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

This is the reference manual for the Go programming language.

The pre-Go1.18 version, without generics, can be found

<a href="/doc/go1.17_spec.html">here</a>.

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 grammar is compact and simple to parse, 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="https://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 "Number, decimal digit" */ .

In <a href="https://www.unicode.org/versions/Unicode8.0.0/">The Unicode Standard 8.0</a>,

Section 4.5 "General Category" defines a set of character categories.

Go treats all characters in any of the Letter categories Lu, Ll, Lt, Lm, or Lo

as Unicode letters, and those in the Number 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" .

binary_digit = "0" | "1" .

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 punctuation</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_punctuation">operators and punctuation</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_punctuation">Operators and punctuation</h3>

The following character sequences represent <a href="#Operators">operators</a>

(including <a href="#Assignments">assignment operators</a>) and punctuation:

<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>0b</code> or <code>0B</code>

for binary, <code>0</code>, <code>0o</code>, or <code>0O</code> for octal,

and <code>0x</code> or <code>0X</code> for hexadecimal.

A single <code>0</code> is considered a decimal zero.

In hexadecimal literals, letters <code>a</code> through <code>f</code>

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

For readability, an underscore character <code>_</code> may appear after

a base prefix or between successive digits; such underscores do not change

the literal's value.

<pre class="ebnf">

int_lit = decimal_lit | binary_lit | octal_lit | hex_lit .

decimal_lit = "0" | ( "1" … "9" ) [ [ "_" ] decimal_digits ] .

binary_lit = "0" ( "b" | "B" ) [ "_" ] binary_digits .

octal_lit = "0" [ "o" | "O" ] [ "_" ] octal_digits .

hex_lit = "0" ( "x" | "X" ) [ "_" ] hex_digits .

decimal_digits = decimal_digit { [ "_" ] decimal_digit } .

binary_digits = binary_digit { [ "_" ] binary_digit } .

octal_digits = octal_digit { [ "_" ] octal_digit } .

hex_digits = hex_digit { [ "_" ] hex_digit } .

42

4_2

0600

0_600

0o600

0O600 // second character is capital letter 'O'

0xBadFace

0xBad_Face

0x_67_7a_2f_cc_40_c6

170141183460469231731687303715884105727

170_141183_460469_231731_687303_715884_105727

_42 // an identifier, not an integer literal

42_ // invalid: _ must separate successive digits

4__2 // invalid: only one _ at a time

0_xBadFace // invalid: _ must separate successive digits

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

A floating-point literal is a decimal or hexadecimal representation of a

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

A decimal floating-point literal consists of an integer part (decimal digits),

a decimal point, a fractional part (decimal digits), and an exponent part

(<code>e</code> or <code>E</code> followed by an optional sign and decimal digits).

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

or the exponent part may be elided.

An exponent value exp scales the mantissa (integer and fractional part) by 10^exp.

A hexadecimal floating-point literal consists of a <code>0x</code> or <code>0X</code>

prefix, an integer part (hexadecimal digits), a radix point, a fractional part (hexadecimal digits),

and an exponent part (<code>p</code> or <code>P</code> followed by an optional sign and decimal digits).

One of the integer part or the fractional part may be elided; the radix point may be elided as well,

but the exponent part is required. (This syntax matches the one given in IEEE 754-2008 §5.12.3.)

An exponent value exp scales the mantissa (integer and fractional part) by 2^exp.

For readability, an underscore character <code>_</code> may appear after

a base prefix or between successive digits; such underscores do not change

the literal value.

<pre class="ebnf">

float_lit = decimal_float_lit | hex_float_lit .

decimal_float_lit = decimal_digits "." [ decimal_digits ] [ decimal_exponent ] |

decimal_digits decimal_exponent |

"." decimal_digits [ decimal_exponent ] .

decimal_exponent = ( "e" | "E" ) [ "+" | "-" ] decimal_digits .

hex_float_lit = "0" ( "x" | "X" ) hex_mantissa hex_exponent .

hex_mantissa = [ "_" ] hex_digits "." [ hex_digits ] |

[ "_" ] hex_digits |

"." hex_digits .

hex_exponent = ( "p" | "P" ) [ "+" | "-" ] decimal_digits .

0.

72.40

072.40 // == 72.40

2.71828

1.e+0

6.67428e-11

1E6

.25

.12345E+5

1_5. // == 15.0

0.15e+0_2 // == 15.0

0x1p-2 // == 0.25

0x2.p10 // == 2048.0

0x1.Fp+0 // == 1.9375

0X.8p-0 // == 0.5

0X_1FFFP-16 // == 0.1249847412109375

0x15e-2 // == 0x15e - 2 (integer subtraction)

0x.p1 // invalid: mantissa has no digits

1p-2 // invalid: p exponent requires hexadecimal mantissa

0x1.5e-2 // invalid: hexadecimal mantissa requires p exponent

1_.5 // invalid: _ must separate successive digits

1._5 // invalid: _ must separate successive digits

1.5_e1 // invalid: _ must separate successive digits

1.5e_1 // invalid: _ must separate successive digits

1.5e1_ // invalid: _ must separate successive digits

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

An imaginary literal represents the imaginary part of a

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

It consists of an <a href="#Integer_literals">integer</a> or

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

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

The value of an imaginary literal is the value of the respective

integer or floating-point literal multiplied by the imaginary unit <i>i</i>.

<pre class="ebnf">

imaginary_lit = (decimal_digits | int_lit | float_lit) "i" .

For backward compatibility, an imaginary literal's integer part consisting

entirely of decimal digits (and possibly underscores) is considered a decimal

integer, even if it starts with a leading <code>0</code>.

0i

0123i // == 123i for backward-compatibility

0o123i // == 0o123 * 1i == 83i

0xabci // == 0xabc * 1i == 2748i

0.i

2.71828i

1.e+0i

6.67428e-11i

1E6i

.25i

.12345E+5i

0x1p-2i // == 0x1p-2 * 1i == 0.25i

<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

'\400' // illegal: octal value over 255

'\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 <a href="#Package_unsafe">certain values</a>,

<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 exact values of arbitrary precision and do not overflow.

Consequently, there are no constants denoting the IEEE-754 negative zero, infinity,

and not-a-number values.

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 <a href="#Representability">represented</a> as a value of the respective type.

If the type is a type parameter, the constant is converted into a non-constant

value of the type parameter.

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.

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 binary exponent of at least 16 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 (non-interface) 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 a set of values together with operations and methods specific

to those values. A type may be denoted by a <i>type name</i>, if it has one, which must be

followed by <a href="#Instantiations">type arguments</a> if the type is generic.

A type may also be specified using a <i>type literal</i>, which composes a type

from existing types.

<pre class="ebnf">

Type = TypeName [ TypeArgs ] | TypeLit | "(" Type ")" .

TypeName = identifier | QualifiedIdent .

TypeArgs = "[" TypeList [ "," ] "]" .

TypeList = Type { "," Type } .

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

SliceType | MapType | ChannelType .

The language <a href="#Predeclared_identifiers">predeclares</a> certain type names.

Others are introduced with <a href="#Type_declarations">type declarations</a>

or <a href="#Type_parameter_declarations">type parameter lists</a>.

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

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

type literals.

Predeclared types, defined types, and type parameters are called <i>named types</i>.

An alias denotes a named type if the type given in the alias declaration is a named 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>;

it is a <a href="#Type_definitions">defined type</a>.

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

An <i>integer</i>, <i>floating-point</i>, or <i>complex</i> type

represents the set of integer, floating-point, or complex values, respectively.

They are collectively called <i>numeric types</i>.

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="https://en.wikipedia.org/wiki/Two's_complement">two's complement arithmetic</a>.

There is also a set of predeclared integer 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 <a href="#Type_definitions">defined

types</a> and thus distinct except

<code>byte</code>, which is an <a href="#Alias_declarations">alias</a> for <code>uint8</code>, and

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

Explicit 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.

The number of bytes is called the length of the string and is never negative.

Strings are immutable: once created,

it is impossible to change the contents of a string.

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

it is a <a href="#Type_definitions">defined type</a>.

The length of a string <code>s</code> 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 of the array 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>

<a href="#Representability">representable</a> 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 number of elements is called the length of the slice and is never negative.

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

<pre class="ebnf">

SliceType = "[" "]" ElementType .

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> may be

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)