go/doc/go1.html at go1.10 · dominicbarnes/go

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

<!--{

"Title": "Go 1 Release Notes",

"Path": "/doc/go1",

"Template": true

}-->

<h2 id="introduction">Introduction to Go 1</h2>

<p>

Go version 1, Go 1 for short, defines a language and a set of core libraries

that provide a stable foundation for creating reliable products, projects, and

publications.

</p>

<p>

The driving motivation for Go 1 is stability for its users. People should be able to

write Go programs and expect that they will continue to compile and run without

change, on a time scale of years, including in production environments such as

Google App Engine. Similarly, people should be able to write books about Go, be

able to say which version of Go the book is describing, and have that version

number still be meaningful much later.

</p>

<p>

Code that compiles in Go 1 should, with few exceptions, continue to compile and

run throughout the lifetime of that version, even as we issue updates and bug

fixes such as Go version 1.1, 1.2, and so on. Other than critical fixes, changes

made to the language and library for subsequent releases of Go 1 may

add functionality but will not break existing Go 1 programs.

<a href="go1compat.html">The Go 1 compatibility document</a>

explains the compatibility guidelines in more detail.

</p>

<p>

Go 1 is a representation of Go as it used today, not a wholesale rethinking of

the language. We avoided designing new features and instead focused on cleaning

up problems and inconsistencies and improving portability. There are a number

changes to the Go language and packages that we had considered for some time and

prototyped but not released primarily because they are significant and

backwards-incompatible. Go 1 was an opportunity to get them out, which is

helpful for the long term, but also means that Go 1 introduces incompatibilities

for old programs. Fortunately, the <code>go</code> <code>fix</code> tool can

automate much of the work needed to bring programs up to the Go 1 standard.

</p>

<p>

This document outlines the major changes in Go 1 that will affect programmers

updating existing code; its reference point is the prior release, r60 (tagged as

r60.3). It also explains how to update code from r60 to run under Go 1.

</p>

<h2 id="language">Changes to the language</h2>

<h3 id="append">Append</h3>

<p>

The <code>append</code> predeclared variadic function makes it easy to grow a slice

by adding elements to the end.

A common use is to add bytes to the end of a byte slice when generating output.

However, <code>append</code> did not provide a way to append a string to a <code>[]byte</code>,

which is another common case.

</p>

{{code "/doc/progs/go1.go" `/greeting := ..byte/` `/append.*hello/`}}

<p>

By analogy with the similar property of <code>copy</code>, Go 1

permits a string to be appended (byte-wise) directly to a byte

slice, reducing the friction between strings and byte slices.

The conversion is no longer necessary:

</p>

<p>

<em>Updating</em>:

This is a new feature, so existing code needs no changes.

</p>

<h3 id="close">Close</h3>

<p>

The <code>close</code> predeclared function provides a mechanism

for a sender to signal that no more values will be sent.

It is important to the implementation of <code>for</code> <code>range</code>

loops over channels and is helpful in other situations.

Partly by design and partly because of race conditions that can occur otherwise,

it is intended for use only by the goroutine sending on the channel,

not by the goroutine receiving data.

However, before Go 1 there was no compile-time checking that <code>close</code>

was being used correctly.

</p>

<p>

To close this gap, at least in part, Go 1 disallows <code>close</code> on receive-only channels.

Attempting to close such a channel is a compile-time error.

</p>

<pre>

var c chan int

var csend chan<- int = c

var crecv <-chan int = c

close(c) // legal

close(csend) // legal

close(crecv) // illegal

</pre>

<p>

<em>Updating</em>:

Existing code that attempts to close a receive-only channel was

erroneous even before Go 1 and should be fixed. The compiler will

now reject such code.

</p>

<h3 id="literals">Composite literals</h3>

<p>

In Go 1, a composite literal of array, slice, or map type can elide the

type specification for the elements' initializers if they are of pointer type.

All four of the initializations in this example are legal; the last one was illegal before Go 1.

</p>

<p>

<em>Updating</em>:

This change has no effect on existing code, but the command

<code>gofmt</code> <code>-s</code> applied to existing source

will, among other things, elide explicit element types wherever permitted.

</p>

<h3 id="init">Goroutines during init</h3>

<p>

The old language defined that <code>go</code> statements executed during initialization created goroutines but that they did not begin to run until initialization of the entire program was complete.

This introduced clumsiness in many places and, in effect, limited the utility

of the <code>init</code> construct:

if it was possible for another package to use the library during initialization, the library

was forced to avoid goroutines.

This design was done for reasons of simplicity and safety but,

as our confidence in the language grew, it seemed unnecessary.

Running goroutines during initialization is no more complex or unsafe than running them during normal execution.

</p>

<p>

In Go 1, code that uses goroutines can be called from

<code>init</code> routines and global initialization expressions

without introducing a deadlock.

</p>

{{code "/doc/progs/go1.go" `/PackageGlobal/` `/^}/`}}

<p>

<em>Updating</em>:

This is a new feature, so existing code needs no changes,

although it's possible that code that depends on goroutines not starting before <code>main</code> will break.

There was no such code in the standard repository.

</p>

<p>

The language spec allows the <code>int</code> type to be 32 or 64 bits wide, but current implementations set <code>int</code> to 32 bits even on 64-bit platforms.

It would be preferable to have <code>int</code> be 64 bits on 64-bit platforms.

(There are important consequences for indexing large slices.)

However, this change would waste space when processing Unicode characters with

the old language because the <code>int</code> type was also used to hold Unicode code points: each code point would waste an extra 32 bits of storage if <code>int</code> grew from 32 bits to 64.

</p>

<p>

To make changing to 64-bit <code>int</code> feasible,

Go 1 introduces a new basic type, <code>rune</code>, to represent

individual Unicode code points.

It is an alias for <code>int32</code>, analogous to <code>byte</code>

as an alias for <code>uint8</code>.

</p>

<p>

Character literals such as <code>'a'</code>, <code>'語'</code>, and <code>'\u0345'</code>

now have default type <code>rune</code>,

analogous to <code>1.0</code> having default type <code>float64</code>.

A variable initialized to a character constant will therefore

have type <code>rune</code> unless otherwise specified.

</p>

<p>

Libraries have been updated to use <code>rune</code> rather than <code>int</code>

when appropriate. For instance, the functions <code>unicode.ToLower</code> and

relatives now take and return a <code>rune</code>.

</p>

<p>

<em>Updating</em>:

Most source code will be unaffected by this because the type inference from

<code>:=</code> initializers introduces the new type silently, and it propagates

from there.

Some code may get type errors that a trivial conversion will resolve.

</p>

<h3 id="error">The error type</h3>

<p>

Go 1 introduces a new built-in type, <code>error</code>, which has the following definition:

</p>

<pre>

type error interface {

Error() string

}

</pre>

<p>

Since the consequences of this type are all in the package library,

it is discussed <a href="#errors">below</a>.

</p>

<h3 id="delete">Deleting from maps</h3>

<p>

In the old language, to delete the entry with key <code>k</code> from map <code>m</code>, one wrote the statement,

</p>

<pre>

m[k] = value, false

</pre>

<p>

This syntax was a peculiar special case, the only two-to-one assignment.

It required passing a value (usually ignored) that is evaluated but discarded,

plus a boolean that was nearly always the constant <code>false</code>.

It did the job but was odd and a point of contention.

</p>

<p>

In Go 1, that syntax has gone; instead there is a new built-in

function, <code>delete</code>. The call

</p>

<p>

will delete the map entry retrieved by the expression <code>m[k]</code>.

There is no return value. Deleting a non-existent entry is a no-op.

</p>

<p>

<em>Updating</em>:

Running <code>go</code> <code>fix</code> will convert expressions of the form <code>m[k] = value,

false</code> into <code>delete(m, k)</code> when it is clear that

the ignored value can be safely discarded from the program and

<code>false</code> refers to the predefined boolean constant.

The fix tool

will flag other uses of the syntax for inspection by the programmer.

</p>

<h3 id="iteration">Iterating in maps</h3>

<p>

The old language specification did not define the order of iteration for maps,

and in practice it differed across hardware platforms.

This caused tests that iterated over maps to be fragile and non-portable, with the

unpleasant property that a test might always pass on one machine but break on another.

</p>

<p>

In Go 1, the order in which elements are visited when iterating

over a map using a <code>for</code> <code>range</code> statement

is defined to be unpredictable, even if the same loop is run multiple

times with the same map.

Code should not assume that the elements are visited in any particular order.

</p>

<p>

This change means that code that depends on iteration order is very likely to break early and be fixed long before it becomes a problem.

Just as important, it allows the map implementation to ensure better map balancing even when programs are using range loops to select an element from a map.

</p>

{{code "/doc/progs/go1.go" `/Sunday/` `/^ }/`}}

<p>

<em>Updating</em>:

This is one change where tools cannot help. Most existing code

will be unaffected, but some programs may break or misbehave; we

recommend manual checking of all range statements over maps to

verify they do not depend on iteration order. There were a few such

examples in the standard repository; they have been fixed.

Note that it was already incorrect to depend on the iteration order, which

was unspecified. This change codifies the unpredictability.

</p>

<h3 id="multiple_assignment">Multiple assignment</h3>

<p>

The language specification has long guaranteed that in assignments

the right-hand-side expressions are all evaluated before any left-hand-side expressions are assigned.

To guarantee predictable behavior,

Go 1 refines the specification further.

</p>

<p>

If the left-hand side of the assignment

statement contains expressions that require evaluation, such as

function calls or array indexing operations, these will all be done

using the usual left-to-right rule before any variables are assigned

their value. Once everything is evaluated, the actual assignments

proceed in left-to-right order.

</p>

<p>

These examples illustrate the behavior.

</p>

<p>

<em>Updating</em>:

This is one change where tools cannot help, but breakage is unlikely.

No code in the standard repository was broken by this change, and code

that depended on the previous unspecified behavior was already incorrect.

</p>

<h3 id="shadowing">Returns and shadowed variables</h3>

<p>

A common mistake is to use <code>return</code> (without arguments) after an assignment to a variable that has the same name as a result variable but is not the same variable.

This situation is called <em>shadowing</em>: the result variable has been shadowed by another variable with the same name declared in an inner scope.

</p>

<p>

In functions with named return values,

the Go 1 compilers disallow return statements without arguments if any of the named return values is shadowed at the point of the return statement.

(It isn't part of the specification, because this is one area we are still exploring;

the situation is analogous to the compilers rejecting functions that do not end with an explicit return statement.)

</p>

<p>

This function implicitly returns a shadowed return value and will be rejected by the compiler:

</p>

<pre>

func Bug() (i, j, k int) {

for i = 0; i < 5; i++ {

for j := 0; j < 5; j++ { // Redeclares j.

k += i*j

if k > 100 {

return // Rejected: j is shadowed here.

}

return // OK: j is not shadowed here.

}

</pre>

<p>

<em>Updating</em>:

Code that shadows return values in this way will be rejected by the compiler and will need to be fixed by hand.

The few cases that arose in the standard repository were mostly bugs.

</p>

<h3 id="unexported">Copying structs with unexported fields</h3>

<p>

The old language did not allow a package to make a copy of a struct value containing unexported fields belonging to a different package.

There was, however, a required exception for a method receiver;

also, the implementations of <code>copy</code> and <code>append</code> have never honored the restriction.

</p>

<p>

Go 1 will allow packages to copy struct values containing unexported fields from other packages.

Besides resolving the inconsistency,

this change admits a new kind of API: a package can return an opaque value without resorting to a pointer or interface.

The new implementations of <code>time.Time</code> and

<code>reflect.Value</code> are examples of types taking advantage of this new property.

</p>

<p>

As an example, if package <code>p</code> includes the definitions,

</p>

<pre>

type Struct struct {

Public int

secret int

}

func NewStruct(a int) Struct { // Note: not a pointer.

return Struct{a, f(a)}

}

func (s Struct) String() string {

return fmt.Sprintf("{%d (secret %d)}", s.Public, s.secret)

}

</pre>

<p>

a package that imports <code>p</code> can assign and copy values of type

<code>p.Struct</code> at will.

Behind the scenes the unexported fields will be assigned and copied just

as if they were exported,

but the client code will never be aware of them. The code

</p>

<pre>

import "p"

myStruct := p.NewStruct(23)

copyOfMyStruct := myStruct

fmt.Println(myStruct, copyOfMyStruct)

</pre>

<p>

will show that the secret field of the struct has been copied to the new value.

</p>

<p>

<em>Updating</em>:

This is a new feature, so existing code needs no changes.

</p>

<h3 id="equality">Equality</h3>

<p>

Before Go 1, the language did not define equality on struct and array values.

This meant,

among other things, that structs and arrays could not be used as map keys.

On the other hand, Go did define equality on function and map values.

Function equality was problematic in the presence of closures

(when are two closures equal?)

while map equality compared pointers, not the maps' content, which was usually

not what the user would want.

</p>

<p>

Go 1 addressed these issues.

First, structs and arrays can be compared for equality and inequality

(<code>==</code> and <code>!=</code>),

and therefore be used as map keys,

provided they are composed from elements for which equality is also defined,

using element-wise comparison.

</p>

<p>

Second, Go 1 removes the definition of equality for function values,

except for comparison with <code>nil</code>.

Finally, map equality is gone too, also except for comparison with <code>nil</code>.

</p>

<p>

Note that equality is still undefined for slices, for which the

calculation is in general infeasible. Also note that the ordered

comparison operators (<code><</code> <code><=</code>

<code>></code> <code>>=</code>) are still undefined for

structs and arrays.

<p>

<em>Updating</em>:

Struct and array equality is a new feature, so existing code needs no changes.

Existing code that depends on function or map equality will be

rejected by the compiler and will need to be fixed by hand.

Few programs will be affected, but the fix may require some

redesign.

</p>

<h2 id="packages">The package hierarchy</h2>

<p>

Go 1 addresses many deficiencies in the old standard library and

cleans up a number of packages, making them more internally consistent

and portable.

</p>

<p>

This section describes how the packages have been rearranged in Go 1.

Some have moved, some have been renamed, some have been deleted.

New packages are described in later sections.

</p>

<h3 id="hierarchy">The package hierarchy</h3>

<p>

Go 1 has a rearranged package hierarchy that groups related items

into subdirectories. For instance, <code>utf8</code> and

<code>utf16</code> now occupy subdirectories of <code>unicode</code>.

Also, <a href="#subrepo">some packages</a> have moved into

subrepositories of

<a href="//code.google.com/p/go"><code>code.google.com/p/go</code></a>

while <a href="#deleted">others</a> have been deleted outright.

</p>

<tr>

</tr>

<tr>

</tr>

<tr><td>asn1</td> <td>encoding/asn1</td></tr>

<tr><td>csv</td> <td>encoding/csv</td></tr>

<tr><td>gob</td> <td>encoding/gob</td></tr>

<tr><td>json</td> <td>encoding/json</td></tr>

<tr><td>xml</td> <td>encoding/xml</td></tr>

<tr>

</tr>

<tr><td>exp/template/html</td> <td>html/template</td></tr>

<tr>

</tr>

<tr><td>cmath</td> <td>math/cmplx</td></tr>

<tr>

</tr>

<tr><td>http/httptest</td> <td>net/http/httptest</td></tr>

<tr><td>http/pprof</td> <td>net/http/pprof</td></tr>

<tr><td>rpc/jsonrpc</td> <td>net/rpc/jsonrpc</td></tr>

<tr>

</tr>

<tr>

</tr>

<tr><td>scanner</td> <td>text/scanner</td></tr>

<tr><td>tabwriter</td> <td>text/tabwriter</td></tr>

<tr><td>template</td> <td>text/template</td></tr>

<tr><td>template/parse</td> <td>text/template/parse</td></tr>

<tr>

</tr>

<tr><td>utf8</td> <td>unicode/utf8</td></tr>

<tr><td>utf16</td> <td>unicode/utf16</td></tr>

</table>

<p>

Note that the package names for the old <code>cmath</code> and

<code>exp/template/html</code> packages have changed to <code>cmplx</code>

and <code>template</code>.

</p>

<p>

<em>Updating</em>:

Running <code>go</code> <code>fix</code> will update all imports and package renames for packages that

remain inside the standard repository. Programs that import packages

that are no longer in the standard repository will need to be edited

by hand.

</p>

<h3 id="exp">The package tree exp</h3>

<p>

Because they are not standardized, the packages under the <code>exp</code> directory will not be available in the

standard Go 1 release distributions, although they will be available in source code form

in <a href="//code.google.com/p/go/">the repository</a> for

developers who wish to use them.

</p>

<p>

Several packages have moved under <code>exp</code> at the time of Go 1's release:

</p>

<ul>

<li><code>go/types</code></li>

</ul>

<p>

(<sup>†</sup>The <code>EscapeString</code> and <code>UnescapeString</code> types remain

in package <code>html</code>.)

</p>

<p>

All these packages are available under the same names, with the prefix <code>exp/</code>: <code>exp/ebnf</code> etc.

</p>

<p>

Also, the <code>utf8.String</code> type has been moved to its own package, <code>exp/utf8string</code>.

</p>

<p>

Finally, the <code>gotype</code> command now resides in <code>exp/gotype</code>, while

<code>ebnflint</code> is now in <code>exp/ebnflint</code>.

If they are installed, they now reside in <code>$GOROOT/bin/tool</code>.

</p>

<p>

<em>Updating</em>:

Code that uses packages in <code>exp</code> will need to be updated by hand,

or else compiled from an installation that has <code>exp</code> available.

The <code>go</code> <code>fix</code> tool or the compiler will complain about such uses.

</p>

<h3 id="old">The package tree old</h3>

<p>

Because they are deprecated, the packages under the <code>old</code> directory will not be available in the

standard Go 1 release distributions, although they will be available in source code form for

developers who wish to use them.

</p>

<p>

The packages in their new locations are:

</p>

<ul>

<li><code>old/netchan</code></li>

</ul>

<p>

<em>Updating</em>:

Code that uses packages now in <code>old</code> will need to be updated by hand,

or else compiled from an installation that has <code>old</code> available.

The <code>go</code> <code>fix</code> tool will warn about such uses.

</p>

<h3 id="deleted">Deleted packages</h3>

<p>

Go 1 deletes several packages outright:

</p>

<ul>

<li><code>container/vector</code></li>

<li><code>exp/datafmt</code></li>

<li><code>go/typechecker</code></li>

<li><code>old/regexp</code></li>

<li><code>old/template</code></li>

</ul>

<p>

and also the command <code>gotry</code>.

</p>

<p>

<em>Updating</em>:

Code that uses <code>container/vector</code> should be updated to use

slices directly. See

<a href="//code.google.com/p/go-wiki/wiki/SliceTricks">the Go

Language Community Wiki</a> for some suggestions.

Code that uses the other packages (there should be almost zero) will need to be rethought.

</p>

<h3 id="subrepo">Packages moving to subrepositories</h3>

<p>

Go 1 has moved a number of packages into other repositories, usually sub-repositories of

<a href="//code.google.com/p/go/">the main Go repository</a>.

This table lists the old and new import paths:

<tr>

</tr>

<tr>

</tr>

<tr><td>crypto/bcrypt</td> <td>code.google.com/p/go.crypto/bcrypt</tr>

<tr><td>crypto/blowfish</td> <td>code.google.com/p/go.crypto/blowfish</tr>

<tr><td>crypto/cast5</td> <td>code.google.com/p/go.crypto/cast5</tr>

<tr><td>crypto/md4</td> <td>code.google.com/p/go.crypto/md4</tr>

<tr><td>crypto/ocsp</td> <td>code.google.com/p/go.crypto/ocsp</tr>

<tr><td>crypto/openpgp</td> <td>code.google.com/p/go.crypto/openpgp</tr>

<tr><td>crypto/openpgp/armor</td> <td>code.google.com/p/go.crypto/openpgp/armor</tr>

<tr><td>crypto/openpgp/elgamal</td> <td>code.google.com/p/go.crypto/openpgp/elgamal</tr>

<tr><td>crypto/openpgp/errors</td> <td>code.google.com/p/go.crypto/openpgp/errors</tr>

<tr><td>crypto/openpgp/packet</td> <td>code.google.com/p/go.crypto/openpgp/packet</tr>

<tr><td>crypto/openpgp/s2k</td> <td>code.google.com/p/go.crypto/openpgp/s2k</tr>

<tr><td>crypto/ripemd160</td> <td>code.google.com/p/go.crypto/ripemd160</tr>

<tr><td>crypto/twofish</td> <td>code.google.com/p/go.crypto/twofish</tr>

<tr><td>crypto/xtea</td> <td>code.google.com/p/go.crypto/xtea</tr>

<tr><td>exp/ssh</td> <td>code.google.com/p/go.crypto/ssh</tr>

<tr>

</tr>

<tr><td>image/bmp</td> <td>code.google.com/p/go.image/bmp</tr>

<tr><td>image/tiff</td> <td>code.google.com/p/go.image/tiff</tr>

<tr>

</tr>

<tr><td>net/dict</td> <td>code.google.com/p/go.net/dict</tr>

<tr><td>net/websocket</td> <td>code.google.com/p/go.net/websocket</tr>

<tr><td>exp/spdy</td> <td>code.google.com/p/go.net/spdy</tr>

<tr>

</tr>

<tr><td>encoding/git85</td> <td>code.google.com/p/go.codereview/git85</tr>

<tr><td>patch</td> <td>code.google.com/p/go.codereview/patch</tr>

<tr>

</tr>

<tr><td>exp/wingui</td> <td>code.google.com/p/gowingui</tr>

</table>

<p>

<em>Updating</em>:

Running <code>go</code> <code>fix</code> will update imports of these packages to use the new import paths.

Installations that depend on these packages will need to install them using

a <code>go get</code> command.

</p>

<h2 id="major">Major changes to the library</h2>

<p>

This section describes significant changes to the core libraries, the ones that

< 10BC8 div class="react-code-text react-code-line-contents" style="min-height:auto">

affect the most programs.

</p>

<h3 id="errors">The error type and errors package</h3>

<p>

The placement of <code>os.Error</code> in package <code>os</code> is mostly historical: errors first came up when implementing package <code>os</code>, and they seemed system-related at the time.

Since then it has become clear that errors are more fundamental than the operating system. For example, it would be nice to use <code>Errors</code> in packages that <code>os</code> depends on, like <code>syscall</code>.

Also, having <code>Error</code> in <code>os</code> introduces many dependencies on <code>os</code> that would otherwise not exist.

</p>

<p>

Go 1 solves these problems by introducing a built-in <code>error</code> interface type and a separate <code>errors</code> package (analogous to <code>bytes</code> and <code>strings</code>) that contains utility functions.

It replaces <code>os.NewError</code> with

<a href="/pkg/errors/#New"><code>errors.New</code></a>,

giving errors a more central place in the environment.

</p>

<p>

So the widely-used <code>String</code> method does not cause accidental satisfaction

of the <code>error</code> interface, the <code>error</code> interface uses instead

the name <code>Error</code> for that method:

</p>

<pre>

type error interface {

Error() string

}

</pre>

<p>

The <code>fmt</code> library automatically invokes <code>Error</code>, as it already

does for <code>String</code>, for easy printing of error values.

</p>

{{code "/doc/progs/go1.go" `/START ERROR EXAMPLE/` `/END ERROR EXAMPLE/`}}

<p>

All standard packages have been updated to use the new interface; the old <code>os.Error</code> is gone.

</p>

<p>

A new package, <a href="/pkg/errors/"><code>errors</code></a>, contains the function

</p>

<pre>

func New(text string) error

</pre>

<p>

to turn a string into an error. It replaces the old <code>os.NewError</code>.

</p>

<p>

<em>Updating</em>:

Running <code>go</code> <code>fix</code> will update almost all code affected by the change.

Code that defines error types with a <code>String</code> method will need to be updated

by hand to rename the methods to <code>Error</code>.

</p>

<h3 id="errno">System call errors</h3>

<p>

The old <code>syscall</code> package, which predated <code>os.Error</code>

(and just about everything else),

returned errors as <code>int</code> values.

In turn, the <code>os</code> package forwarded many of these errors, such

as <code>EINVAL</code>, but using a different set of errors on each platform.

This behavior was unpleasant and unportable.

</p>

<p>

In Go 1, the

<a href="/pkg/syscall/"><code>syscall</code></a>

package instead returns an <code>error</code> for system call errors.

On Unix, the implementation is done by a

<a href="/pkg/syscall/#Errno"><code>syscall.Errno</code></a> type

that satisfies <code>error</code> and replaces the old <code>os.Errno</code>.

</p>

<p>

The changes affecting <code>os.EINVAL</code> and relatives are

described <a href="#os">elsewhere</a>.

<p>

<em>Updating</em>:

Running <code>go</code> <code>fix</code> will update almost all code affected by the change.

Regardless, most code should use the <code>os</code> package

rather than <code>syscall</code> and so will be unaffected.

</p>

<p>

Time is always a challenge to support well in a programming language.

The old Go <code>time</code> package had <code>int64</code> units, no

real type safety,

and no distinction between absolute times and durations.

</p>

<p>

One of the most sweeping changes in the Go 1 library is therefore a

complete redesign of the

<a href="/pkg/time/"><code>time</code></a> package.

Instead of an integer number of nanoseconds as an <code>int64</code>,

and a separate <code>*time.Time</code> type to deal with human

units such as hours and years,

there are now two fundamental types:

(a value, so the <code>*</code> is gone), which represents a moment in time;

and <a href="/pkg/time/#Duration"><code>time.Duration</code></a>,

which represents an interval.

Both have nanosecond resolution.

A <code>Time</code> can represent any time into the ancient

past and remote future, while a <code>Duration</code> can

span plus or minus only about 290 years.

There are methods on these types, plus a number of helpful

predefined constant durations such as <code>time.Second</code>.

</p>

<p>

Among the new methods are things like

<a href="/pkg/time/#Time.Add"><code>Time.Add</code></a>,

which adds a <code>Duration</code> to a <code>Time</code>, and

<a href="/pkg/time/#Time.Sub"><code>Time.Sub</code></a>,

which subtracts two <code>Times</code> to yield a <code>Duration</code>.

</p>

<p>

The most important semantic change is that the Unix epoch (Jan 1, 1970) is now

relevant only for those functions and methods that mention Unix:

and the <a href="/pkg/time/#Time.Unix"><code>Unix</code></a>

and <a href="/pkg/time/#Time.UnixNano"><code>UnixNano</code></a> methods

of the <code>Time</code> type.

In particular,

returns a <code>time.Time</code> value rather than, in the old

API, an integer nanosecond count since the Unix epoch.

</p>

{{code "/doc/progs/go1.go" `/sleepUntil/` `/^}/`}}

<p>

The new types, methods, and constants have been propagated through

all the standard packages that use time, such as <code>os</code> and

its representation of file time stamps.

</p>

<p>

<em>Updating</em>:

The <code>go</code> <code>fix</code> tool will update many uses of the old <code>time</code> package to use the new

types and methods, although it does not replace values such as <code>1e9</code>

representing nanoseconds per second.

Also, because of type changes in some of the values that arise,

some of the expressions rewritten by the fix tool may require

further hand editing; in such cases the rewrite will include

the correct function or method for the old functionality, but

may have the wrong type or require further analysis.

</p>

<h2 id="minor">Minor changes to the library</h2>

<p>

This section describes smaller changes, such as those to less commonly

used packages or that affect

few programs beyond the need to run <code>go</code> <code>fix</code>.

This category includes packages that are new in Go 1.

Collectively they improve portability, regularize behavior, and

make the interfaces more modern and Go-like.

</p>

<h3 id="archive_zip">The archive/zip package</h3>

<p>

In Go 1, <a href="/pkg/archive/zip/#Writer"><code>*zip.Writer</code></a> no

longer has a <code>Write</code> method. Its presence was a mistake.

</p>

<p>

<em>Updating</em>:

What little code is affected will be caught by the compiler and must be updated by hand.

</p>

<h3 id="bufio">The bufio package</h3>

<p>

In Go 1, <a href="/pkg/bufio/#NewReaderSize"><code>bufio.NewReaderSize</code></a>

and

<a href="/pkg/bufio/#NewWriterSize"><code>bufio.NewWriterSize</code></a>

functions no longer return an error for invalid sizes.

If the argument size is too small or invalid, it is adjusted.

</p>

<p>

<em>Updating</em>:

Running <code>go</code> <code>fix</code> will update calls that assign the error to _.

Calls that aren't fixed will be caught by the compiler and must be updated by hand.

</p>

<h3 id="compress">The compress/flate, compress/gzip and compress/zlib packages</h3>

<p>

In Go 1, the <code>NewWriterXxx</code> functions in

<a href="/pkg/compress/flate"><code>compress/flate</code></a>,

<a href="/pkg/compress/gzip"><code>compress/gzip</code></a> and

<a href="/pkg/compress/zlib"><code>compress/zlib</code></a>

all return <code>(*Writer, error)</code> if they take a compression level,

and <code>*Writer</code> otherwise. Package <code>gzip</code>'s

<code>Compressor</code> and <code>Decompressor</code> types have been renamed

to <code>Writer</code> and <code>Reader</code>. Package <code>flate</code>'s

<code>WrongValueError</code> type has been removed.

</p>

<p>

<em>Updating</em>

Running <code>go</code> <code>fix</code> will update old names and calls that assign the error to _.

Calls that aren't fixed will be caught by the compiler and must be updated by hand.

</p>

<h3 id="crypto_aes_des">The crypto/aes and crypto/des packages</h3>

<p>

In Go 1, the <code>Reset</code> method has been removed. Go does not guarantee

that memory is not copied and therefore this method was misleading.

</p>

<p>

The cipher-specific types <code>*aes.Cipher</code>, <code>*des.Cipher</code>,

and <code>*des.TripleDESCipher</code> have been removed in favor of

<code>cipher.Block</code>.

</p>

<p>

<em>Updating</em>:

Remove the calls to Reset. Replace uses of the specific cipher types with

cipher.Block.

</p>

<h3 id="crypto_elliptic">The crypto/elliptic package</h3>

<p>

In Go 1, <a href="/pkg/crypto/elliptic/#Curve"><code>elliptic.Curve</code></a>

has been made an interface to permit alternative implementations. The curve

parameters have been moved to the

<a href="/pkg/crypto/elliptic/#CurveParams"><code>elliptic.CurveParams</code></a>

structure.

</p>

<p>

<em>Updating</em>:

Existing users of <code>*elliptic.Curve</code> will need to change to

simply <code>elliptic.Curve</code>. Calls to <code>Marshal</code>,

<code>Unmarshal</code> and <code>GenerateKey</code> are now functions

in <code>crypto/elliptic</code> that take an <code>elliptic.Curve</code>

as their first argument.

</p>

<h3 id="crypto_hmac">The crypto/hmac package</h3>

<p>

In Go 1, the hash-specific functions, such as <code>hmac.NewMD5</code>, have

been removed from <code>crypto/hmac</code>. Instead, <code>hmac.New</code> takes

a function that returns a <code>hash.Hash</code>, such as <code>md5.New</code>.

</p>

<p>

<em>Updating</em>:

Running <code>go</code> <code>fix</code> will perform the needed changes.

</p>

<h3 id="crypto_x509">The crypto/x509 package</h3>

<p>

In Go 1, the

View remainder of file in raw view

FilesExpand file tree

go1.html

Latest commit

History

go1.html

File metadata and controls