<h2 id="Introduction">Introduction</h2>

This is a reference manual for the Go programming language. For

more information and other documents, see <a href="/">golang.org</a>.

Go is a general-purpose language designed with systems programming

in mind. It is strongly typed and garbage-collected and has explicit

support for concurrent programming. Programs are constructed from

<i>packages</i>, whose properties allow efficient management of

dependencies. The existing implementations use a traditional

compile/link model to generate executable binaries.

The grammar is compact and regular, allowing for easy analysis by

automatic tools such as integrated development environments.

<h2 id="Notation">Notation</h2>

The syntax is specified using Extended Backus-Naur Form (EBNF):

<pre class="grammar">

Production = production_name "=" [ Expression ] "." .

Expression = Alternative { "|" Alternative } .

Alternative = Term { Term } .

Term = production_name | token [ "…" token ] | Group | Option | Repetition .

Group = "(" Expression ")" .

Option = "[" Expression "]" .

Repetition = "{" Expression "}" .

Productions are expressions constructed from terms and the following

operators, in increasing precedence:

<pre class="grammar">

| alternation

() grouping

[] option (0 or 1 times)

{} repetition (0 to n times)

Lower-case production names are used to identify lexical tokens.

Non-terminals are in CamelCase. Lexical tokens are enclosed in

double quotes <code>""</code> or back quotes <code>``</code>.

The form <code>a … b</code> represents the set of characters from

<code>a</code> through <code>b</code> as alternatives. The horizontal

ellipsis <code>…</code> is also used elsewhere in the spec to informally denote various

enumerations or code snippets that are not further specified. The character <code>…</code>

(as opposed to the three characters <code>...</code>) is not a token of the Go

language.

<h2 id="Source_code_representation">Source code representation</h2>

Source code is Unicode text encoded in

<a href="http://en.wikipedia.org/wiki/UTF-8">UTF-8</a>. The text is not

canonicalized, so a single accented code point is distinct from the

same character constructed from combining an accent and a letter;

those are treated as two code points. For simplicity, this document

will use the unqualified term <i>character</i> to refer to a Unicode code point

in the source text.

Each code point is distinct; for instance, upper and lower case letters

are different characters.

Implementation restriction: For compatibility with other tools, a

compiler may disallow the NUL character (U+0000) in the source text.

Implementation restriction: For compatibility with other tools, a

compiler may ignore a UTF-8-encoded byte order mark

(U+FEFF) if it is the first Unicode code point in the source text.

A byte order mark may be disallowed anywhere else in the source.

<h3 id="Characters">Characters</h3>

The following terms are used to denote specific Unicode character classes:

<pre class="ebnf">

newline = /* the Unicode code point U+000A */ .

unicode_char = /* an arbitrary Unicode code point except newline */ .

unicode_letter = /* a Unicode code point classified as "Letter" */ .

unicode_digit = /* a Unicode code point classified as "Decimal Digit" */ .

In <a href="http://www.unicode.org/versions/Unicode6.3.0/">The Unicode Standard 6.3</a>,

Section 4.5 "General Category"

defines a set of character categories. Go treats

those characters in category Lu, Ll, Lt, Lm, or Lo as Unicode letters,

and those in category Nd as Unicode digits.

<h3 id="Letters_and_digits">Letters and digits</h3>

The underscore character <code>_</code> (U+005F) is considered a letter.

<pre class="ebnf">

letter = unicode_letter | "_" .

decimal_digit = "0" … "9" .

octal_digit = "0" … "7" .

hex_digit = "0" … "9" | "A" … "F" | "a" … "f" .

<h2 id="Lexical_elements">Lexical elements</h2>

<h3 id="Comments">Comments</h3>

Comments serve as program documentation. There are two forms:

<i>Line comments</i> start with the character sequence <code>//</code>

and stop at the end of the line.

<i>General comments</i> start with the character sequence <code>/*</code>

and stop with the first subsequent character sequence <code>*/</code>.

A comment cannot start inside a <a href="#Rune_literals">rune</a> or

<a href="#String_literals">string literal</a>, or inside a comment.

A general comment containing no newlines acts like a space.

Any other comment acts like a newline.

<h3 id="Tokens">Tokens</h3>

Tokens form the vocabulary of the Go language.

There are four classes: <i>identifiers</i>, <i>keywords</i>, <i>operators

and delimiters</i>, and <i>literals</i>. <i>White space</i>, formed from

spaces (U+0020), horizontal tabs (U+0009),

carriage returns (U+000D), and newlines (U+000A),

is ignored except as it separates tokens

that would otherwise combine into a single token. Also, a newline or end of file

may trigger the insertion of a <a href="#Semicolons">semicolon</a>.

While breaking the input into tokens,

the next token is the longest sequence of characters that form a

valid token.

<h3 id="Semicolons">Semicolons</h3>

The formal grammar uses semicolons <code>";"</code> as terminators in

a number of productions. Go programs may omit most of these semicolons

using the following two rules:

When the input is broken into tokens, a semicolon is automatically inserted

into the token stream immediately after a line's final token if that token is

<li>an

<a href="#Identifiers">identifier</a>

</li>

<li>an

<a href="#Integer_literals">integer</a>,

<a href="#Floating-point_literals">floating-point</a>,

<a href="#Imaginary_literals">imaginary</a>,

<a href="#Rune_literals">rune</a>, or

<a href="#String_literals">string</a> literal

</li>

<li>one of the <a href="#Keywords">keywords</a>

<code>break</code>,

<code>continue</code>,

<code>fallthrough</code>, or

<code>return</code>

</li>

<li>one of the <a href="#Operators_and_Delimiters">operators and delimiters</a>

<code>++</code>,

<code>--</code>,

<code>)</code>,

<code>]</code>, or

<code>}</code>

</li>

To allow complex statements to occupy a single line, a semicolon

may be omitted before a closing <code>")"</code> or <code>"}"</code>.

To reflect idiomatic use, code examples in this document elide semicolons

using these rules.

<h3 id="Identifiers">Identifiers</h3>

Identifiers name program entities such as variables and types.

An identifier is a sequence of one or more letters and digits.

The first character in an identifier must be a letter.

<pre class="ebnf">

identifier = letter { letter | unicode_digit } .

a

_x9

ThisVariableIsExported

αβ

Some identifiers are <a href="#Predeclared_identifiers">predeclared</a>.

<h3 id="Keywords">Keywords</h3>

The following keywords are reserved and may not be used as identifiers.

<pre class="grammar">

break default func interface select

case defer go map struct

chan else goto package switch

const fallthrough if range type

continue for import return var

<h3 id="Operators_and_Delimiters">Operators and Delimiters</h3>

The following character sequences represent <a href="#Operators">operators</a>, delimiters, and other special tokens:

<pre class="grammar">

+ &amp; += &amp;= &amp;&amp; == != ( )

- | -= |= || &lt; &lt;= [ ]

* ^ *= ^= &lt;- &gt; &gt;= { }

/ &lt;&lt; /= &lt;&lt;= ++ = := , ;

% &gt;&gt; %= &gt;&gt;= -- ! ... . :

&amp;^ &amp;^=

<h3 id="Integer_literals">Integer literals</h3>

An integer literal is a sequence of digits representing an

<a href="#Constants">integer constant</a>.

An optional prefix sets a non-decimal base: <code>0</code> for octal, <code>0x</code> or

<code>0X</code> for hexadecimal. In hexadecimal literals, letters

<code>a-f</code> and <code>A-F</code> represent values 10 through 15.

<pre class="ebnf">

int_lit = decimal_lit | octal_lit | hex_lit .

decimal_lit = ( "1" … "9" ) { decimal_digit } .

octal_lit = "0" { octal_digit } .

hex_lit = "0" ( "x" | "X" ) hex_digit { hex_digit } .

42

0600

0xBadFace

170141183460469231731687303715884105727

<h3 id="Floating-point_literals">Floating-point literals</h3>

A floating-point literal is a decimal representation of a

<a href="#Constants">floating-point constant</a>.

It has an integer part, a decimal point, a fractional part,

and an exponent part. The integer and fractional part comprise

decimal digits; the exponent part is an <code>e</code> or <code>E</code>

followed by an optionally signed decimal exponent. One of the

integer part or the fractional part may be elided; one of the decimal

point or the exponent may be elided.

<pre class="ebnf">

float_lit = decimals "." [ decimals ] [ exponent ] |

decimals exponent |

"." decimals [ exponent ] .

decimals = decimal_digit { decimal_digit } .

exponent = ( "e" | "E" ) [ "+" | "-" ] decimals .

0.

72.40

072.40 // == 72.40

2.71828

1.e+0

6.67428e-11

1E6

.25

.12345E+5

<h3 id="Imaginary_literals">Imaginary literals</h3>

An imaginary literal is a decimal representation of the imaginary part of a

<a href="#Constants">complex constant</a>.

It consists of a

<a href="#Floating-point_literals">floating-point literal</a>

or decimal integer followed

by the lower-case letter <code>i</code>.

<pre class="ebnf">

imaginary_lit = (decimals | float_lit) "i" .

0i

011i // == 11i

0.i

2.71828i

1.e+0i

6.67428e-11i

1E6i

.25i

.12345E+5i

<h3 id="Rune_literals">Rune literals</h3>

A rune literal represents a <a href="#Constants">rune constant</a>,

an integer value identifying a Unicode code point.

A rune literal is expressed as one or more characters enclosed in single quotes,

as in <code>'x'</code> or <code>'\n'</code>.

Within the quotes, any character may appear except newline and unescaped single

quote. A single quoted character represents the Unicode value

of the character itself,

while multi-character sequences beginning with a backslash encode

values in various formats.

The simplest form represents the single character within the quotes;

since Go source text is Unicode characters encoded in UTF-8, multiple

UTF-8-encoded bytes may represent a single integer value. For

instance, the literal <code>'a'</code> holds a single byte representing

a literal <code>a</code>, Unicode U+0061, value <code>0x61</code>, while

<code>'ä'</code> holds two bytes (<code>0xc3</code> <code>0xa4</code>) representing

a literal <code>a</code>-dieresis, U+00E4, value <code>0xe4</code>.

Several backslash escapes allow arbitrary values to be encoded as

ASCII text. There are four ways to represent the integer value

as a numeric constant: <code>\x</code> followed by exactly two hexadecimal

digits; <code>\u</code> followed by exactly four hexadecimal digits;

<code>\U</code> followed by exactly eight hexadecimal digits, and a

plain backslash <code>\</code> followed by exactly three octal digits.

In each case the value of the literal is the value represented by

the digits in the corresponding base.

Although these representations all result in an integer, they have

different valid ranges. Octal escapes must represent a value between

0 and 255 inclusive. Hexadecimal escapes satisfy this condition

by construction. The escapes <code>\u</code> and <code>\U</code>

represent Unicode code points so within them some values are illegal,

in particular those above <code>0x10FFFF</code> and surrogate halves.

After a backslash, certain single-character escapes represent special values:

<pre class="grammar">

\a U+0007 alert or bell

\b U+0008 backspace

\f U+000C form feed

\n U+000A line feed or newline

\r U+000D carriage return

\t U+0009 horizontal tab

\v U+000b vertical tab

\\ U+005c backslash

\' U+0027 single quote (valid escape only within rune literals)

\" U+0022 double quote (valid escape only within string literals)

All other sequences starting with a backslash are illegal inside rune literals.

<pre class="ebnf">

rune_lit = "'" ( unicode_value | byte_value ) "'" .

unicode_value = unicode_char | little_u_value | big_u_value | escaped_char .

byte_value = octal_byte_value | hex_byte_value .

octal_byte_value = `\` octal_digit octal_digit octal_digit .

hex_byte_value = `\` "x" hex_digit hex_digit .

little_u_value = `\` "u" hex_digit hex_digit hex_digit hex_digit .

big_u_value = `\` "U" hex_digit hex_digit hex_digit hex_digit

hex_digit hex_digit hex_digit hex_digit .

escaped_char = `\` ( "a" | "b" | "f" | "n" | "r" | "t" | "v" | `\` | "'" | `"` ) .

'a'

'ä'

'本'

'\t'

'\000'

'\007'

'\377'

'\x07'

'\xff'

'\u12e4'

'\U00101234'

'\'' // rune literal containing single quote character

'aa' // illegal: too many characters

'\xa' // illegal: too few hexadecimal digits

'\0' // illegal: too few octal digits

'\uDFFF' // illegal: surrogate half

'\U00110000' // illegal: invalid Unicode code point

<h3 id="String_literals">String literals</h3>

A string literal represents a <a href="#Constants">string constant</a>

obtained from concatenating a sequence of characters. There are two forms:

raw string literals and interpreted string literals.

Raw string literals are character sequences between back quotes, as in

<code>`foo`</code>. Within the quotes, any character may appear except

back quote. The value of a raw string literal is the

string composed of the uninterpreted (implicitly UTF-8-encoded) characters

between the quotes;

in particular, backslashes have no special meaning and the string may

contain newlines.

Carriage return characters ('\r') inside raw string literals

are discarded from the raw string value.

Interpreted string literals are character sequences between double

quotes, as in <code>&quot;bar&quot;</code>.

Within the quotes, any character may appear except newline and unescaped double quote.

The text between the quotes forms the

value of the literal, with backslash escapes interpreted as they

are in <a href="#Rune_literals">rune literals</a> (except that <code>\'</code> is illegal and

<code>\"</code> is legal), with the same restrictions.

The three-digit octal (<code>\</code><i>nnn</i>)

and two-digit hexadecimal (<code>\x</code><i>nn</i>) escapes represent individual

<i>bytes</i> of the resulting string; all other escapes represent

the (possibly multi-byte) UTF-8 encoding of individual <i>characters</i>.

Thus inside a string literal <code>\377</code> and <code>\xFF</code> represent

a single byte of value <code>0xFF</code>=255, while <code>ÿ</code>,

<code>\u00FF</code>, <code>\U000000FF</code> and <code>\xc3\xbf</code> represent

the two bytes <code>0xc3</code> <code>0xbf</code> of the UTF-8 encoding of character

U+00FF.

<pre class="ebnf">

string_lit = raw_string_lit | interpreted_string_lit .

raw_string_lit = "`" { unicode_char | newline } "`" .

interpreted_string_lit = `"` { unicode_value | byte_value } `"` .

`abc` // same as "abc"

`\n

\n` // same as "\\n\n\\n"

"\n"

"\"" // same as `"`

"Hello, world!\n"

"日本語"

"\u65e5本\U00008a9e"

"\xff\u00FF"

"\uD800" // illegal: surrogate half

"\U00110000" // illegal: invalid Unicode code point

These examples all represent the same string:

"日本語" // UTF-8 input text

`日本語` // UTF-8 input text as a raw literal

"\u65e5\u672c\u8a9e" // the explicit Unicode code points

"\U000065e5\U0000672c\U00008a9e" // the explicit Unicode code points

"\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e" // the explicit UTF-8 bytes

If the source code represents a character as two code points, such as

a combining form involving an accent and a letter, the result will be

an error if placed in a rune literal (it is not a single code

point), and will appear as two code points if placed in a string

literal.

<h2 id="Constants">Constants</h2>

<p>There are <i>boolean constants</i>,

<i>rune constants</i>,

<i>integer constants</i>,

<i>floating-point constants</i>, <i>complex constants</i>,

and <i>string constants</i>. Rune, integer, floating-point,

and complex constants are

collectively called <i>numeric constants</i>.

A constant value is represented by a

<a href="#Rune_literals">rune</a>,

<a href="#Integer_literals">integer</a>,

<a href="#Floating-point_literals">floating-point</a>,

<a href="#Imaginary_literals">imaginary</a>,

or

<a href="#String_literals">string</a> literal,

an identifier denoting a constant,

a <a href="#Constant_expressions">constant expression</a>,

a <a href="#Conversions">conversion</a> with a result that is a constant, or

the result value of some built-in functions such as

<code>unsafe.Sizeof</code> applied to any value,

<code>cap</code> or <code>len</code> applied to

<a href="#Length_and_capacity">some expressions</a>,

<code>real</code> and <code>imag</code> applied to a complex constant

and <code>complex</code> applied to numeric constants.

The boolean truth values are represented by the predeclared constants

<code>true</code> and <code>false</code>. The predeclared identifier

<a href="#Iota">iota</a> denotes an integer constant.

In general, complex constants are a form of

<a href="#Constant_expressions">constant expression</a>

and are discussed in that section.

Numeric constants represent values of arbitrary precision and do not overflow.

Constants may be <a href="#Types">typed</a> or <i>untyped</i>.

Literal constants, <code>true</code>, <code>false</code>, <code>iota</code>,

and certain <a href="#Constant_expressions">constant expressions</a>

containing only untyped constant operands are untyped.

A constant may be given a type explicitly by a <a href="#Constant_declarations">constant declaration</a>

or <a href="#Conversions">conversion</a>, or implicitly when used in a

<a href="#Variable_declarations">variable declaration</a> or an

<a href="#Assignments">assignment</a> or as an

operand in an <a href="#Expressions">expression</a>.

It is an error if the constant value

cannot be represented as a value of the respective type.

For instance, <code>3.0</code> can be given any integer or any

floating-point type, while <code>2147483648.0</code> (equal to <code>1&lt;&lt;31</code>)

can be given the types <code>float32</code>, <code>float64</code>, or <code>uint32</code> but

not <code>int32</code> or <code>string</code>.

An untyped constant has a <i>default type</i> which is the type to which the

constant is implicitly converted in contexts where a typed value is required,

for instance, in a <a href="#Short_variable_declarations">short variable declaration</a>

such as <code>i := 0</code> where there is no explicit type.

The default type of an untyped constant is <code>bool</code>, <code>rune</code>,

<code>int</code>, <code>float64</code>, <code>complex128</code> or <code>string</code>

respectively, depending on whether it is a boolean, rune, integer, floating-point,

complex, or string constant.

There are no constants denoting the IEEE-754 infinity and not-a-number values,

but the <a href="/pkg/math/"><code>math</code> package</a>'s

<a href="/pkg/math/#Inf">Inf</a>,

<a href="/pkg/math/#NaN">NaN</a>,

<a href="/pkg/math/#IsInf">IsInf</a>, and

<a href="/pkg/math/#IsNaN">IsNaN</a>

functions return and test for those values at run time.

Implementation restriction: Although numeric constants have arbitrary

precision in the language, a compiler may implement them using an

internal representation with limited precision. That said, every

implementation must:

<li>Represent integer constants with at least 256 bits.</li>

<li>Represent floating-point constants, including the parts of

a complex constant, with a mantissa of at least 256 bits

and a signed exponent of at least 32 bits.</li>

<li>Give an error if unable to represent an integer constant

precisely.</li>

<li>Give an error if unable to represent a floating-point or

complex constant due to overflow.</li>

<li>Round to the nearest representable constant if unable to

represent a floating-point or complex constant due to limits

on precision.</li>

These requirements apply both to literal constants and to the result

of evaluating <a href="#Constant_expressions">constant

expressions</a>.

<h2 id="Variables">Variables</h2>

A variable is a storage location for holding a <i>value</i>.

The set of permissible values is determined by the

variable's <i><a href="#Types">type</a></i>.

A <a href="#Variable_declarations">variable declaration</a>

or, for function parameters and results, the signature

of a <a href="#Function_declarations">function declaration</a>

or <a href="#Function_literals">function literal</a> reserves

storage for a named variable.

Calling the built-in function <a href="#Allocation"><code>new</code></a>

or taking the address of a <a href="#Composite_literals">composite literal</a>

allocates storage for a variable at run time.

Such an anonymous variable is referred to via a (possibly implicit)

<a href="#Address_operators">pointer indirection</a>.

<i>Structured</i> variables of <a href="#Array_types">array</a>, <a href="#Slice_types">slice</a>,

and <a href="#Struct_types">struct</a> types have elements and fields that may

be <a href="#Address_operators">addressed</a> individually. Each such element

acts like a variable.

The <i>static type</i> (or just <i>type</i>) of a variable is the

type given in its declaration, the type provided in the

<code>new</code> call or composite literal, or the type of

an element of a structured variable.

Variables of interface type also have a distinct <i>dynamic type</i>,

which is the concrete type of the value assigned to the variable at run time

(unless the value is the predeclared identifier <code>nil</code>,

which has no type).

The dynamic type may vary during execution but values stored in interface

variables are always <a href="#Assignability">assignable</a>

to the static type of the variable.

var x interface{} // x is nil and has static type interface{}

var v *T // v has value nil, static type *T

x = 42 // x has value 42 and dynamic type int

x = v // x has value (*T)(nil) and dynamic type *T

A variable's value is retrieved by referring to the variable in an

<a href="#Expressions">expression</a>; it is the most recent value

<a href="#Assignments">assigned</a> to the variable.

If a variable has not yet been assigned a value, its value is the

<a href="#The_zero_value">zero value</a> for its type.

<h2 id="Types">Types</h2>

A type determines the set of values and operations specific to values of that

type. Types may be <i>named</i> or <i>unnamed</i>. Named types are specified

by a (possibly <a href="#Qualified_identifiers">qualified</a>)

<a href="#Type_declarations"><i>type name</i></a>; unnamed types are specified

using a <i>type literal</i>, which composes a new type from existing types.

<pre class="ebnf">

Type = TypeName | TypeLit | "(" Type ")" .

TypeName = identifier | QualifiedIdent .

TypeLit = ArrayType | StructType | PointerType | FunctionType | InterfaceType |

SliceType | MapType | ChannelType .

Named instances of the boolean, numeric, and string types are

<a href="#Predeclared_identifiers">predeclared</a>.

<i>Composite types</i>&mdash;array, struct, pointer, function,

interface, slice, map, and channel types&mdash;may be constructed using

type literals.

Each type <code>T</code> has an <i>underlying type</i>: If <code>T</code>

is one of the predeclared boolean, numeric, or string types, or a type literal,

the corresponding underlying

type is <code>T</code> itself. Otherwise, <code>T</code>'s underlying type

is the underlying type of the type to which <code>T</code> refers in its

<a href="#Type_declarations">type declaration</a>.

type T1 string

type T2 T1

type T3 []T1

type T4 T3

The underlying type of <code>string</code>, <code>T1</code>, and <code>T2</code>

is <code>string</code>. The underlying type of <code>[]T1</code>, <code>T3</code>,

and <code>T4</code> is <code>[]T1</code>.

<h3 id="Method_sets">Method sets</h3>

A type may have a <i>method set</i> associated with it.

The method set of an <a href="#Interface_types">interface type</a> is its interface.

The method set of any other type <code>T</code> consists of all

<a href="#Method_declarations">methods</a> declared with receiver type <code>T</code>.

The method set of the corresponding <a href="#Pointer_types">pointer type</a> <code>*T</code>

is the set of all methods declared with receiver <code>*T</code> or <code>T</code>

(that is, it also contains the method set of <code>T</code>).

Further rules apply to structs containing anonymous fields, as described

in the section on <a href="#Struct_types">struct types</a>.

Any other type has an empty method set.

In a method set, each method must have a

<a href="#Uniqueness_of_identifiers">unique</a>

non-<a href="#Blank_identifier">blank</a> <a href="#MethodName">method name</a>.

The method set of a type determines the interfaces that the

type <a href="#Interface_types">implements</a>

and the methods that can be <a href="#Calls">called</a>

using a receiver of that type.

<h3 id="Boolean_types">Boolean types</h3>

A <i>boolean type</i> represents the set of Boolean truth values

denoted by the predeclared constants <code>true</code>

and <code>false</code>. The predeclared boolean type is <code>bool</code>.

<h3 id="Numeric_types">Numeric types</h3>

A <i>numeric type</i> represents sets of integer or floating-point values.

The predeclared architecture-independent numeric types are:

<pre class="grammar">

uint8 the set of all unsigned 8-bit integers (0 to 255)

uint16 the set of all unsigned 16-bit integers (0 to 65535)

uint32 the set of all unsigned 32-bit integers (0 to 4294967295)

uint64 the set of all unsigned 64-bit integers (0 to 18446744073709551615)

int8 the set of all signed 8-bit integers (-128 to 127)

int16 the set of all signed 16-bit integers (-32768 to 32767)

int32 the set of all signed 32-bit integers (-2147483648 to 2147483647)

int64 the set of all signed 64-bit integers (-9223372036854775808 to 9223372036854775807)

float32 the set of all IEEE-754 32-bit floating-point numbers

float64 the set of all IEEE-754 64-bit floating-point numbers

complex64 the set of all complex numbers with float32 real and imaginary parts

complex128 the set of all complex numbers with float64 real and imaginary parts

byte alias for uint8

rune alias for int32

The value of an <i>n</i>-bit integer is <i>n</i> bits wide and represented using

<a href="http://en.wikipedia.org/wiki/Two's_complement">two's complement arithmetic</a>.

There is also a set of predeclared numeric types with implementation-specific sizes:

<pre class="grammar">

uint either 32 or 64 bits

int same size as uint

uintptr an unsigned integer large enough to store the uninterpreted bits of a pointer value

To avoid portability issues all numeric types are distinct except

<code>byte</code>, which is an alias for <code>uint8</code>, and

<code>rune</code>, which is an alias for <code>int32</code>.

Conversions

are required when different numeric types are mixed in an expression

or assignment. For instance, <code>int32</code> and <code>int</code>

are not the same type even though they may have the same size on a

particular architecture.

<h3 id="String_types">String types</h3>

A <i>string type</i> represents the set of string values.

A string value is a (possibly empty) sequence of bytes.

Strings are immutable: once created,

it is impossible to change the contents of a string.

The predeclared string type is <code>string</code>.

The length of a string <code>s</code> (its size in bytes) can be discovered using

the built-in function <a href="#Length_and_capacity"><code>len</code></a>.

The length is a compile-time constant if the string is a constant.

A string's bytes can be accessed by integer <a href="#Index_expressions">indices</a>

0 through <code>len(s)-1</code>.

It is illegal to take the address of such an element; if

<code>s[i]</code> is the <code>i</code>'th byte of a

string, <code>&amp;s[i]</code> is invalid.

<h3 id="Array_types">Array types</h3>

An array is a numbered sequence of elements of a single

type, called the element type.

The number of elements is called the length and is never

negative.

<pre class="ebnf">

ArrayType = "[" ArrayLength "]" ElementType .

ArrayLength = Expression .

ElementType = Type .

The length is part of the array's type; it must evaluate to a

non-negative <a href="#Constants">constant</a> representable by a value

of type <code>int</code>.

The length of array <code>a</code> can be discovered

using the built-in function <a href="#Length_and_capacity"><code>len</code></a>.

The elements can be addressed by integer <a href="#Index_expressions">indices</a>

0 through <code>len(a)-1</code>.

Array types are always one-dimensional but may be composed to form

multi-dimensional types.

[32]byte

[2*N] struct { x, y int32 }

[1000]*float64

[3][5]int

[2][2][2]float64 // same as [2]([2]([2]float64))

<h3 id="Slice_types">Slice types</h3>

A slice is a descriptor for a contiguous segment of an <i>underlying array</i> and

provides access to a numbered sequence of elements from that array.

A slice type denotes the set of all slices of arrays of its element type.

The value of an uninitialized slice is <code>nil</code>.

<pre class="ebnf">

SliceType = "[" "]" ElementType .

Like arrays, slices are indexable and have a length. The length of a

slice <code>s</code> can be discovered by the built-in function

<a href="#Length_and_capacity"><code>len</code></a>; unlike with arrays it may change during

execution. The elements can be addressed by integer <a href="#Index_expressions">indices</a>

0 through <code>len(s)-1</code>. The slice index of a

given element may be less than the index of the same element in the

underlying array.

A slice, once initialized, is always associated with an underlying

array that holds its elements. A slice therefore shares storage

with its array and with other slices of the same array; by contrast,

distinct arrays always represent distinct storage.

The array underlying a slice may extend past the end of the slice.

The <i>capacity</i> is a measure of that extent: it is the sum of

the length of the slice and the length of the array beyond the slice;

a slice of length up to that capacity can be created by

<a href="#Slice_expressions"><i>slicing</i></a> a new one from the original slice.

The capacity of a slice <code>a</code> can be discovered using the

built-in function <a href="#Length_and_capacity"><code>cap(a)</code></a>.

A new, initialized slice value for a given element type <code>T</code> is

made using the built-in function

<a href="#Making_slices_maps_and_channels"><code>make</code></a>,

which takes a slice type

and parameters specifying the length and optionally the capacity.

A slice created with <code>make</code> always allocates a new, hidden array

to which the returned slice value refers. That is, executing

make([]T, length, capacity)

produces the same slice as allocating an array and <a href="#Slice_expressions">slicing</a>

it, so these two expressions are equivalent:

make([]int, 50, 100)

new([100]int)[0:50]

Like arrays, slices are always one-dimensional but may be composed to construct

higher-dimensional objects.

With arrays of arrays, the inner arrays are, by construction, always the same length;

however with slices of slices (or arrays of slices), the inner lengths may vary dynamically.

Moreover, the inner slices must be initialized individually.

<h3 id="Struct_types">Struct types</h3>

A struct is a sequence of named elements, called fields, each of which has a

name and a type. Field names may be specified explicitly (IdentifierList) or

implicitly (AnonymousField).

Within a struct, non-<a href="#Blank_identifier">blank</a> field names must

be <a href="#Uniqueness_of_identifiers">unique</a>.

<pre class="ebnf">

StructType = "struct" "{" { FieldDecl ";" } "}" .

FieldDecl = (IdentifierList Type | AnonymousField) [ Tag ] .

AnonymousField = [ "*" ] TypeName .

Tag = string_lit .

// An empty struct.

struct {}

// A struct with 6 fields.

struct {

x, y int

u float32

_ float32 // padding

A *[]int

F func()

}

A field declared with a type but no explicit field name is an <i>anonymous field</i>,

also called an <i>embedded</i> field or an embedding of the type in the struct.

An embedded type must be specified as

a type name <code>T</code> or as a pointer to a non-interface type name <code>*T</code>,

and <code>T</code> itself may not be

a pointer type. The unqualified type name acts as the field name.

// A struct with four anonymous fields of type T1, *T2, P.T3 and *P.T4

struct {

T1 // field name is T1

*T2 // field name is T2

P.T3 // field name is T3

*P.T4 // field name is T4