diff options
Diffstat (limited to 'doc/go1.2.html')
| -rw-r--r-- | doc/go1.2.html | 979 |
1 files changed, 979 insertions, 0 deletions
diff --git a/doc/go1.2.html b/doc/go1.2.html new file mode 100644 index 000000000..c7a9f8442 --- /dev/null +++ b/doc/go1.2.html @@ -0,0 +1,979 @@ +<!--{ + "Title": "Go 1.2 Release Notes", + "Path": "/doc/go1.2", + "Template": true +}--> + +<h2 id="introduction">Introduction to Go 1.2</h2> + +<p> +Since the release of <a href="/doc/go1.1.html">Go version 1.1</a> in April, 2013, +the release schedule has been shortened to make the release process more efficient. +This release, Go version 1.2 or Go 1.2 for short, arrives roughly six months after 1.1, +while 1.1 took over a year to appear after 1.0. +Because of the shorter time scale, 1.2 is a smaller delta than the step from 1.0 to 1.1, +but it still has some significant developments, including +a better scheduler and one new language feature. +Of course, Go 1.2 keeps the <a href="/doc/go1compat.html">promise +of compatibility</a>. +The overwhelming majority of programs built with Go 1.1 (or 1.0 for that matter) +will run without any changes whatsoever when moved to 1.2, +although the introduction of one restriction +to a corner of the language may expose already-incorrect code +(see the discussion of the <a href="#use_of_nil">use of nil</a>). +</p> + +<h2 id="language">Changes to the language</h2> + +<p> +In the interest of firming up the specification, one corner case has been clarified, +with consequences for programs. +There is also one new language feature. +</p> + +<h3 id="use_of_nil">Use of nil</h3> + +<p> +The language now specifies that, for safety reasons, +certain uses of nil pointers are guaranteed to trigger a run-time panic. +For instance, in Go 1.0, given code like +</p> + +<pre> +type T struct { + X [1<<24]byte + Field int32 +} + +func main() { + var x *T + ... +} +</pre> + +<p> +the <code>nil</code> pointer <code>x</code> could be used to access memory incorrectly: +the expression <code>x.Field</code> could access memory at address <code>1<<24</code>. +To prevent such unsafe behavior, in Go 1.2 the compilers now guarantee that any indirection through +a nil pointer, such as illustrated here but also in nil pointers to arrays, nil interface values, +nil slices, and so on, will either panic or return a correct, safe non-nil value. +In short, any expression that explicitly or implicitly requires evaluation of a nil address is an error. +The implementation may inject extra tests into the compiled program to enforce this behavior. +</p> + +<p> +Further details are in the +<a href="http://golang.org/s/go12nil">design document</a>. +</p> + +<p> +<em>Updating</em>: +Most code that depended on the old behavior is erroneous and will fail when run. +Such programs will need to be updated by hand. +</p> + +<h3 id="three_index">Three-index slices</h3> + +<p> +Go 1.2 adds the ability to specify the capacity as well as the length when using a slicing operation +on an existing array or slice. +A slicing operation creates a new slice by describing a contiguous section of an already-created array or slice: +</p> + +<pre> +var array [10]int +slice := array[2:4] +</pre> + +<p> +The capacity of the slice is the maximum number of elements that the slice may hold, even after reslicing; +it reflects the size of the underlying array. +In this example, the capacity of the <code>slice</code> variable is 8. +</p> + +<p> +Go 1.2 adds new syntax to allow a slicing operation to specify the capacity as well as the length. +A second +colon introduces the capacity value, which must be less than or equal to the capacity of the +source slice or array, adjusted for the origin. For instance, +</p> + +<pre> +slice = array[2:4:7] +</pre> + +<p> +sets the slice to have the same length as in the earlier example but its capacity is now only 5 elements (7-2). +It is impossible to use this new slice value to access the last three elements of the original array. +</p> + +<p> +In this three-index notation, a missing first index (<code>[:i:j]</code>) defaults to zero but the other +two indices must always be specified explicitly. +It is possible that future releases of Go may introduce default values for these indices. +</p> + +<p> +Further details are in the +<a href="http://golang.org/s/go12slice">design document</a>. +</p> + +<p> +<em>Updating</em>: +This is a backwards-compatible change that affects no existing programs. +</p> + +<h2 id="impl">Changes to the implementations and tools</h2> + +<h3 id="preemption">Pre-emption in the scheduler</h3> + +<p> +In prior releases, a goroutine that was looping forever could starve out other +goroutines on the same thread, a serious problem when GOMAXPROCS +provided only one user thread. +In Go 1.2, this is partially addressed: The scheduler is invoked occasionally +upon entry to a function. +This means that any loop that includes a (non-inlined) function call can +be pre-empted, allowing other goroutines to run on the same thread. +</p> + +<h3 id="thread_limit">Limit on the number of threads</h3> + +<p> +Go 1.2 introduces a configurable limit (default 10,000) to the total number of threads +a single program may have in its address space, to avoid resource starvation +issues in some environments. +Note that goroutines are multiplexed onto threads so this limit does not directly +limit the number of goroutines, only the number that may be simultaneously blocked +in a system call. +In practice, the limit is hard to reach. +</p> + +<p> +The new <a href="/pkg/runtime/debug/#SetMaxThreads"><code>SetMaxThreads</code></a> function in the +<a href="/pkg/runtime/debug/"><code>runtime/debug</code></a> package controls the thread count limit. +</p> + +<p> +<em>Updating</em>: +Few functions will be affected by the limit, but if a program dies because it hits the +limit, it could be modified to call <code>SetMaxThreads</code> to set a higher count. +Even better would be to refactor the program to need fewer threads, reducing consumption +of kernel resources. +</p> + +<h3 id="stack_size">Stack size</h3> + +<p> +In Go 1.2, the minimum size of the stack when a goroutine is created has been lifted from 4KB to 8KB. +Many programs were suffering performance problems with the old size, which had a tendency +to introduce expensive stack-segment switching in performance-critical sections. +The new number was determined by empirical testing. +</p> + +<p> +At the other end, the new function <a href="/pkg/runtime/debug/#SetMaxStack"><code>SetMaxStack</code></a> +in the <a href="/pkg/runtime/debug"><code>runtime/debug</code></a> package controls +the <em>maximum</em> size of a single goroutine's stack. +The default is 1GB on 64-bit systems and 250MB on 32-bit systems. +Before Go 1.2, it was too easy for a runaway recursion to consume all the memory on a machine. +</p> + +<p> +<em>Updating</em>: +The increased minimum stack size may cause programs with many goroutines to use +more memory. There is no workaround, but plans for future releases +include new stack management technology that should address the problem better. +</p> + +<h3 id="cgo_and_cpp">Cgo and C++</h3> + +<p> +The <a href="/cmd/cgo/"><code>cgo</code></a> command will now invoke the C++ +compiler to build any pieces of the linked-to library that are written in C++; +<a href="/cmd/cgo/">the documentation</a> has more detail. +</p> + +<h3 id="go_tools_godoc">Godoc and vet moved to the go.tools subrepository</h3> + +<p> +Both binaries are still included with the distribution, but the source code for the +godoc and vet commands has moved to the +<a href="http://code.google.com/p/go.tools">go.tools</a> subrepository. +</p> + +<p> +Also, the core of the godoc program has been split into a +<a href="https://code.google.com/p/go/source/browse/?repo=tools#hg%2Fgodoc">library</a>, +while the command itself is in a separate +<a href="https://code.google.com/p/go/source/browse/?repo=tools#hg%2Fcmd%2Fgodoc">directory</a>. +The move allows the code to be updated easily and the separation into a library and command +makes it easier to construct custom binaries for local sites and different deployment methods. +</p> + +<p> +<em>Updating</em>: +Since godoc and vet are not part of the library, +no client Go code depends on the their source and no updating is required. +</p> + +<p> +The binary distributions available from <a href="http://golang.org">golang.org</a> +include these binaries, so users of these distributions are unaffected. +</p> + +<p> +When building from source, users must use "go get" to install godoc and vet. +(The binaries will continue to be installed in their usual locations, not +<code>$GOPATH/bin</code>.) +</p> + +<pre> +$ go get code.google.com/p/go.tools/cmd/godoc +$ go get code.google.com/p/go.tools/cmd/vet +</pre> + +<h3 id="gccgo">Status of gccgo</h3> + +<p> +We expect the future GCC 4.9 release to include gccgo with full +support for Go 1.2. +In the current (4.8.2) release of GCC, gccgo implements Go 1.1.2. +</p> + +<h3 id="gc_changes">Changes to the gc compiler and linker</h3> + +<p> +Go 1.2 has several semantic changes to the workings of the gc compiler suite. +Most users will be unaffected by them. +</p> + +<p> +The <a href="/cmd/cgo/"><code>cgo</code></a> command now +works when C++ is included in the library being linked against. +See the <a href="/cmd/cgo/"><code>cgo</code></a> documentation +for details. +</p> + +<p> +The gc compiler displayed a vestigial detail of its origins when +a program had no <code>package</code> clause: it assumed +the file was in package <code>main</code>. +The past has been erased, and a missing <code>package</code> clause +is now an error. +</p> + +<p> +On the ARM, the toolchain supports "external linking", which +is a step towards being able to build shared libraries with the gc +tool chain and to provide dynamic linking support for environments +in which that is necessary. +</p> + +<p> +In the runtime for the ARM, with <code>5a</code>, it used to be possible to refer +to the runtime-internal <code>m</code> (machine) and <code>g</code> +(goroutine) variables using <code>R9</code> and <code>R10</code> directly. +It is now necessary to refer to them by their proper names. +</p> + +<p> +Also on the ARM, the <code>5l</code> linker (sic) now defines the +<code>MOVBS</code> and <code>MOVHS</code> instructions +as synonyms of <code>MOVB</code> and <code>MOVH</code>, +to make clearer the separation between signed and unsigned +sub-word moves; the unsigned versions already existed with a +<code>U</code> suffix. +</p> + +<h3 id="cover">Test coverage</h3> + +<p> +One major new feature of <a href="/pkg/go/"><code>go test</code></a> is +that it can now compute and, with help from a new, separately installed +"go tool cover" program, display test coverage results. +</p> + +<p> +The cover tool is part of the +<a href="https://code.google.com/p/go/source/checkout?repo=tools"><code>go.tools</code></a> +subrepository. +It can be installed by running +</p> + +<pre> +$ go get code.google.com/p/go.tools/cmd/cover +</pre> + +<p> +The cover tool does two things. +First, when "go test" is given the <code>-cover</code> flag, it is run automatically +to rewrite the source for the package and insert instrumentation statements. +The test is then compiled and run as usual, and basic coverage statistics are reported: +</p> + +<pre> +$ go test -cover fmt +ok fmt 0.060s coverage: 91.4% of statements +$ +</pre> + +<p> +Second, for more detailed reports, different flags to "go test" can create a coverage profile file, +which the cover program, invoked with "go tool cover", can then analyze. +</p> + +<p> +Details on how to generate and analyze coverage statistics can be found by running the commands +</p> + +<pre> +$ go help testflag +$ go tool cover -help +</pre> + +<h3 id="go_doc">The go doc command is deleted</h3> + +<p> +The "go doc" command is deleted. +Note that the <a href="/cmd/godoc/"><code>godoc</code></a> tool itself is not deleted, +just the wrapping of it by the <a href="/cmd/go/"><code>go</code></a> command. +All it did was show the documents for a package by package path, +which godoc itself already does with more flexibility. +It has therefore been deleted to reduce the number of documentation tools and, +as part of the restructuring of godoc, encourage better options in future. +</p> + +<p> +<em>Updating</em>: For those who still need the precise functionality of running +</p> + +<pre> +$ go doc +</pre> + +<p> +in a directory, the behavior is identical to running +</p> + +<pre> +$ godoc . +</pre> + +<h3 id="gocmd">Changes to the go command</h3> + +<p> +The <a href="/cmd/go/"><code>go get</code></a> command +now has a <code>-t</code> flag that causes it to download the dependencies +of the tests run by the package, not just those of the package itself. +By default, as before, dependencies of the tests are not downloaded. +</p> + +<h2 id="performance">Performance</h2> + +<p> +There are a number of significant performance improvements in the standard library; here are a few of them. +</p> + +<ul> + +<li> +The <a href="/pkg/compress/bzip2/"><code>compress/bzip2</code></a> +decompresses about 30% faster. +</li> + +<li> +The <a href="/pkg/crypto/des/"><code>crypto/des</code></a> package +is about five times faster. +</li> + +<li> +The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package +encodes about 30% faster. +</li> + +<li> +Networking performance on Windows and BSD systems is about 30% faster through the use +of an integrated network poller in the runtime, similar to what was done for Linux and OS X +in Go 1.1. +</li> + +</ul> + +<h2 id="library">Changes to the standard library</h2> + + +<h3 id="archive_tar_zip">The archive/tar and archive/zip packages</h3> + +<p> +The +<a href="/pkg/archive/tar/"><code>archive/tar</code></a> +and +<a href="/pkg/archive/zip/"><code>archive/zip</code></a> +packages have had a change to their semantics that may break existing programs. +The issue is that they both provided an implementation of the +<a href="/pkg/os/#FileInfo"><code>os.FileInfo</code></a> +interface that was not compliant with the specification for that interface. +In particular, their <code>Name</code> method returned the full +path name of the entry, but the interface specification requires that +the method return only the base name (final path element). +</p> + +<p> +<em>Updating</em>: Since this behavior was newly implemented and +a bit obscure, it is possible that no code depends on the broken behavior. +If there are programs that do depend on it, they will need to be identified +and fixed manually. +</p> + +<h3 id="encoding">The new encoding package</h3> + +<p> +There is a new package, <a href="/pkg/encoding/"><code>encoding</code></a>, +that defines a set of standard encoding interfaces that may be used to +build custom marshalers and unmarshalers for packages such as +<a href="/pkg/encoding/xml/"><code>encoding/xml</code></a>, +<a href="/pkg/encoding/json/"><code>encoding/json</code></a>, +and +<a href="/pkg/encoding/binary/"><code>encoding/binary</code></a>. +These new interfaces have been used to tidy up some implementations in +the standard library. +</p> + +<p> +The new interfaces are called +<a href="/pkg/encoding/#BinaryMarshaler"><code>BinaryMarshaler</code></a>, +<a href="/pkg/encoding/#BinaryUnmarshaler"><code>BinaryUnmarshaler</code></a>, +<a href="/pkg/encoding/#TextMarshaler"><code>TextMarshaler</code></a>, +and +<a href="/pkg/encoding/#TextUnmarshaler"><code>TextUnmarshaler</code></a>. +Full details are in the <a href="/pkg/encoding/">documentation</a> for the package +and a separate <a href="http://golang.org/s/go12encoding">design document</a>. +</p> + +<h3 id="fmt_indexed_arguments">The fmt package</h3> + +<p> +The <a href="/pkg/fmt/"><code>fmt</code></a> package's formatted print +routines such as <a href="/pkg/fmt/#Printf"><code>Printf</code></a> +now allow the data items to be printed to be accessed in arbitrary order +by using an indexing operation in the formatting specifications. +Wherever an argument is to be fetched from the argument list for formatting, +either as the value to be formatted or as a width or specification integer, +a new optional indexing notation <code>[</code><em>n</em><code>]</code> +fetches argument <em>n</em> instead. +The value of <em>n</em> is 1-indexed. +After such an indexing operating, the next argument to be fetched by normal +processing will be <em>n</em>+1. +</p> + +<p> +For example, the normal <code>Printf</code> call +</p> + +<pre> +fmt.Sprintf("%c %c %c\n", 'a', 'b', 'c') +</pre> + +<p> +would create the string <code>"a b c"</code>, but with indexing operations like this, +</p> + +<pre> +fmt.Sprintf("%[3]c %[1]c %c\n", 'a', 'b', 'c') +</pre> + +<p> +the result is "<code>"c a b"</code>. The <code>[3]</code> index accesses the third formatting +argument, which is <code>'c'</code>, <code>[1]</code> accesses the first, <code>'a'</code>, +and then the next fetch accesses the argument following that one, <code>'b'</code>. +</p> + +<p> +The motivation for this feature is programmable format statements to access +the arguments in different order for localization, but it has other uses: +</p> + +<pre> +log.Printf("trace: value %v of type %[1]T\n", expensiveFunction(a.b[c])) +</pre> + +<p> +<em>Updating</em>: The change to the syntax of format specifications +is strictly backwards compatible, so it affects no working programs. +</p> + +<h3 id="text_template">The text/template and html/template packages</h3> + +<p> +The +<a href="/pkg/text/template/"><code>text/template</code></a> package +has a couple of changes in Go 1.2, both of which are also mirrored in the +<a href="/pkg/html/template/"><code>html/template</code></a> package. +</p> + +<p> +First, there are new default functions for comparing basic types. +The functions are listed in this table, which shows their names and +the associated familiar comparison operator. +</p> + +<table cellpadding="0" summary="Template comparison functions"> +<tr> +<th width="50"></th><th width="100">Name</th> <th width="50">Operator</th> +</tr> +<tr> +<td></td><td><code>eq</code></td> <td><code>==</code></td> +</tr> +<tr> +<td></td><td><code>ne</code></td> <td><code>!=</code></td> +</tr> +<tr> +<td></td><td><code>lt</code></td> <td><code><</code></td> +</tr> +<tr> +<td></td><td><code>le</code></td> <td><code><=</code></td> +</tr> +<tr> +<td></td><td><code>gt</code></td> <td><code>></code></td> +</tr> +<tr> +<td></td><td><code>ge</code></td> <td><code>>=</code></td> +</tr> +</table> + +<p> +These functions behave slightly differently from the corresponding Go operators. +First, they operate only on basic types (<code>bool</code>, <code>int</code>, +<code>float64</code>, <code>string</code>, etc.). +(Go allows comparison of arrays and structs as well, under some circumstances.) +Second, values can be compared as long as they are the same sort of value: +any signed integer value can be compared to any other signed integer value for example. (Go +does not permit comparing an <code>int8</code> and an <code>int16</code>). +Finally, the <code>eq</code> function (only) allows comparison of the first +argument with one or more following arguments. The template in this example, +</p> + +<pre> +{{"{{"}}if eq .A 1 2 3 {{"}}"}} equal {{"{{"}}else{{"}}"}} not equal {{"{{"}}end{{"}}"}} +</pre> + +<p> +reports "equal" if <code>.A</code> is equal to <em>any</em> of 1, 2, or 3. +</p> + +<p> +The second change is that a small addition to the grammar makes "if else if" chains easier to write. +Instead of writing, +</p> + +<pre> +{{"{{"}}if eq .A 1{{"}}"}} X {{"{{"}}else{{"}}"}} {{"{{"}}if eq .A 2{{"}}"}} Y {{"{{"}}end{{"}}"}} {{"{{"}}end{{"}}"}} +</pre> + +<p> +one can fold the second "if" into the "else" and have only one "end", like this: +</p> + +<pre> +{{"{{"}}if eq .A 1{{"}}"}} X {{"{{"}}else if eq .A 2{{"}}"}} Y {{"{{"}}end{{"}}"}} +</pre> + +<p> +The two forms are identical in effect; the difference is just in the syntax. +</p> + +<p> +<em>Updating</em>: Neither the "else if" change nor the comparison functions +affect existing programs. Those that +already define functions called <code>eq</code> and so on through a function +map are unaffected because the associated function map will override the new +default function definitions. +</p> + +<h3 id="new_packages">New packages</h3> + +<p> +There are two new packages. +</p> + +<ul> +<li> +The <a href="/pkg/encoding/"><code>encoding</code></a> package is +<a href="#encoding">described above</a>. +</li> +<li> +The <a href="/pkg/image/color/palette/"><code>image/color/palette</code></a> package +provides standard color palettes. +</li> +</ul> + +<h3 id="minor_library_changes">Minor changes to the library</h3> + +<p> +The following list summarizes a number of minor changes to the library, mostly additions. +See the relevant package documentation for more information about each change. +</p> + +<ul> + +<li> +The <a href="/pkg/archive/zip/"><code>archive/zip</code></a> package +adds the +<a href="/pkg/archive/zip/#File.DataOffset"><code>DataOffset</code></a> accessor +to return the offset of a file's (possibly compressed) data within the archive. +</li> + +<li> +The <a href="/pkg/bufio/"><code>bufio</code></a> package +adds <a href="/pkg/bufio/#Reader.Reset"><code>Reset</code></a> +methods to <a href="/pkg/bufio/#Reader"><code>Reader</code></a> and +<a href="/pkg/bufio/#Writer"><code>Writer</code></a>. +These methods allow the <a href="/pkg/io/#Reader"><code>Readers</code></a> +and <a href="/pkg/io/#Writer"><code>Writers</code></a> +to be re-used on new input and output readers and writers, saving +allocation overhead. +</li> + +<li> +The <a href="/pkg/compress/bzip2/"><code>compress/bzip2</code></a> +can now decompress concatenated archives. +</li> + +<li> +The <a href="/pkg/compress/flate/"><code>compress/flate</code></a> +package adds a <a href="/pkg/compress/flate/#Writer.Reset"><code>Reset</code></a> +method on the <a href="/pkg/compress/flate/#Writer"><code>Writer</code></a>, +to make it possible to reduce allocation when, for instance, constructing an +archive to hold multiple compressed files. +</li> + +<li> +The <a href="/pkg/compress/gzip/"><code>compress/gzip</code></a> package's +<a href="/pkg/compress/gzip/#Writer"><code>Writer</code></a> type adds a +<a href="/pkg/compress/gzip/#Writer.Reset"><code>Reset</code></a> +so it may be reused. +</li> + +<li> +The <a href="/pkg/compress/zlib/"><code>compress/zlib</code></a> package's +<a href="/pkg/compress/zlib/#Writer"><code>Writer</code></a> type adds a +<a href="/pkg/compress/zlib/#Writer.Reset"><code>Reset</code></a> +so it may be reused. +</li> + +<li> +The <a href="/pkg/container/heap/"><code>container/heap</code></a> package +adds a <a href="/pkg/container/heap/#Fix"><code>Fix</code></a> +method to provide a more efficient way to update an item's position in the heap. +</li> + +<li> +The <a href="/pkg/container/list/"><code>container/list</code></a> package +adds the <a href="/pkg/container/list/#List.MoveBefore"><code>MoveBefore</code></a> +and +<a href="/pkg/container/list/#List.MoveAfter"><code>MoveAfter</code></a> +methods, which implement the obvious rearrangement. +</li> + +<li> +The <a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a> package +adds the a new GCM mode (Galois Counter Mode), which is almost always +used with AES encryption. +</li> + +<li> +The +<a href="/pkg/crypto/md5/"><code>crypto/md5</code></a> package +adds a new <a href="/pkg/crypto/md5/#Sum"><code>Sum</code></a> function +to simplify hashing without sacrificing performance. +</li> + +<li> +Similarly, the +<a href="/pkg/crypto/md5/"><code>crypto/sha1</code></a> package +adds a new <a href="/pkg/crypto/sha1/#Sum"><code>Sum</code></a> function. +</li> + +<li> +Also, the +<a href="/pkg/crypto/sha256/"><code>crypto/sha256</code></a> package +adds <a href="/pkg/crypto/sha256/#Sum256"><code>Sum256</code></a> +and <a href="/pkg/crypto/sha256/#Sum224"><code>Sum224</code></a> functions. +</li> + +<li> +Finally, the <a href="/pkg/crypto/sha512/"><code>crypto/sha512</code></a> package +adds <a href="/pkg/crypto/sha512/#Sum512"><code>Sum512</code></a> and +<a href="/pkg/crypto/sha512/#Sum384"><code>Sum384</code></a> functions. +</li> + +<li> +The <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package +adds support for reading and writing arbitrary extensions. +</li> + +<li> +The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package adds +support for TLS 1.1, 1.2 and AES-GCM. +</li> + +<li> +The <a href="/pkg/database/sql/"><code>database/sql</code></a> package adds a +<a href="/pkg/database/sql/#DB.SetMaxOpenConns"><code>SetMaxOpenConns</code></a> +method on <a href="/pkg/database/sql/#DB"><code>DB</code></a> to limit the +number of open connections to the database. +</li> + +<li> +The <a href="/pkg/encoding/csv/"><code>encoding/csv</code></a> package +now always allows trailing commas on fields. +</li> + +<li> +The <a href="/pkg/encoding/gob/"><code>encoding/gob</code></a> package +now treats channel and function fields of structures as if they were unexported, +even if they are not. That is, it ignores them completely. Previously they would +trigger an error, which could cause unexpected compatibility problems if an +embedded structure added such a field. +The package also now supports the generic <code>BinaryMarshaler</code> and +<code>BinaryUnmarshaler</code> interfaces of the +<a href="/pkg/encoding/"><code>encoding</code></a> package +described above. +</li> + +<li> +The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package +now will always escape ampersands as "\u0026" when printing strings. +It will now accept but correct invalid UTF-8 in +<a href="/pkg/encoding/json/#Marshal"><code>Marshal</code></a> +(such input was previously rejected). +Finally, it now supports the generic encoding interfaces of the +<a href="/pkg/encoding/"><code>encoding</code></a> package +described above. +</li> + +<li> +The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package +now allows attributes stored in pointers to be marshaled. +It also supports the generic encoding interfaces of the +<a href="/pkg/encoding/"><code>encoding</code></a> package +described above through the new +<a href="/pkg/encoding/xml/#Marshaler"><code>Marshaler</code></a>, +<a href="/pkg/encoding/xml/#Unmarshaler"><code>Unmarshaler</code></a>, +and related +<a href="/pkg/encoding/xml/#MarshalerAttr"><code>MarshalerAttr</code></a> and +<a href="/pkg/encoding/xml/#UnmarshalerAttr"><code>UnmarshalerAttr</code></a> +interfaces. +The package also adds a +<a href="/pkg/encoding/xml/#Encoder.Flush"><code>Flush</code></a> method +to the +<a href="/pkg/encoding/xml/#Encoder"><code>Encoder</code></a> +type for use by custom encoders. See the documentation for +<a href="/pkg/encoding/xml/#Encoder.EncodeToken"><code>EncodeToken</code></a> +to see how to use it. +</li> + +<li> +The <a href="/pkg/flag/"><code>flag</code></a> package now +has a <a href="/pkg/flag/#Getter"><code>Getter</code></a> interface +to allow the value of a flag to be retrieved. Due to the +Go 1 compatibility guidelines, this method cannot be added to the existing +<a href="/pkg/flag/#Value"><code>Value</code></a> +interface, but all the existing standard flag types implement it. +The package also now exports the <a href="/pkg/flag/#CommandLine"><code>CommandLine</code></a> +flag set, which holds the flags from the command line. +</li> + +<li> +The <a href="/pkg/go/ast/"><code>go/ast</code></a> package's +<a href="/pkg/go/ast/#SliceExpr"><code>SliceExpr</code></a> struct +has a new boolean field, <code>Slice3</code>, which is set to true +when representing a slice expression with three indices (two colons). +The default is false, representing the usual two-index form. +</li> + +<li> +The <a href="/pkg/go/build/"><code>go/build</code></a> package adds +the <code>AllTags</code> field +to the <a href="/pkg/go/build/#Package"><code>Package</code></a> type, +to make it easier to process build tags. +</li> + +<li> +The <a href="/pkg/image/draw/"><code>image/draw</code></a> package now +exports an interface, <a href="/pkg/image/draw/#Drawer"><code>Drawer</code></a>, +that wraps the standard <a href="/pkg/image/draw/#Draw"><code>Draw</code></a> method. +The Porter-Duff operators now implement this interface, in effect binding an operation to +the draw operator rather than providing it explicitly. +Given a paletted image as its destination, the new +<a href="/pkg/image/draw/#FloydSteinberg"><code>FloydSteinberg</code></a> +implementation of the +<a href="/pkg/image/draw/#Drawer"><code>Drawer</code></a> +interface will use the Floyd-Steinberg error diffusion algorithm to draw the image. +To create palettes suitable for such processing, the new +<a href="/pkg/image/draw/#Quantizer"><code>Quantizer</code></a> interface +represents implementations of quantization algorithms that choose a palette +given a full-color image. +There are no implementations of this interface in the library. +</li> + +<li> +The <a href="/pkg/image/gif/"><code>image/gif</code></a> package +can now create GIF files using the new +<a href="/pkg/image/gif/#Encode"><code>Encode</code></a> +and <a href="/pkg/image/gif/#EncodeAll"><code>EncodeAll</code></a> +functions. +Their options argument allows specification of an image +<a href="/pkg/image/draw/#Quantizer"><code>Quantizer</code></a> to use; +if it is <code>nil</code>, the generated GIF will use the +<a href="/pkg/image/color/palette/#Plan9"><code>Plan9</code></a> +color map (palette) defined in the new +<a href="/pkg/image/color/palette/"><code>image/color/palette</code></a> package. +The options also specify a +<a href="/pkg/image/draw/#Drawer"><code>Drawer</code></a> +to use to create the output image; +if it is <code>nil</code>, Floyd-Steinberg error diffusion is used. +</li> + +<li> +The <a href="/pkg/io/#Copy"><code>Copy</code></a> method of the +<a href="/pkg/io/"><code>io</code></a> package now prioritizes its +arguments differently. +If one argument implements <a href="/pkg/io/#WriterTo"><code>WriterTo</code></a> +and the other implements <a href="/pkg/io/#ReaderFrom"><code>ReaderFrom</code></a>, +<a href="/pkg/io/#Copy"><code>Copy</code></a> will now invoke +<a href="/pkg/io/#WriterTo"><code>WriterTo</code></a> to do the work, +so that less intermediate buffering is required in general. +</li> + +<li> +The <a href="/pkg/net/"><code>net</code></a> package requires cgo by default +because the host operating system must in general mediate network call setup. +On some systems, though, it is possible to use the network without cgo, and useful +to do so, for instance to avoid dynamic linking. +The new build tag <code>netgo</code> (off by default) allows the construction of a +<code>net</code> package in pure Go on those systems where it is possible. +</li> + +<li> +The <a href="/pkg/net/"><code>net</code></a> package adds a new field +<code>DualStack</code> to the <a href="/pkg/net/#Dialer"><code>Dialer</code></a> +struct for TCP connection setup using a dual IP stack as described in +<a href="http://tools.ietf.org/html/rfc6555">RFC 6555</a>. +</li> + +<li> +The <a href="/pkg/net/http/"><code>net/http</code></a> package will no longer +transmit cookies that are incorrect according to +<a href="http://tools.ietf.org/html/rfc6265">RFC 6265</a>. +It just logs an error and sends nothing. +Also, +the <a href="/pkg/net/http/"><code>net/http</code></a> package's +<a href="/pkg/net/http/#ReadResponse"><code>ReadResponse</code></a> +function now permits the <code>*Request</code> parameter to be <code>nil</code>, +whereupon it assumes a GET request. +Finally, an HTTP server will now serve HEAD +requests transparently, without the need for special casing in handler code. +While serving a HEAD request, writes to a +<a href="/pkg/net/http/#Handler"><code>Handler</code></a>'s +<a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a> +are absorbed by the +<a href="/pkg/net/http/#Server"><code>Server</code></a> +and the client receives an empty body as required by the HTTP specification. +</li> + +<li> +The <a href="/pkg/os/exec/"><code>os/exec</code></a> package's +<a href="/pkg/os/exec/#Cmd.StdinPipe"><code>Cmd.StdinPipe</code></a> method +returns an <code>io.WriteCloser</code>, but has changed its concrete +implementation from <code>*os.File</code> to an unexported type that embeds +<code>*os.File</code>, and it is now safe to close the returned value. +Before Go 1.2, there was an unavoidable race that this change fixes. +Code that needs access to the methods of <code>*os.File</code> can use an +interface type assertion, such as <code>wc.(interface{ Sync() error })</code>. +</li> + +<li> +The <a href="/pkg/runtime/"><code>runtime</code></a> package relaxes +the constraints on finalizer functions in +<a href="/pkg/runtime/#SetFinalizer"><code>SetFinalizer</code></a>: the +actual argument can now be any type that is assignable to the formal type of +the function, as is the case for any normal function call in Go. +</li> + +<li> +The <a href="/pkg/sort/"><code>sort</code></a> package has a new +<a href="/pkg/sort/#Stable"><code>Stable</code></a> function that implements +stable sorting. It is less efficient than the normal sort algorithm, however. +</li> + +<li> +The <a href="/pkg/strings/"><code>strings</code></a> package adds +an <a href="/pkg/strings/#IndexByte"><code>IndexByte</code></a> +function for consistency with the <a href="/pkg/bytes/"><code>bytes</code></a> package. +</li> + +<li> +The <a href="/pkg/sync/atomic/"><code>sync/atomic</code></a> package +adds a new set of swap functions that atomically exchange the argument with the +value stored in the pointer, returning the old value. +The functions are +<a href="/pkg/sync/atomic/#SwapInt32"><code>SwapInt32</code></a>, +<a href="/pkg/sync/atomic/#SwapInt64"><code>SwapInt64</code></a>, +<a href="/pkg/sync/atomic/#SwapUint32"><code>SwapUint32</code></a>, +<a href="/pkg/sync/atomic/#SwapUint64"><code>SwapUint64</code></a>, +<a href="/pkg/sync/atomic/#SwapUintptr"><code>SwapUintptr</code></a>, +and +<a href="/pkg/sync/atomic/#SwapPointer"><code>SwapPointer</code></a>, +which swaps an <code>unsafe.Pointer</code>. +</li> + +<li> +The <a href="/pkg/syscall/"><code>syscall</code></a> package now implements +<a href="/pkg/syscall/#Sendfile"><code>Sendfile</code></a> for Darwin. +</li> + +<li> +The <a href="/pkg/testing/"><code>testing</code></a> package +now exports the <a href="/pkg/testing/#TB"><code>TB</code></a> interface. +It records the methods in common with the +<a href="/pkg/testing/#T"><code>T</code></a> +and +<a href="/pkg/testing/#B"><code>B</code></a> types, +to make it easier to share code between tests and benchmarks. +Also, the +<a href="/pkg/testing/#AllocsPerRun"><code>AllocsPerRun</code></a> +function now quantizes the return value to an integer (although it +still has type <code>float64</code>), to round off any error caused by +initialization and make the result more repeatable. +</li> + +<li> +The <a href="/pkg/text/template/"><code>text/template</code></a> package +now automatically dereferences pointer values when evaluating the arguments +to "escape" functions such as "html", to bring the behavior of such functions +in agreement with that of other printing functions such as "printf". +</li> + +<li> +In the <a href="/pkg/time/"><code>time</code></a> package, the +<a href="/pkg/time/#Parse"><code>Parse</code></a> function +and +<a href="/pkg/time/#Time.Format"><code>Format</code></a> +method +now handle time zone offsets with seconds, such as in the historical +date "1871-01-01T05:33:02+00:34:08". +Also, pattern matching in the formats for those routines is stricter: a non-lowercase letter +must now follow the standard words such as "Jan" and "Mon". +</li> + +<li> +The <a href="/pkg/unicode/"><code>unicode</code></a> package +adds <a href="/pkg/unicode/#In"><code>In</code></a>, +a nicer-to-use but equivalent version of the original +<a href="/pkg/unicode/#IsOneOf"><code>IsOneOf</code></a>, +to see whether a character is a member of a Unicode category. +</li> + +</ul> |