"Fossies" - the Fresh Open Source Software Archive

Member "go/doc/go1.1.html" (9 Sep 2020, 40411 Bytes) of package /windows/misc/go1.14.9.windows-386.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) HTML source code syntax highlighting (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file.

    1 <!--{
    2     "Title": "Go 1.1 Release Notes",
    3     "Path":  "/doc/go1.1",
    4     "Template": true
    5 }-->
    6 
    7 <h2 id="introduction">Introduction to Go 1.1</h2>
    8 
    9 <p>
   10 The release of <a href="/doc/go1.html">Go version 1</a> (Go 1 or Go 1.0 for short)
   11 in March of 2012 introduced a new period
   12 of stability in the Go language and libraries.
   13 That stability has helped nourish a growing community of Go users
   14 and systems around the world.
   15 Several "point" releases since
   16 then—1.0.1, 1.0.2, and 1.0.3—have been issued.
   17 These point releases fixed known bugs but made
   18 no non-critical changes to the implementation.
   19 </p>
   20 
   21 <p>
   22 This new release, Go 1.1, keeps the <a href="/doc/go1compat.html">promise
   23 of compatibility</a> but adds a couple of significant
   24 (backwards-compatible, of course) language changes, has a long list
   25 of (again, compatible) library changes, and
   26 includes major work on the implementation of the compilers,
   27 libraries, and run-time.
   28 The focus is on performance.
   29 Benchmarking is an inexact science at best, but we see significant,
   30 sometimes dramatic speedups for many of our test programs.
   31 We trust that many of our users' programs will also see improvements
   32 just by updating their Go installation and recompiling.
   33 </p>
   34 
   35 <p>
   36 This document summarizes the changes between Go 1 and Go 1.1.
   37 Very little if any code will need modification to run with Go 1.1,
   38 although a couple of rare error cases surface with this release
   39 and need to be addressed if they arise.
   40 Details appear below; see the discussion of
   41 <a href="#int">64-bit ints</a> and <a href="#unicode_literals">Unicode literals</a>
   42 in particular.
   43 </p>
   44 
   45 <h2 id="language">Changes to the language</h2>
   46 
   47 <p>
   48 <a href="/doc/go1compat.html">The Go compatibility document</a> promises
   49 that programs written to the Go 1 language specification will continue to operate,
   50 and those promises are maintained.
   51 In the interest of firming up the specification, though, there are
   52 details about some error cases that have been clarified.
   53 There are also some new language features.
   54 </p>
   55 
   56 <h3 id="divzero">Integer division by zero</h3>
   57 
   58 <p>
   59 In Go 1, integer division by a constant zero produced a run-time panic:
   60 </p>
   61 
   62 <pre>
   63 func f(x int) int {
   64     return x/0
   65 }
   66 </pre>
   67 
   68 <p>
   69 In Go 1.1, an integer division by constant zero is not a legal program, so it is a compile-time error.
   70 </p>
   71 
   72 <h3 id="unicode_literals">Surrogates in Unicode literals</h3>
   73 
   74 <p>
   75 The definition of string and rune literals has been refined to exclude surrogate halves from the
   76 set of valid Unicode code points.
   77 See the <a href="#unicode">Unicode</a> section for more information.
   78 </p>
   79 
   80 <h3 id="method_values">Method values</h3>
   81 
   82 <p>
   83 Go 1.1 now implements
   84 <a href="/ref/spec#Method_values">method values</a>,
   85 which are functions that have been bound to a specific receiver value.
   86 For instance, given a
   87 <a href="/pkg/bufio/#Writer"><code>Writer</code></a>
   88 value <code>w</code>,
   89 the expression
   90 <code>w.Write</code>,
   91 a method value, is a function that will always write to <code>w</code>; it is equivalent to
   92 a function literal closing over <code>w</code>:
   93 </p>
   94 
   95 <pre>
   96 func (p []byte) (n int, err error) {
   97     return w.Write(p)
   98 }
   99 </pre>
  100 
  101 <p>
  102 Method values are distinct from method expressions, which generate functions
  103 from methods of a given type; the method expression <code>(*bufio.Writer).Write</code>
  104 is equivalent to a function with an extra first argument, a receiver of type
  105 <code>(*bufio.Writer)</code>:
  106 </p>
  107 
  108 <pre>
  109 func (w *bufio.Writer, p []byte) (n int, err error) {
  110     return w.Write(p)
  111 }
  112 </pre>
  113 
  114 <p>
  115 <em>Updating</em>: No existing code is affected; the change is strictly backward-compatible.
  116 </p>
  117 
  118 <h3 id="return">Return requirements</h3>
  119 
  120 <p>
  121 Before Go 1.1, a function that returned a value needed an explicit "return"
  122 or call to <code>panic</code> at
  123 the end of the function; this was a simple way to make the programmer
  124 be explicit about the meaning of the function. But there are many cases
  125 where a final "return" is clearly unnecessary, such as a function with
  126 only an infinite "for" loop.
  127 </p>
  128 
  129 <p>
  130 In Go 1.1, the rule about final "return" statements is more permissive.
  131 It introduces the concept of a
  132 <a href="/ref/spec#Terminating_statements"><em>terminating statement</em></a>,
  133 a statement that is guaranteed to be the last one a function executes.
  134 Examples include
  135 "for" loops with no condition and "if-else"
  136 statements in which each half ends in a "return".
  137 If the final statement of a function can be shown <em>syntactically</em> to
  138 be a terminating statement, no final "return" statement is needed.
  139 </p>
  140 
  141 <p>
  142 Note that the rule is purely syntactic: it pays no attention to the values in the
  143 code and therefore requires no complex analysis.
  144 </p>
  145 
  146 <p>
  147 <em>Updating</em>: The change is backward-compatible, but existing code
  148 with superfluous "return" statements and calls to <code>panic</code> may
  149 be simplified manually.
  150 Such code can be identified by <code>go vet</code>.
  151 </p>
  152 
  153 <h2 id="impl">Changes to the implementations and tools</h2>
  154 
  155 <h3 id="gccgo">Status of gccgo</h3>
  156 
  157 <p>
  158 The GCC release schedule does not coincide with the Go release schedule, so some skew is inevitable in
  159 <code>gccgo</code>'s releases.
  160 The 4.8.0 version of GCC shipped in March, 2013 and includes a nearly-Go 1.1 version of <code>gccgo</code>.
  161 Its library is a little behind the release, but the biggest difference is that method values are not implemented.
  162 Sometime around July 2013, we expect 4.8.2 of GCC to ship with a <code>gccgo</code>
  163 providing a complete Go 1.1 implementation.
  164 </p>
  165 
  166 <h3 id="gc_flag">Command-line flag parsing</h3>
  167 
  168 <p>
  169 In the gc toolchain, the compilers and linkers now use the
  170 same command-line flag parsing rules as the Go flag package, a departure
  171 from the traditional Unix flag parsing. This may affect scripts that invoke
  172 the tool directly.
  173 For example,
  174 <code>go tool 6c -Fw -Dfoo</code> must now be written
  175 <code>go tool 6c -F -w -D foo</code>.
  176 </p>
  177 
  178 <h3 id="int">Size of int on 64-bit platforms</h3>
  179 
  180 <p>
  181 The language allows the implementation to choose whether the <code>int</code> type and
  182 <code>uint</code> types are 32 or 64 bits. Previous Go implementations made <code>int</code>
  183 and <code>uint</code> 32 bits on all systems. Both the gc and gccgo implementations
  184 now make
  185 <code>int</code> and <code>uint</code> 64 bits on 64-bit platforms such as AMD64/x86-64.
  186 Among other things, this enables the allocation of slices with
  187 more than 2 billion elements on 64-bit platforms.
  188 </p>
  189 
  190 <p>
  191 <em>Updating</em>:
  192 Most programs will be unaffected by this change.
  193 Because Go does not allow implicit conversions between distinct
  194 <a href="/ref/spec#Numeric_types">numeric types</a>,
  195 no programs will stop compiling due to this change.
  196 However, programs that contain implicit assumptions
  197 that <code>int</code> is only 32 bits may change behavior.
  198 For example, this code prints a positive number on 64-bit systems and
  199 a negative one on 32-bit systems:
  200 </p>
  201 
  202 <pre>
  203 x := ^uint32(0) // x is 0xffffffff
  204 i := int(x)     // i is -1 on 32-bit systems, 0xffffffff on 64-bit
  205 fmt.Println(i)
  206 </pre>
  207 
  208 <p>Portable code intending 32-bit sign extension (yielding <code>-1</code> on all systems)
  209 would instead say:
  210 </p>
  211 
  212 <pre>
  213 i := int(int32(x))
  214 </pre>
  215 
  216 <h3 id="heap">Heap size on 64-bit architectures</h3>
  217 
  218 <p>
  219 On 64-bit architectures, the maximum heap size has been enlarged substantially,
  220 from a few gigabytes to several tens of gigabytes.
  221 (The exact details depend on the system and may change.)
  222 </p>
  223 
  224 <p>
  225 On 32-bit architectures, the heap size has not changed.
  226 </p>
  227 
  228 <p>
  229 <em>Updating</em>:
  230 This change should have no effect on existing programs beyond allowing them
  231 to run with larger heaps.
  232 </p>
  233 
  234 <h3 id="unicode">Unicode</h3>
  235 
  236 <p>
  237 To make it possible to represent code points greater than 65535 in UTF-16,
  238 Unicode defines <em>surrogate halves</em>,
  239 a range of code points to be used only in the assembly of large values, and only in UTF-16.
  240 The code points in that surrogate range are illegal for any other purpose.
  241 In Go 1.1, this constraint is honored by the compiler, libraries, and run-time:
  242 a surrogate half is illegal as a rune value, when encoded as UTF-8, or when
  243 encoded in isolation as UTF-16.
  244 When encountered, for example in converting from a rune to UTF-8, it is
  245 treated as an encoding error and will yield the replacement rune,
  246 <a href="/pkg/unicode/utf8/#RuneError"><code>utf8.RuneError</code></a>,
  247 U+FFFD.
  248 </p>
  249 
  250 <p>
  251 This program,
  252 </p>
  253 
  254 <pre>
  255 import "fmt"
  256 
  257 func main() {
  258     fmt.Printf("%+q\n", string(0xD800))
  259 }
  260 </pre>
  261 
  262 <p>
  263 printed <code>"\ud800"</code> in Go 1.0, but prints <code>"\ufffd"</code> in Go 1.1.
  264 </p>
  265 
  266 <p>
  267 Surrogate-half Unicode values are now illegal in rune and string constants, so constants such as
  268 <code>'\ud800'</code> and <code>"\ud800"</code> are now rejected by the compilers.
  269 When written explicitly as UTF-8 encoded bytes,
  270 such strings can still be created, as in <code>"\xed\xa0\x80"</code>.
  271 However, when such a string is decoded as a sequence of runes, as in a range loop, it will yield only <code>utf8.RuneError</code>
  272 values.
  273 </p>
  274 
  275 <p>
  276 The Unicode byte order mark U+FEFF, encoded in UTF-8, is now permitted as the first
  277 character of a Go source file.
  278 Even though its appearance in the byte-order-free UTF-8 encoding is clearly unnecessary,
  279 some editors add the mark as a kind of "magic number" identifying a UTF-8 encoded file.
  280 </p>
  281 
  282 <p>
  283 <em>Updating</em>:
  284 Most programs will be unaffected by the surrogate change.
  285 Programs that depend on the old behavior should be modified to avoid the issue.
  286 The byte-order-mark change is strictly backward-compatible.
  287 </p>
  288 
  289 <h3 id="race">Race detector</h3>
  290 
  291 <p>
  292 A major addition to the tools is a <em>race detector</em>, a way to
  293 find bugs in programs caused by concurrent access of the same
  294 variable, where at least one of the accesses is a write.
  295 This new facility is built into the <code>go</code> tool.
  296 For now, it is only available on Linux, Mac OS X, and Windows systems with
  297 64-bit x86 processors.
  298 To enable it, set the <code>-race</code> flag when building or testing your program
  299 (for instance, <code>go test -race</code>).
  300 The race detector is documented in <a href="/doc/articles/race_detector.html">a separate article</a>.
  301 </p>
  302 
  303 <h3 id="gc_asm">The gc assemblers</h3>
  304 
  305 <p>
  306 Due to the change of the <a href="#int"><code>int</code></a> to 64 bits and
  307 a new internal <a href="//golang.org/s/go11func">representation of functions</a>,
  308 the arrangement of function arguments on the stack has changed in the gc toolchain.
  309 Functions written in assembly will need to be revised at least
  310 to adjust frame pointer offsets.
  311 </p>
  312 
  313 <p>
  314 <em>Updating</em>:
  315 The <code>go vet</code> command now checks that functions implemented in assembly
  316 match the Go function prototypes they implement.
  317 </p>
  318 
  319 <h3 id="gocmd">Changes to the go command</h3>
  320 
  321 <p>
  322 The <a href="/cmd/go/"><code>go</code></a> command has acquired several
  323 changes intended to improve the experience for new Go users.
  324 </p>
  325 
  326 <p>
  327 First, when compiling, testing, or running Go code, the <code>go</code> command will now give more detailed error messages,
  328 including a list of paths searched, when a package cannot be located.
  329 </p>
  330 
  331 <pre>
  332 $ go build foo/quxx
  333 can't load package: package foo/quxx: cannot find package "foo/quxx" in any of:
  334         /home/you/go/src/pkg/foo/quxx (from $GOROOT)
  335         /home/you/src/foo/quxx (from $GOPATH)
  336 </pre>
  337 
  338 <p>
  339 Second, the <code>go get</code> command no longer allows <code>$GOROOT</code>
  340 as the default destination when downloading package source.
  341 To use the <code>go get</code>
  342 command, a <a href="/doc/code.html#GOPATH">valid <code>$GOPATH</code></a> is now required.
  343 </p>
  344 
  345 <pre>
  346 $ GOPATH= go get code.google.com/p/foo/quxx
  347 package code.google.com/p/foo/quxx: cannot download, $GOPATH not set. For more details see: go help gopath
  348 </pre>
  349 
  350 <p>
  351 Finally, as a result of the previous change, the <code>go get</code> command will also fail
  352 when <code>$GOPATH</code> and <code>$GOROOT</code> are set to the same value.
  353 </p>
  354 
  355 <pre>
  356 $ GOPATH=$GOROOT go get code.google.com/p/foo/quxx
  357 warning: GOPATH set to GOROOT (/home/you/go) has no effect
  358 package code.google.com/p/foo/quxx: cannot download, $GOPATH must not be set to $GOROOT. For more details see: go help gopath
  359 </pre>
  360 
  361 <h3 id="gotest">Changes to the go test command</h3>
  362 
  363 <p>
  364 The <a href="/cmd/go/#hdr-Test_packages"><code>go test</code></a>
  365 command no longer deletes the binary when run with profiling enabled,
  366 to make it easier to analyze the profile.
  367 The implementation sets the <code>-c</code> flag automatically, so after running,
  368 </p>
  369 
  370 <pre>
  371 $ go test -cpuprofile cpuprof.out mypackage
  372 </pre>
  373 
  374 <p>
  375 the file <code>mypackage.test</code> will be left in the directory where <code>go test</code> was run.
  376 </p>
  377 
  378 <p>
  379 The <a href="/cmd/go/#hdr-Test_packages"><code>go test</code></a>
  380 command can now generate profiling information
  381 that reports where goroutines are blocked, that is,
  382 where they tend to stall waiting for an event such as a channel communication.
  383 The information is presented as a
  384 <em>blocking profile</em>
  385 enabled with the
  386 <code>-blockprofile</code>
  387 option of
  388 <code>go test</code>.
  389 Run <code>go help test</code> for more information.
  390 </p>
  391 
  392 <h3 id="gofix">Changes to the go fix command</h3>
  393 
  394 <p>
  395 The <a href="/cmd/fix/"><code>fix</code></a> command, usually run as
  396 <code>go fix</code>, no longer applies fixes to update code from
  397 before Go 1 to use Go 1 APIs.
  398 To update pre-Go 1 code to Go 1.1, use a Go 1.0 toolchain
  399 to convert the code to Go 1.0 first.
  400 </p>
  401 
  402 <h3 id="tags">Build constraints</h3>
  403 
  404 <p>
  405 The "<code>go1.1</code>" tag has been added to the list of default
  406 <a href="/pkg/go/build/#hdr-Build_Constraints">build constraints</a>.
  407 This permits packages to take advantage of the new features in Go 1.1 while
  408 remaining compatible with earlier versions of Go.
  409 </p>
  410 
  411 <p>
  412 To build a file only with Go 1.1 and above, add this build constraint:
  413 </p>
  414 
  415 <pre>
  416 // +build go1.1
  417 </pre>
  418 
  419 <p>
  420 To build a file only with Go 1.0.x, use the converse constraint:
  421 </p>
  422 
  423 <pre>
  424 // +build !go1.1
  425 </pre>
  426 
  427 <h3 id="platforms">Additional platforms</h3>
  428 
  429 <p>
  430 The Go 1.1 toolchain adds experimental support for <code>freebsd/arm</code>,
  431 <code>netbsd/386</code>, <code>netbsd/amd64</code>, <code>netbsd/arm</code>,
  432 <code>openbsd/386</code> and <code>openbsd/amd64</code> platforms.
  433 </p>
  434 
  435 <p>
  436 An ARMv6 or later processor is required for <code>freebsd/arm</code> or
  437 <code>netbsd/arm</code>.
  438 </p>
  439 
  440 <p>
  441 Go 1.1 adds experimental support for <code>cgo</code> on <code>linux/arm</code>.
  442 </p>
  443 
  444 <h3 id="crosscompile">Cross compilation</h3>
  445 
  446 <p>
  447 When cross-compiling, the <code>go</code> tool will disable <code>cgo</code>
  448 support by default.
  449 </p>
  450 
  451 <p>
  452 To explicitly enable <code>cgo</code>, set <code>CGO_ENABLED=1</code>.
  453 </p>
  454 
  455 <h2 id="performance">Performance</h2>
  456 
  457 <p>
  458 The performance of code compiled with the Go 1.1 gc tool suite should be noticeably
  459 better for most Go programs.
  460 Typical improvements relative to Go 1.0 seem to be about 30%-40%, sometimes
  461 much more, but occasionally less or even non-existent.
  462 There are too many small performance-driven tweaks through the tools and libraries
  463 to list them all here, but the following major changes are worth noting:
  464 </p>
  465 
  466 <ul>
  467 <li>The gc compilers generate better code in many cases, most noticeably for
  468 floating point on the 32-bit Intel architecture.</li>
  469 <li>The gc compilers do more in-lining, including for some operations
  470 in the run-time such as <a href="/pkg/builtin/#append"><code>append</code></a>
  471 and interface conversions.</li>
  472 <li>There is a new implementation of Go maps with significant reduction in
  473 memory footprint and CPU time.</li>
  474 <li>The garbage collector has been made more parallel, which can reduce
  475 latencies for programs running on multiple CPUs.</li>
  476 <li>The garbage collector is also more precise, which costs a small amount of
  477 CPU time but can reduce the size of the heap significantly, especially
  478 on 32-bit architectures.</li>
  479 <li>Due to tighter coupling of the run-time and network libraries, fewer
  480 context switches are required on network operations.</li>
  481 </ul>
  482 
  483 <h2 id="library">Changes to the standard library</h2>
  484 
  485 <h3 id="bufio_scanner">bufio.Scanner</h3>
  486 
  487 <p>
  488 The various routines to scan textual input in the
  489 <a href="/pkg/bufio/"><code>bufio</code></a>
  490 package,
  491 <a href="/pkg/bufio/#Reader.ReadBytes"><code>ReadBytes</code></a>,
  492 <a href="/pkg/bufio/#Reader.ReadString"><code>ReadString</code></a>
  493 and particularly
  494 <a href="/pkg/bufio/#Reader.ReadLine"><code>ReadLine</code></a>,
  495 are needlessly complex to use for simple purposes.
  496 In Go 1.1, a new type,
  497 <a href="/pkg/bufio/#Scanner"><code>Scanner</code></a>,
  498 has been added to make it easier to do simple tasks such as
  499 read the input as a sequence of lines or space-delimited words.
  500 It simplifies the problem by terminating the scan on problematic
  501 input such as pathologically long lines, and having a simple
  502 default: line-oriented input, with each line stripped of its terminator.
  503 Here is code to reproduce the input a line at a time:
  504 </p>
  505 
  506 <pre>
  507 scanner := bufio.NewScanner(os.Stdin)
  508 for scanner.Scan() {
  509     fmt.Println(scanner.Text()) // Println will add back the final '\n'
  510 }
  511 if err := scanner.Err(); err != nil {
  512     fmt.Fprintln(os.Stderr, "reading standard input:", err)
  513 }
  514 </pre>
  515 
  516 <p>
  517 Scanning behavior can be adjusted through a function to control subdividing the input
  518 (see the documentation for <a href="/pkg/bufio/#SplitFunc"><code>SplitFunc</code></a>),
  519 but for tough problems or the need to continue past errors, the older interface
  520 may still be required.
  521 </p>
  522 
  523 <h3 id="net">net</h3>
  524 
  525 <p>
  526 The protocol-specific resolvers in the <a href="/pkg/net/"><code>net</code></a> package were formerly
  527 lax about the network name passed in.
  528 Although the documentation was clear
  529 that the only valid networks for
  530 <a href="/pkg/net/#ResolveTCPAddr"><code>ResolveTCPAddr</code></a>
  531 are <code>"tcp"</code>,
  532 <code>"tcp4"</code>, and <code>"tcp6"</code>, the Go 1.0 implementation silently accepted any string.
  533 The Go 1.1 implementation returns an error if the network is not one of those strings.
  534 The same is true of the other protocol-specific resolvers <a href="/pkg/net/#ResolveIPAddr"><code>ResolveIPAddr</code></a>,
  535 <a href="/pkg/net/#ResolveUDPAddr"><code>ResolveUDPAddr</code></a>, and
  536 <a href="/pkg/net/#ResolveUnixAddr"><code>ResolveUnixAddr</code></a>.
  537 </p>
  538 
  539 <p>
  540 The previous implementation of
  541 <a href="/pkg/net/#ListenUnixgram"><code>ListenUnixgram</code></a>
  542 returned a
  543 <a href="/pkg/net/#UDPConn"><code>UDPConn</code></a> as
  544 a representation of the connection endpoint.
  545 The Go 1.1 implementation instead returns a
  546 <a href="/pkg/net/#UnixConn"><code>UnixConn</code></a>
  547 to allow reading and writing
  548 with its
  549 <a href="/pkg/net/#UnixConn.ReadFrom"><code>ReadFrom</code></a>
  550 and
  551 <a href="/pkg/net/#UnixConn.WriteTo"><code>WriteTo</code></a>
  552 methods.
  553 </p>
  554 
  555 <p>
  556 The data structures
  557 <a href="/pkg/net/#IPAddr"><code>IPAddr</code></a>,
  558 <a href="/pkg/net/#TCPAddr"><code>TCPAddr</code></a>, and
  559 <a href="/pkg/net/#UDPAddr"><code>UDPAddr</code></a>
  560 add a new string field called <code>Zone</code>.
  561 Code using untagged composite literals (e.g. <code>net.TCPAddr{ip, port}</code>)
  562 instead of tagged literals (<code>net.TCPAddr{IP: ip, Port: port}</code>)
  563 will break due to the new field.
  564 The Go 1 compatibility rules allow this change: client code must use tagged literals to avoid such breakages.
  565 </p>
  566 
  567 <p>
  568 <em>Updating</em>:
  569 To correct breakage caused by the new struct field,
  570 <code>go fix</code> will rewrite code to add tags for these types.
  571 More generally, <code>go vet</code> will identify composite literals that
  572 should be revised to use field tags.
  573 </p>
  574 
  575 <h3 id="reflect">reflect</h3>
  576 
  577 <p>
  578 The <a href="/pkg/reflect/"><code>reflect</code></a> package has several significant additions.
  579 </p>
  580 
  581 <p>
  582 It is now possible to run a "select" statement using
  583 the <code>reflect</code> package; see the description of
  584 <a href="/pkg/reflect/#Select"><code>Select</code></a>
  585 and
  586 <a href="/pkg/reflect/#SelectCase"><code>SelectCase</code></a>
  587 for details.
  588 </p>
  589 
  590 <p>
  591 The new method
  592 <a href="/pkg/reflect/#Value.Convert"><code>Value.Convert</code></a>
  593 (or
  594 <a href="/pkg/reflect/#Type"><code>Type.ConvertibleTo</code></a>)
  595 provides functionality to execute a Go conversion or type assertion operation
  596 on a
  597 <a href="/pkg/reflect/#Value"><code>Value</code></a>
  598 (or test for its possibility).
  599 </p>
  600 
  601 <p>
  602 The new function
  603 <a href="/pkg/reflect/#MakeFunc"><code>MakeFunc</code></a>
  604 creates a wrapper function to make it easier to call a function with existing
  605 <a href="/pkg/reflect/#Value"><code>Values</code></a>,
  606 doing the standard Go conversions among the arguments, for instance
  607 to pass an actual <code>int</code> to a formal <code>interface{}</code>.
  608 </p>
  609 
  610 <p>
  611 Finally, the new functions
  612 <a href="/pkg/reflect/#ChanOf"><code>ChanOf</code></a>,
  613 <a href="/pkg/reflect/#MapOf"><code>MapOf</code></a>
  614 and
  615 <a href="/pkg/reflect/#SliceOf"><code>SliceOf</code></a>
  616 construct new
  617 <a href="/pkg/reflect/#Type"><code>Types</code></a>
  618 from existing types, for example to construct the type <code>[]T</code> given
  619 only <code>T</code>.
  620 </p>
  621 
  622 
  623 <h3 id="time">time</h3>
  624 <p>
  625 On FreeBSD, Linux, NetBSD, OS X and OpenBSD, previous versions of the
  626 <a href="/pkg/time/"><code>time</code></a> package
  627 returned times with microsecond precision.
  628 The Go 1.1 implementation on these
  629 systems now returns times with nanosecond precision.
  630 Programs that write to an external format with microsecond precision
  631 and read it back, expecting to recover the original value, will be affected
  632 by the loss of precision.
  633 There are two new methods of <a href="/pkg/time/#Time"><code>Time</code></a>,
  634 <a href="/pkg/time/#Time.Round"><code>Round</code></a>
  635 and
  636 <a href="/pkg/time/#Time.Truncate"><code>Truncate</code></a>,
  637 that can be used to remove precision from a time before passing it to
  638 external storage.
  639 </p>
  640 
  641 <p>
  642 The new method
  643 <a href="/pkg/time/#Time.YearDay"><code>YearDay</code></a>
  644 returns the one-indexed integral day number of the year specified by the time value.
  645 </p>
  646 
  647 <p>
  648 The
  649 <a href="/pkg/time/#Timer"><code>Timer</code></a>
  650 type has a new method
  651 <a href="/pkg/time/#Timer.Reset"><code>Reset</code></a>
  652 that modifies the timer to expire after a specified duration.
  653 </p>
  654 
  655 <p>
  656 Finally, the new function
  657 <a href="/pkg/time/#ParseInLocation"><code>ParseInLocation</code></a>
  658 is like the existing
  659 <a href="/pkg/time/#Parse"><code>Parse</code></a>
  660 but parses the time in the context of a location (time zone), ignoring
  661 time zone information in the parsed string.
  662 This function addresses a common source of confusion in the time API.
  663 </p>
  664 
  665 <p>
  666 <em>Updating</em>:
  667 Code that needs to read and write times using an external format with
  668 lower precision should be modified to use the new methods.
  669 </p>
  670 
  671 <h3 id="exp_old">Exp and old subtrees moved to go.exp and go.text subrepositories</h3>
  672 
  673 <p>
  674 To make it easier for binary distributions to access them if desired, the <code>exp</code>
  675 and <code>old</code> source subtrees, which are not included in binary distributions,
  676 have been moved to the new <code>go.exp</code> subrepository at
  677 <code>code.google.com/p/go.exp</code>. To access the <code>ssa</code> package,
  678 for example, run
  679 </p>
  680 
  681 <pre>
  682 $ go get code.google.com/p/go.exp/ssa
  683 </pre>
  684 
  685 <p>
  686 and then in Go source,
  687 </p>
  688 
  689 <pre>
  690 import "code.google.com/p/go.exp/ssa"
  691 </pre>
  692 
  693 <p>
  694 The old package <code>exp/norm</code> has also been moved, but to a new repository
  695 <code>go.text</code>, where the Unicode APIs and other text-related packages will
  696 be developed.
  697 </p>
  698 
  699 <h3 id="new_packages">New packages</h3>
  700 
  701 <p>
  702 There are three new packages.
  703 </p>
  704 
  705 <ul>
  706 <li>
  707 The <a href="/pkg/go/format/"><code>go/format</code></a> package provides
  708 a convenient way for a program to access the formatting capabilities of the
  709 <a href="/cmd/go/#hdr-Run_gofmt_on_package_sources"><code>go fmt</code></a> command.
  710 It has two functions,
  711 <a href="/pkg/go/format/#Node"><code>Node</code></a> to format a Go parser
  712 <a href="/pkg/go/ast/#Node"><code>Node</code></a>,
  713 and
  714 <a href="/pkg/go/format/#Source"><code>Source</code></a>
  715 to reformat arbitrary Go source code into the standard format as provided by the
  716 <a href="/cmd/go/#hdr-Run_gofmt_on_package_sources"><code>go fmt</code></a> command.
  717 </li>
  718 
  719 <li>
  720 The <a href="/pkg/net/http/cookiejar/"><code>net/http/cookiejar</code></a> package provides the basics for managing HTTP cookies.
  721 </li>
  722 
  723 <li>
  724 The <a href="/pkg/runtime/race/"><code>runtime/race</code></a> package provides low-level facilities for data race detection.
  725 It is internal to the race detector and does not otherwise export any user-visible functionality.
  726 </li>
  727 </ul>
  728 
  729 <h3 id="minor_library_changes">Minor changes to the library</h3>
  730 
  731 <p>
  732 The following list summarizes a number of minor changes to the library, mostly additions.
  733 See the relevant package documentation for more information about each change.
  734 </p>
  735 
  736 <ul>
  737 <li>
  738 The <a href="/pkg/bytes/"><code>bytes</code></a> package has two new functions,
  739 <a href="/pkg/bytes/#TrimPrefix"><code>TrimPrefix</code></a>
  740 and
  741 <a href="/pkg/bytes/#TrimSuffix"><code>TrimSuffix</code></a>,
  742 with self-evident properties.
  743 Also, the <a href="/pkg/bytes/#Buffer"><code>Buffer</code></a> type
  744 has a new method
  745 <a href="/pkg/bytes/#Buffer.Grow"><code>Grow</code></a> that
  746 provides some control over memory allocation inside the buffer.
  747 Finally, the
  748 <a href="/pkg/bytes/#Reader"><code>Reader</code></a> type now has a
  749 <a href="/pkg/strings/#Reader.WriteTo"><code>WriteTo</code></a> method
  750 so it implements the
  751 <a href="/pkg/io/#WriterTo"><code>io.WriterTo</code></a> interface.
  752 </li>
  753 
  754 <li>
  755 The <a href="/pkg/compress/gzip/"><code>compress/gzip</code></a> package has
  756 a new <a href="/pkg/compress/gzip/#Writer.Flush"><code>Flush</code></a>
  757 method for its
  758 <a href="/pkg/compress/gzip/#Writer"><code>Writer</code></a>
  759 type that flushes its underlying <code>flate.Writer</code>.
  760 </li>
  761 
  762 <li>
  763 The <a href="/pkg/crypto/hmac/"><code>crypto/hmac</code></a> package has a new function,
  764 <a href="/pkg/crypto/hmac/#Equal"><code>Equal</code></a>, to compare two MACs.
  765 </li>
  766 
  767 <li>
  768 The <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package
  769 now supports PEM blocks (see
  770 <a href="/pkg/crypto/x509/#DecryptPEMBlock"><code>DecryptPEMBlock</code></a> for instance),
  771 and a new function
  772 <a href="/pkg/crypto/x509/#ParseECPrivateKey"><code>ParseECPrivateKey</code></a> to parse elliptic curve private keys.
  773 </li>
  774 
  775 <li>
  776 The <a href="/pkg/database/sql/"><code>database/sql</code></a> package
  777 has a new
  778 <a href="/pkg/database/sql/#DB.Ping"><code>Ping</code></a>
  779 method for its
  780 <a href="/pkg/database/sql/#DB"><code>DB</code></a>
  781 type that tests the health of the connection.
  782 </li>
  783 
  784 <li>
  785 The <a href="/pkg/database/sql/driver/"><code>database/sql/driver</code></a> package
  786 has a new
  787 <a href="/pkg/database/sql/driver/#Queryer"><code>Queryer</code></a>
  788 interface that a
  789 <a href="/pkg/database/sql/driver/#Conn"><code>Conn</code></a>
  790 may implement to improve performance.
  791 </li>
  792 
  793 <li>
  794 The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package's
  795 <a href="/pkg/encoding/json/#Decoder"><code>Decoder</code></a>
  796 has a new method
  797 <a href="/pkg/encoding/json/#Decoder.Buffered"><code>Buffered</code></a>
  798 to provide access to the remaining data in its buffer,
  799 as well as a new method
  800 <a href="/pkg/encoding/json/#Decoder.UseNumber"><code>UseNumber</code></a>
  801 to unmarshal a value into the new type
  802 <a href="/pkg/encoding/json/#Number"><code>Number</code></a>,
  803 a string, rather than a float64.
  804 </li>
  805 
  806 <li>
  807 The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package
  808 has a new function,
  809 <a href="/pkg/encoding/xml/#EscapeText"><code>EscapeText</code></a>,
  810 which writes escaped XML output,
  811 and a method on
  812 <a href="/pkg/encoding/xml/#Encoder"><code>Encoder</code></a>,
  813 <a href="/pkg/encoding/xml/#Encoder.Indent"><code>Indent</code></a>,
  814 to specify indented output.
  815 </li>
  816 
  817 <li>
  818 In the <a href="/pkg/go/ast/"><code>go/ast</code></a> package, a
  819 new type <a href="/pkg/go/ast/#CommentMap"><code>CommentMap</code></a>
  820 and associated methods makes it easier to extract and process comments in Go programs.
  821 </li>
  822 
  823 <li>
  824 In the <a href="/pkg/go/doc/"><code>go/doc</code></a> package,
  825 the parser now keeps better track of stylized annotations such as <code>TODO(joe)</code>
  826 throughout the code,
  827 information that the <a href="/cmd/godoc/"><code>godoc</code></a>
  828 command can filter or present according to the value of the <code>-notes</code> flag.
  829 </li>
  830 
  831 <li>
  832 The undocumented and only partially implemented "noescape" feature of the
  833 <a href="/pkg/html/template/"><code>html/template</code></a>
  834 package has been removed; programs that depend on it will break.
  835 </li>
  836 
  837 <li>
  838 The <a href="/pkg/image/jpeg/"><code>image/jpeg</code></a> package now
  839 reads progressive JPEG files and handles a few more subsampling configurations.
  840 </li>
  841 
  842 <li>
  843 The <a href="/pkg/io/"><code>io</code></a> package now exports the
  844 <a href="/pkg/io/#ByteWriter"><code>io.ByteWriter</code></a> interface to capture the common
  845 functionality of writing a byte at a time.
  846 It also exports a new error, <a href="/pkg/io/#ErrNoProgress"><code>ErrNoProgress</code></a>,
  847 used to indicate a <code>Read</code> implementation is looping without delivering data.
  848 </li>
  849 
  850 <li>
  851 The <a href="/pkg/log/syslog/"><code>log/syslog</code></a> package now provides better support
  852 for OS-specific logging features.
  853 </li>
  854 
  855 <li>
  856 The <a href="/pkg/math/big/"><code>math/big</code></a> package's
  857 <a href="/pkg/math/big/#Int"><code>Int</code></a> type
  858 now has methods
  859 <a href="/pkg/math/big/#Int.MarshalJSON"><code>MarshalJSON</code></a>
  860 and
  861 <a href="/pkg/math/big/#Int.UnmarshalJSON"><code>UnmarshalJSON</code></a>
  862 to convert to and from a JSON representation.
  863 Also,
  864 <a href="/pkg/math/big/#Int"><code>Int</code></a>
  865 can now convert directly to and from a <code>uint64</code> using
  866 <a href="/pkg/math/big/#Int.Uint64"><code>Uint64</code></a>
  867 and
  868 <a href="/pkg/math/big/#Int.SetUint64"><code>SetUint64</code></a>,
  869 while
  870 <a href="/pkg/math/big/#Rat"><code>Rat</code></a>
  871 can do the same with <code>float64</code> using
  872 <a href="/pkg/math/big/#Rat.Float64"><code>Float64</code></a>
  873 and
  874 <a href="/pkg/math/big/#Rat.SetFloat64"><code>SetFloat64</code></a>.
  875 </li>
  876 
  877 <li>
  878 The <a href="/pkg/mime/multipart/"><code>mime/multipart</code></a> package
  879 has a new method for its
  880 <a href="/pkg/mime/multipart/#Writer"><code>Writer</code></a>,
  881 <a href="/pkg/mime/multipart/#Writer.SetBoundary"><code>SetBoundary</code></a>,
  882 to define the boundary separator used to package the output.
  883 The <a href="/pkg/mime/multipart/#Reader"><code>Reader</code></a> also now
  884 transparently decodes any <code>quoted-printable</code> parts and removes
  885 the <code>Content-Transfer-Encoding</code> header when doing so.
  886 </li>
  887 
  888 <li>
  889 The
  890 <a href="/pkg/net/"><code>net</code></a> package's
  891 <a href="/pkg/net/#ListenUnixgram"><code>ListenUnixgram</code></a>
  892 function has changed return types: it now returns a
  893 <a href="/pkg/net/#UnixConn"><code>UnixConn</code></a>
  894 rather than a
  895 <a href="/pkg/net/#UDPConn"><code>UDPConn</code></a>, which was
  896 clearly a mistake in Go 1.0.
  897 Since this API change fixes a bug, it is permitted by the Go 1 compatibility rules.
  898 </li>
  899 
  900 <li>
  901 The <a href="/pkg/net/"><code>net</code></a> package includes a new type,
  902 <a href="/pkg/net/#Dialer"><code>Dialer</code></a>, to supply options to
  903 <a href="/pkg/net/#Dialer.Dial"><code>Dial</code></a>.
  904 </li>
  905 
  906 <li>
  907 The <a href="/pkg/net/"><code>net</code></a> package adds support for
  908 link-local IPv6 addresses with zone qualifiers, such as <code>fe80::1%lo0</code>.
  909 The address structures <a href="/pkg/net/#IPAddr"><code>IPAddr</code></a>,
  910 <a href="/pkg/net/#UDPAddr"><code>UDPAddr</code></a>, and
  911 <a href="/pkg/net/#TCPAddr"><code>TCPAddr</code></a>
  912 record the zone in a new field, and functions that expect string forms of these addresses, such as
  913 <a href="/pkg/net/#Dial"><code>Dial</code></a>,
  914 <a href="/pkg/net/#ResolveIPAddr"><code>ResolveIPAddr</code></a>,
  915 <a href="/pkg/net/#ResolveUDPAddr"><code>ResolveUDPAddr</code></a>, and
  916 <a href="/pkg/net/#ResolveTCPAddr"><code>ResolveTCPAddr</code></a>,
  917 now accept the zone-qualified form.
  918 </li>
  919 
  920 <li>
  921 The <a href="/pkg/net/"><code>net</code></a> package adds
  922 <a href="/pkg/net/#LookupNS"><code>LookupNS</code></a> to its suite of resolving functions.
  923 <code>LookupNS</code> returns the <a href="/pkg/net/#NS">NS records</a> for a host name.
  924 </li>
  925 
  926 <li>
  927 The <a href="/pkg/net/"><code>net</code></a> package adds protocol-specific
  928 packet reading and writing methods to
  929 <a href="/pkg/net/#IPConn"><code>IPConn</code></a>
  930 (<a href="/pkg/net/#IPConn.ReadMsgIP"><code>ReadMsgIP</code></a>
  931 and <a href="/pkg/net/#IPConn.WriteMsgIP"><code>WriteMsgIP</code></a>) and
  932 <a href="/pkg/net/#UDPConn"><code>UDPConn</code></a>
  933 (<a href="/pkg/net/#UDPConn.ReadMsgUDP"><code>ReadMsgUDP</code></a> and
  934 <a href="/pkg/net/#UDPConn.WriteMsgUDP"><code>WriteMsgUDP</code></a>).
  935 These are specialized versions of <a href="/pkg/net/#PacketConn"><code>PacketConn</code></a>'s
  936 <code>ReadFrom</code> and <code>WriteTo</code> methods that provide access to out-of-band data associated
  937 with the packets.
  938  </li>
  939 
  940  <li>
  941 The <a href="/pkg/net/"><code>net</code></a> package adds methods to
  942 <a href="/pkg/net/#UnixConn"><code>UnixConn</code></a> to allow closing half of the connection
  943 (<a href="/pkg/net/#UnixConn.CloseRead"><code>CloseRead</code></a> and
  944 <a href="/pkg/net/#UnixConn.CloseWrite"><code>CloseWrite</code></a>),
  945 matching the existing methods of <a href="/pkg/net/#TCPConn"><code>TCPConn</code></a>.
  946 </li>
  947 
  948 <li>
  949 The <a href="/pkg/net/http/"><code>net/http</code></a> package includes several new additions.
  950 <a href="/pkg/net/http/#ParseTime"><code>ParseTime</code></a> parses a time string, trying
  951 several common HTTP time formats.
  952 The <a href="/pkg/net/http/#Request.PostFormValue"><code>PostFormValue</code></a> method of
  953 <a href="/pkg/net/http/#Request"><code>Request</code></a> is like
  954 <a href="/pkg/net/http/#Request.FormValue"><code>FormValue</code></a> but ignores URL parameters.
  955 The <a href="/pkg/net/http/#CloseNotifier"><code>CloseNotifier</code></a> interface provides a mechanism
  956 for a server handler to discover when a client has disconnected.
  957 The <code>ServeMux</code> type now has a
  958 <a href="/pkg/net/http/#ServeMux.Handler"><code>Handler</code></a> method to access a path's
  959 <code>Handler</code> without executing it.
  960 The <code>Transport</code> can now cancel an in-flight request with
  961 <a href="/pkg/net/http/#Transport.CancelRequest"><code>CancelRequest</code></a>.
  962 Finally, the Transport is now more aggressive at closing TCP connections when
  963 a <a href="/pkg/net/http/#Response"><code>Response.Body</code></a> is closed before
  964 being fully consumed.
  965 </li>
  966 
  967 <li>
  968 The <a href="/pkg/net/mail/"><code>net/mail</code></a> package has two new functions,
  969 <a href="/pkg/net/mail/#ParseAddress"><code>ParseAddress</code></a> and
  970 <a href="/pkg/net/mail/#ParseAddressList"><code>ParseAddressList</code></a>,
  971 to parse RFC 5322-formatted mail addresses into
  972 <a href="/pkg/net/mail/#Address"><code>Address</code></a> structures.
  973 </li>
  974 
  975 <li>
  976 The <a href="/pkg/net/smtp/"><code>net/smtp</code></a> package's
  977 <a href="/pkg/net/smtp/#Client"><code>Client</code></a> type has a new method,
  978 <a href="/pkg/net/smtp/#Client.Hello"><code>Hello</code></a>,
  979 which transmits a <code>HELO</code> or <code>EHLO</code> message to the server.
  980 </li>
  981 
  982 <li>
  983 The <a href="/pkg/net/textproto/"><code>net/textproto</code></a> package
  984 has two new functions,
  985 <a href="/pkg/net/textproto/#TrimBytes"><code>TrimBytes</code></a> and
  986 <a href="/pkg/net/textproto/#TrimString"><code>TrimString</code></a>,
  987 which do ASCII-only trimming of leading and trailing spaces.
  988 </li>
  989 
  990 <li>
  991 The new method <a href="/pkg/os/#FileMode.IsRegular"><code>os.FileMode.IsRegular</code></a> makes it easy to ask if a file is a plain file.
  992 </li>
  993 
  994 <li>
  995 The <a href="/pkg/os/signal/"><code>os/signal</code></a> package has a new function,
  996 <a href="/pkg/os/signal/#Stop"><code>Stop</code></a>, which stops the package delivering
  997 any further signals to the channel.
  998 </li>
  999 
 1000 <li>
 1001 The <a href="/pkg/regexp/"><code>regexp</code></a> package
 1002 now supports Unix-original leftmost-longest matches through the
 1003 <a href="/pkg/regexp/#Regexp.Longest"><code>Regexp.Longest</code></a>
 1004 method, while
 1005 <a href="/pkg/regexp/#Regexp.Split"><code>Regexp.Split</code></a> slices
 1006 strings into pieces based on separators defined by the regular expression.
 1007 </li>
 1008 
 1009 <li>
 1010 The <a href="/pkg/runtime/debug/"><code>runtime/debug</code></a> package
 1011 has three new functions regarding memory usage.
 1012 The <a href="/pkg/runtime/debug/#FreeOSMemory"><code>FreeOSMemory</code></a>
 1013 function triggers a run of the garbage collector and then attempts to return unused
 1014 memory to the operating system;
 1015 the <a href="/pkg/runtime/debug/#ReadGCStats"><code>ReadGCStats</code></a>
 1016 function retrieves statistics about the collector; and
 1017 <a href="/pkg/runtime/debug/#SetGCPercent"><code>SetGCPercent</code></a>
 1018 provides a programmatic way to control how often the collector runs,
 1019 including disabling it altogether.
 1020 </li>
 1021 
 1022 <li>
 1023 The <a href="/pkg/sort/"><code>sort</code></a> package has a new function,
 1024 <a href="/pkg/sort/#Reverse"><code>Reverse</code></a>.
 1025 Wrapping the argument of a call to
 1026 <a href="/pkg/sort/#Sort"><code>sort.Sort</code></a>
 1027 with a call to <code>Reverse</code> causes the sort order to be reversed.
 1028 </li>
 1029 
 1030 <li>
 1031 The <a href="/pkg/strings/"><code>strings</code></a> package has two new functions,
 1032 <a href="/pkg/strings/#TrimPrefix"><code>TrimPrefix</code></a>
 1033 and
 1034 <a href="/pkg/strings/#TrimSuffix"><code>TrimSuffix</code></a>
 1035 with self-evident properties, and the new method
 1036 <a href="/pkg/strings/#Reader.WriteTo"><code>Reader.WriteTo</code></a> so the
 1037 <a href="/pkg/strings/#Reader"><code>Reader</code></a>
 1038 type now implements the
 1039 <a href="/pkg/io/#WriterTo"><code>io.WriterTo</code></a> interface.
 1040 </li>
 1041 
 1042 <li>
 1043 The <a href="/pkg/syscall/"><code>syscall</code></a> package's
 1044 <a href="/pkg/syscall/#Fchflags"><code>Fchflags</code></a> function on various BSDs
 1045 (including Darwin) has changed signature.
 1046 It now takes an int as the first parameter instead of a string.
 1047 Since this API change fixes a bug, it is permitted by the Go 1 compatibility rules.
 1048 </li>
 1049 <li>
 1050 The <a href="/pkg/syscall/"><code>syscall</code></a> package also has received many updates
 1051 to make it more inclusive of constants and system calls for each supported operating system.
 1052 </li>
 1053 
 1054 <li>
 1055 The <a href="/pkg/testing/"><code>testing</code></a> package now automates the generation of allocation
 1056 statistics in tests and benchmarks using the new
 1057 <a href="/pkg/testing/#AllocsPerRun"><code>AllocsPerRun</code></a> function. And the
 1058 <a href="/pkg/testing/#B.ReportAllocs"><code>ReportAllocs</code></a>
 1059 method on <a href="/pkg/testing/#B"><code>testing.B</code></a> will enable printing of
 1060 memory allocation statistics for the calling benchmark. It also introduces the
 1061 <a href="/pkg/testing/#BenchmarkResult.AllocsPerOp"><code>AllocsPerOp</code></a> method of
 1062 <a href="/pkg/testing/#BenchmarkResult"><code>BenchmarkResult</code></a>.
 1063 There is also a new
 1064 <a href="/pkg/testing/#Verbose"><code>Verbose</code></a> function to test the state of the <code>-v</code>
 1065 command-line flag,
 1066 and a new
 1067 <a href="/pkg/testing/#B.Skip"><code>Skip</code></a> method of
 1068 <a href="/pkg/testing/#B"><code>testing.B</code></a> and
 1069 <a href="/pkg/testing/#T"><code>testing.T</code></a>
 1070 to simplify skipping an inappropriate test.
 1071 </li>
 1072 
 1073 <li>
 1074 In the <a href="/pkg/text/template/"><code>text/template</code></a>
 1075 and
 1076 <a href="/pkg/html/template/"><code>html/template</code></a> packages,
 1077 templates can now use parentheses to group the elements of pipelines, simplifying the construction of complex pipelines.
 1078 Also, as part of the new parser, the
 1079 <a href="/pkg/text/template/parse/#Node"><code>Node</code></a> interface got two new methods to provide
 1080 better error reporting.
 1081 Although this violates the Go 1 compatibility rules,
 1082 no existing code should be affected because this interface is explicitly intended only to be used
 1083 by the
 1084 <a href="/pkg/text/template/"><code>text/template</code></a>
 1085 and
 1086 <a href="/pkg/html/template/"><code>html/template</code></a>
 1087 packages and there are safeguards to guarantee that.
 1088 </li>
 1089 
 1090 <li>
 1091 The implementation of the <a href="/pkg/unicode/"><code>unicode</code></a> package has been updated to Unicode version 6.2.0.
 1092 </li>
 1093 
 1094 <li>
 1095 In the <a href="/pkg/unicode/utf8/"><code>unicode/utf8</code></a> package,
 1096 the new function <a href="/pkg/unicode/utf8/#ValidRune"><code>ValidRune</code></a> reports whether the rune is a valid Unicode code point.
 1097 To be valid, a rune must be in range and not be a surrogate half.
 1098 </li>
 1099 </ul>