"Fossies" - the Fresh Open Source Software Archive

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


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

    1 <!--{
    2     "Title": "The Go Programming Language Specification",
    3     "Subtitle": "Version of Jan 14, 2020",
    4     "Path": "/ref/spec"
    5 }-->
    6 
    7 <h2 id="Introduction">Introduction</h2>
    8 
    9 <p>
   10 This is a reference manual for the Go programming language. For
   11 more information and other documents, see <a href="/">golang.org</a>.
   12 </p>
   13 
   14 <p>
   15 Go is a general-purpose language designed with systems programming
   16 in mind. It is strongly typed and garbage-collected and has explicit
   17 support for concurrent programming.  Programs are constructed from
   18 <i>packages</i>, whose properties allow efficient management of
   19 dependencies.
   20 </p>
   21 
   22 <p>
   23 The grammar is compact and simple to parse, allowing for easy analysis
   24 by automatic tools such as integrated development environments.
   25 </p>
   26 
   27 <h2 id="Notation">Notation</h2>
   28 <p>
   29 The syntax is specified using Extended Backus-Naur Form (EBNF):
   30 </p>
   31 
   32 <pre class="grammar">
   33 Production  = production_name "=" [ Expression ] "." .
   34 Expression  = Alternative { "|" Alternative } .
   35 Alternative = Term { Term } .
   36 Term        = production_name | token [ "…" token ] | Group | Option | Repetition .
   37 Group       = "(" Expression ")" .
   38 Option      = "[" Expression "]" .
   39 Repetition  = "{" Expression "}" .
   40 </pre>
   41 
   42 <p>
   43 Productions are expressions constructed from terms and the following
   44 operators, in increasing precedence:
   45 </p>
   46 <pre class="grammar">
   47 |   alternation
   48 ()  grouping
   49 []  option (0 or 1 times)
   50 {}  repetition (0 to n times)
   51 </pre>
   52 
   53 <p>
   54 Lower-case production names are used to identify lexical tokens.
   55 Non-terminals are in CamelCase. Lexical tokens are enclosed in
   56 double quotes <code>""</code> or back quotes <code>``</code>.
   57 </p>
   58 
   59 <p>
   60 The form <code>a … b</code> represents the set of characters from
   61 <code>a</code> through <code>b</code> as alternatives. The horizontal
   62 ellipsis <code></code> is also used elsewhere in the spec to informally denote various
   63 enumerations or code snippets that are not further specified. The character <code></code>
   64 (as opposed to the three characters <code>...</code>) is not a token of the Go
   65 language.
   66 </p>
   67 
   68 <h2 id="Source_code_representation">Source code representation</h2>
   69 
   70 <p>
   71 Source code is Unicode text encoded in
   72 <a href="https://en.wikipedia.org/wiki/UTF-8">UTF-8</a>. The text is not
   73 canonicalized, so a single accented code point is distinct from the
   74 same character constructed from combining an accent and a letter;
   75 those are treated as two code points.  For simplicity, this document
   76 will use the unqualified term <i>character</i> to refer to a Unicode code point
   77 in the source text.
   78 </p>
   79 <p>
   80 Each code point is distinct; for instance, upper and lower case letters
   81 are different characters.
   82 </p>
   83 <p>
   84 Implementation restriction: For compatibility with other tools, a
   85 compiler may disallow the NUL character (U+0000) in the source text.
   86 </p>
   87 <p>
   88 Implementation restriction: For compatibility with other tools, a
   89 compiler may ignore a UTF-8-encoded byte order mark
   90 (U+FEFF) if it is the first Unicode code point in the source text.
   91 A byte order mark may be disallowed anywhere else in the source.
   92 </p>
   93 
   94 <h3 id="Characters">Characters</h3>
   95 
   96 <p>
   97 The following terms are used to denote specific Unicode character classes:
   98 </p>
   99 <pre class="ebnf">
  100 newline        = /* the Unicode code point U+000A */ .
  101 unicode_char   = /* an arbitrary Unicode code point except newline */ .
  102 unicode_letter = /* a Unicode code point classified as "Letter" */ .
  103 unicode_digit  = /* a Unicode code point classified as "Number, decimal digit" */ .
  104 </pre>
  105 
  106 <p>
  107 In <a href="https://www.unicode.org/versions/Unicode8.0.0/">The Unicode Standard 8.0</a>,
  108 Section 4.5 "General Category" defines a set of character categories.
  109 Go treats all characters in any of the Letter categories Lu, Ll, Lt, Lm, or Lo
  110 as Unicode letters, and those in the Number category Nd as Unicode digits.
  111 </p>
  112 
  113 <h3 id="Letters_and_digits">Letters and digits</h3>
  114 
  115 <p>
  116 The underscore character <code>_</code> (U+005F) is considered a letter.
  117 </p>
  118 <pre class="ebnf">
  119 letter        = unicode_letter | "_" .
  120 decimal_digit = "0""9" .
  121 binary_digit  = "0" | "1" .
  122 octal_digit   = "0""7" .
  123 hex_digit     = "0""9" | "A""F" | "a""f" .
  124 </pre>
  125 
  126 <h2 id="Lexical_elements">Lexical elements</h2>
  127 
  128 <h3 id="Comments">Comments</h3>
  129 
  130 <p>
  131 Comments serve as program documentation. There are two forms:
  132 </p>
  133 
  134 <ol>
  135 <li>
  136 <i>Line comments</i> start with the character sequence <code>//</code>
  137 and stop at the end of the line.
  138 </li>
  139 <li>
  140 <i>General comments</i> start with the character sequence <code>/*</code>
  141 and stop with the first subsequent character sequence <code>*/</code>.
  142 </li>
  143 </ol>
  144 
  145 <p>
  146 A comment cannot start inside a <a href="#Rune_literals">rune</a> or
  147 <a href="#String_literals">string literal</a>, or inside a comment.
  148 A general comment containing no newlines acts like a space.
  149 Any other comment acts like a newline.
  150 </p>
  151 
  152 <h3 id="Tokens">Tokens</h3>
  153 
  154 <p>
  155 Tokens form the vocabulary of the Go language.
  156 There are four classes: <i>identifiers</i>, <i>keywords</i>, <i>operators
  157 and punctuation</i>, and <i>literals</i>.  <i>White space</i>, formed from
  158 spaces (U+0020), horizontal tabs (U+0009),
  159 carriage returns (U+000D), and newlines (U+000A),
  160 is ignored except as it separates tokens
  161 that would otherwise combine into a single token. Also, a newline or end of file
  162 may trigger the insertion of a <a href="#Semicolons">semicolon</a>.
  163 While breaking the input into tokens,
  164 the next token is the longest sequence of characters that form a
  165 valid token.
  166 </p>
  167 
  168 <h3 id="Semicolons">Semicolons</h3>
  169 
  170 <p>
  171 The formal grammar uses semicolons <code>";"</code> as terminators in
  172 a number of productions. Go programs may omit most of these semicolons
  173 using the following two rules:
  174 </p>
  175 
  176 <ol>
  177 <li>
  178 When the input is broken into tokens, a semicolon is automatically inserted
  179 into the token stream immediately after a line's final token if that token is
  180 <ul>
  181     <li>an
  182         <a href="#Identifiers">identifier</a>
  183     </li>
  184 
  185     <li>an
  186         <a href="#Integer_literals">integer</a>,
  187         <a href="#Floating-point_literals">floating-point</a>,
  188         <a href="#Imaginary_literals">imaginary</a>,
  189         <a href="#Rune_literals">rune</a>, or
  190         <a href="#String_literals">string</a> literal
  191     </li>
  192 
  193     <li>one of the <a href="#Keywords">keywords</a>
  194         <code>break</code>,
  195         <code>continue</code>,
  196         <code>fallthrough</code>, or
  197         <code>return</code>
  198     </li>
  199 
  200     <li>one of the <a href="#Operators_and_punctuation">operators and punctuation</a>
  201         <code>++</code>,
  202         <code>--</code>,
  203         <code>)</code>,
  204         <code>]</code>, or
  205         <code>}</code>
  206     </li>
  207 </ul>
  208 </li>
  209 
  210 <li>
  211 To allow complex statements to occupy a single line, a semicolon
  212 may be omitted before a closing <code>")"</code> or <code>"}"</code>.
  213 </li>
  214 </ol>
  215 
  216 <p>
  217 To reflect idiomatic use, code examples in this document elide semicolons
  218 using these rules.
  219 </p>
  220 
  221 
  222 <h3 id="Identifiers">Identifiers</h3>
  223 
  224 <p>
  225 Identifiers name program entities such as variables and types.
  226 An identifier is a sequence of one or more letters and digits.
  227 The first character in an identifier must be a letter.
  228 </p>
  229 <pre class="ebnf">
  230 identifier = letter { letter | unicode_digit } .
  231 </pre>
  232 <pre>
  233 a
  234 _x9
  235 ThisVariableIsExported
  236 αβ
  237 </pre>
  238 
  239 <p>
  240 Some identifiers are <a href="#Predeclared_identifiers">predeclared</a>.
  241 </p>
  242 
  243 
  244 <h3 id="Keywords">Keywords</h3>
  245 
  246 <p>
  247 The following keywords are reserved and may not be used as identifiers.
  248 </p>
  249 <pre class="grammar">
  250 break        default      func         interface    select
  251 case         defer        go           map          struct
  252 chan         else         goto         package      switch
  253 const        fallthrough  if           range        type
  254 continue     for          import       return       var
  255 </pre>
  256 
  257 <h3 id="Operators_and_punctuation">Operators and punctuation</h3>
  258 
  259 <p>
  260 The following character sequences represent <a href="#Operators">operators</a>
  261 (including <a href="#assign_op">assignment operators</a>) and punctuation:
  262 </p>
  263 <pre class="grammar">
  264 +    &amp;     +=    &amp;=     &amp;&amp;    ==    !=    (    )
  265 -    |     -=    |=     ||    &lt;     &lt;=    [    ]
  266 *    ^     *=    ^=     &lt;-    &gt;     &gt;=    {    }
  267 /    &lt;&lt;    /=    &lt;&lt;=    ++    =     :=    ,    ;
  268 %    &gt;&gt;    %=    &gt;&gt;=    --    !     ...   .    :
  269      &amp;^          &amp;^=
  270 </pre>
  271 
  272 <h3 id="Integer_literals">Integer literals</h3>
  273 
  274 <p>
  275 An integer literal is a sequence of digits representing an
  276 <a href="#Constants">integer constant</a>.
  277 An optional prefix sets a non-decimal base: <code>0b</code> or <code>0B</code>
  278 for binary, <code>0</code>, <code>0o</code>, or <code>0O</code> for octal,
  279 and <code>0x</code> or <code>0X</code> for hexadecimal.
  280 A single <code>0</code> is considered a decimal zero.
  281 In hexadecimal literals, letters <code>a</code> through <code>f</code>
  282 and <code>A</code> through <code>F</code> represent values 10 through 15.
  283 </p>
  284 
  285 <p>
  286 For readability, an underscore character <code>_</code> may appear after
  287 a base prefix or between successive digits; such underscores do not change
  288 the literal's value.
  289 </p>
  290 <pre class="ebnf">
  291 int_lit        = decimal_lit | binary_lit | octal_lit | hex_lit .
  292 decimal_lit    = "0" | ( "1""9" ) [ [ "_" ] decimal_digits ] .
  293 binary_lit     = "0" ( "b" | "B" ) [ "_" ] binary_digits .
  294 octal_lit      = "0" [ "o" | "O" ] [ "_" ] octal_digits .
  295 hex_lit        = "0" ( "x" | "X" ) [ "_" ] hex_digits .
  296 
  297 decimal_digits = decimal_digit { [ "_" ] decimal_digit } .
  298 binary_digits  = binary_digit { [ "_" ] binary_digit } .
  299 octal_digits   = octal_digit { [ "_" ] octal_digit } .
  300 hex_digits     = hex_digit { [ "_" ] hex_digit } .
  301 </pre>
  302 
  303 <pre>
  304 42
  305 4_2
  306 0600
  307 0_600
  308 0o600
  309 0O600       // second character is capital letter 'O'
  310 0xBadFace
  311 0xBad_Face
  312 0x_67_7a_2f_cc_40_c6
  313 170141183460469231731687303715884105727
  314 170_141183_460469_231731_687303_715884_105727
  315 
  316 _42         // an identifier, not an integer literal
  317 42_         // invalid: _ must separate successive digits
  318 4__2        // invalid: only one _ at a time
  319 0_xBadFace  // invalid: _ must separate successive digits
  320 </pre>
  321 
  322 
  323 <h3 id="Floating-point_literals">Floating-point literals</h3>
  324 
  325 <p>
  326 A floating-point literal is a decimal or hexadecimal representation of a
  327 <a href="#Constants">floating-point constant</a>.
  328 </p>
  329 
  330 <p>
  331 A decimal floating-point literal consists of an integer part (decimal digits),
  332 a decimal point, a fractional part (decimal digits), and an exponent part
  333 (<code>e</code> or <code>E</code> followed by an optional sign and decimal digits).
  334 One of the integer part or the fractional part may be elided; one of the decimal point
  335 or the exponent part may be elided.
  336 An exponent value exp scales the mantissa (integer and fractional part) by 10<sup>exp</sup>.
  337 </p>
  338 
  339 <p>
  340 A hexadecimal floating-point literal consists of a <code>0x</code> or <code>0X</code>
  341 prefix, an integer part (hexadecimal digits), a radix point, a fractional part (hexadecimal digits),
  342 and an exponent part (<code>p</code> or <code>P</code> followed by an optional sign and decimal digits).
  343 One of the integer part or the fractional part may be elided; the radix point may be elided as well,
  344 but the exponent part is required. (This syntax matches the one given in IEEE 754-2008 §5.12.3.)
  345 An exponent value exp scales the mantissa (integer and fractional part) by 2<sup>exp</sup>.
  346 </p>
  347 
  348 <p>
  349 For readability, an underscore character <code>_</code> may appear after
  350 a base prefix or between successive digits; such underscores do not change
  351 the literal value.
  352 </p>
  353 
  354 <pre class="ebnf">
  355 float_lit         = decimal_float_lit | hex_float_lit .
  356 
  357 decimal_float_lit = decimal_digits "." [ decimal_digits ] [ decimal_exponent ] |
  358                     decimal_digits decimal_exponent |
  359                     "." decimal_digits [ decimal_exponent ] .
  360 decimal_exponent  = ( "e" | "E" ) [ "+" | "-" ] decimal_digits .
  361 
  362 hex_float_lit     = "0" ( "x" | "X" ) hex_mantissa hex_exponent .
  363 hex_mantissa      = [ "_" ] hex_digits "." [ hex_digits ] |
  364                     [ "_" ] hex_digits |
  365                     "." hex_digits .
  366 hex_exponent      = ( "p" | "P" ) [ "+" | "-" ] decimal_digits .
  367 </pre>
  368 
  369 <pre>
  370 0.
  371 72.40
  372 072.40       // == 72.40
  373 2.71828
  374 1.e+0
  375 6.67428e-11
  376 1E6
  377 .25
  378 .12345E+5
  379 1_5.         // == 15.0
  380 0.15e+0_2    // == 15.0
  381 
  382 0x1p-2       // == 0.25
  383 0x2.p10      // == 2048.0
  384 0x1.Fp+0     // == 1.9375
  385 0X.8p-0      // == 0.5
  386 0X_1FFFP-16  // == 0.1249847412109375
  387 0x15e-2      // == 0x15e - 2 (integer subtraction)
  388 
  389 0x.p1        // invalid: mantissa has no digits
  390 1p-2         // invalid: p exponent requires hexadecimal mantissa
  391 0x1.5e-2     // invalid: hexadecimal mantissa requires p exponent
  392 1_.5         // invalid: _ must separate successive digits
  393 1._5         // invalid: _ must separate successive digits
  394 1.5_e1       // invalid: _ must separate successive digits
  395 1.5e_1       // invalid: _ must separate successive digits
  396 1.5e1_       // invalid: _ must separate successive digits
  397 </pre>
  398 
  399 
  400 <h3 id="Imaginary_literals">Imaginary literals</h3>
  401 
  402 <p>
  403 An imaginary literal represents the imaginary part of a
  404 <a href="#Constants">complex constant</a>.
  405 It consists of an <a href="#Integer_literals">integer</a> or
  406 <a href="#Floating-point_literals">floating-point</a> literal
  407 followed by the lower-case letter <code>i</code>.
  408 The value of an imaginary literal is the value of the respective
  409 integer or floating-point literal multiplied by the imaginary unit <i>i</i>.
  410 </p>
  411 
  412 <pre class="ebnf">
  413 imaginary_lit = (decimal_digits | int_lit | float_lit) "i" .
  414 </pre>
  415 
  416 <p>
  417 For backward compatibility, an imaginary literal's integer part consisting
  418 entirely of decimal digits (and possibly underscores) is considered a decimal
  419 integer, even if it starts with a leading <code>0</code>.
  420 </p>
  421 
  422 <pre>
  423 0i
  424 0123i         // == 123i for backward-compatibility
  425 0o123i        // == 0o123 * 1i == 83i
  426 0xabci        // == 0xabc * 1i == 2748i
  427 0.i
  428 2.71828i
  429 1.e+0i
  430 6.67428e-11i
  431 1E6i
  432 .25i
  433 .12345E+5i
  434 0x1p-2i       // == 0x1p-2 * 1i == 0.25i
  435 </pre>
  436 
  437 
  438 <h3 id="Rune_literals">Rune literals</h3>
  439 
  440 <p>
  441 A rune literal represents a <a href="#Constants">rune constant</a>,
  442 an integer value identifying a Unicode code point.
  443 A rune literal is expressed as one or more characters enclosed in single quotes,
  444 as in <code>'x'</code> or <code>'\n'</code>.
  445 Within the quotes, any character may appear except newline and unescaped single
  446 quote. A single quoted character represents the Unicode value
  447 of the character itself,
  448 while multi-character sequences beginning with a backslash encode
  449 values in various formats.
  450 </p>
  451 
  452 <p>
  453 The simplest form represents the single character within the quotes;
  454 since Go source text is Unicode characters encoded in UTF-8, multiple
  455 UTF-8-encoded bytes may represent a single integer value.  For
  456 instance, the literal <code>'a'</code> holds a single byte representing
  457 a literal <code>a</code>, Unicode U+0061, value <code>0x61</code>, while
  458 <code>'ä'</code> holds two bytes (<code>0xc3</code> <code>0xa4</code>) representing
  459 a literal <code>a</code>-dieresis, U+00E4, value <code>0xe4</code>.
  460 </p>
  461 
  462 <p>
  463 Several backslash escapes allow arbitrary values to be encoded as
  464 ASCII text.  There are four ways to represent the integer value
  465 as a numeric constant: <code>\x</code> followed by exactly two hexadecimal
  466 digits; <code>\u</code> followed by exactly four hexadecimal digits;
  467 <code>\U</code> followed by exactly eight hexadecimal digits, and a
  468 plain backslash <code>\</code> followed by exactly three octal digits.
  469 In each case the value of the literal is the value represented by
  470 the digits in the corresponding base.
  471 </p>
  472 
  473 <p>
  474 Although these representations all result in an integer, they have
  475 different valid ranges.  Octal escapes must represent a value between
  476 0 and 255 inclusive.  Hexadecimal escapes satisfy this condition
  477 by construction. The escapes <code>\u</code> and <code>\U</code>
  478 represent Unicode code points so within them some values are illegal,
  479 in particular those above <code>0x10FFFF</code> and surrogate halves.
  480 </p>
  481 
  482 <p>
  483 After a backslash, certain single-character escapes represent special values:
  484 </p>
  485 
  486 <pre class="grammar">
  487 \a   U+0007 alert or bell
  488 \b   U+0008 backspace
  489 \f   U+000C form feed
  490 \n   U+000A line feed or newline
  491 \r   U+000D carriage return
  492 \t   U+0009 horizontal tab
  493 \v   U+000b vertical tab
  494 \\   U+005c backslash
  495 \'   U+0027 single quote  (valid escape only within rune literals)
  496 \"   U+0022 double quote  (valid escape only within string literals)
  497 </pre>
  498 
  499 <p>
  500 All other sequences starting with a backslash are illegal inside rune literals.
  501 </p>
  502 <pre class="ebnf">
  503 rune_lit         = "'" ( unicode_value | byte_value ) "'" .
  504 unicode_value    = unicode_char | little_u_value | big_u_value | escaped_char .
  505 byte_value       = octal_byte_value | hex_byte_value .
  506 octal_byte_value = `\` octal_digit octal_digit octal_digit .
  507 hex_byte_value   = `\` "x" hex_digit hex_digit .
  508 little_u_value   = `\` "u" hex_digit hex_digit hex_digit hex_digit .
  509 big_u_value      = `\` "U" hex_digit hex_digit hex_digit hex_digit
  510                            hex_digit hex_digit hex_digit hex_digit .
  511 escaped_char     = `\` ( "a" | "b" | "f" | "n" | "r" | "t" | "v" | `\` | "'" | `"` ) .
  512 </pre>
  513 
  514 <pre>
  515 'a'
  516 'ä'
  517 '本'
  518 '\t'
  519 '\000'
  520 '\007'
  521 '\377'
  522 '\x07'
  523 '\xff'
  524 '\u12e4'
  525 '\U00101234'
  526 '\''         // rune literal containing single quote character
  527 'aa'         // illegal: too many characters
  528 '\xa'        // illegal: too few hexadecimal digits
  529 '\0'         // illegal: too few octal digits
  530 '\uDFFF'     // illegal: surrogate half
  531 '\U00110000' // illegal: invalid Unicode code point
  532 </pre>
  533 
  534 
  535 <h3 id="String_literals">String literals</h3>
  536 
  537 <p>
  538 A string literal represents a <a href="#Constants">string constant</a>
  539 obtained from concatenating a sequence of characters. There are two forms:
  540 raw string literals and interpreted string literals.
  541 </p>
  542 
  543 <p>
  544 Raw string literals are character sequences between back quotes, as in
  545 <code>`foo`</code>.  Within the quotes, any character may appear except
  546 back quote. The value of a raw string literal is the
  547 string composed of the uninterpreted (implicitly UTF-8-encoded) characters
  548 between the quotes;
  549 in particular, backslashes have no special meaning and the string may
  550 contain newlines.
  551 Carriage return characters ('\r') inside raw string literals
  552 are discarded from the raw string value.
  553 </p>
  554 
  555 <p>
  556 Interpreted string literals are character sequences between double
  557 quotes, as in <code>&quot;bar&quot;</code>.
  558 Within the quotes, any character may appear except newline and unescaped double quote.
  559 The text between the quotes forms the
  560 value of the literal, with backslash escapes interpreted as they
  561 are in <a href="#Rune_literals">rune literals</a> (except that <code>\'</code> is illegal and
  562 <code>\"</code> is legal), with the same restrictions.
  563 The three-digit octal (<code>\</code><i>nnn</i>)
  564 and two-digit hexadecimal (<code>\x</code><i>nn</i>) escapes represent individual
  565 <i>bytes</i> of the resulting string; all other escapes represent
  566 the (possibly multi-byte) UTF-8 encoding of individual <i>characters</i>.
  567 Thus inside a string literal <code>\377</code> and <code>\xFF</code> represent
  568 a single byte of value <code>0xFF</code>=255, while <code>ÿ</code>,
  569 <code>\u00FF</code>, <code>\U000000FF</code> and <code>\xc3\xbf</code> represent
  570 the two bytes <code>0xc3</code> <code>0xbf</code> of the UTF-8 encoding of character
  571 U+00FF.
  572 </p>
  573 
  574 <pre class="ebnf">
  575 string_lit             = raw_string_lit | interpreted_string_lit .
  576 raw_string_lit         = "`" { unicode_char | newline } "`" .
  577 interpreted_string_lit = `"` { unicode_value | byte_value } `"` .
  578 </pre>
  579 
  580 <pre>
  581 `abc`                // same as "abc"
  582 `\n
  583 \n`                  // same as "\\n\n\\n"
  584 "\n"
  585 "\""                 // same as `"`
  586 "Hello, world!\n"
  587 "日本語"
  588 "\u65e5本\U00008a9e"
  589 "\xff\u00FF"
  590 "\uD800"             // illegal: surrogate half
  591 "\U00110000"         // illegal: invalid Unicode code point
  592 </pre>
  593 
  594 <p>
  595 These examples all represent the same string:
  596 </p>
  597 
  598 <pre>
  599 "日本語"                                 // UTF-8 input text
  600 `日本語`                                 // UTF-8 input text as a raw literal
  601 "\u65e5\u672c\u8a9e"                    // the explicit Unicode code points
  602 "\U000065e5\U0000672c\U00008a9e"        // the explicit Unicode code points
  603 "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"  // the explicit UTF-8 bytes
  604 </pre>
  605 
  606 <p>
  607 If the source code represents a character as two code points, such as
  608 a combining form involving an accent and a letter, the result will be
  609 an error if placed in a rune literal (it is not a single code
  610 point), and will appear as two code points if placed in a string
  611 literal.
  612 </p>
  613 
  614 
  615 <h2 id="Constants">Constants</h2>
  616 
  617 <p>There are <i>boolean constants</i>,
  618 <i>rune constants</i>,
  619 <i>integer constants</i>,
  620 <i>floating-point constants</i>, <i>complex constants</i>,
  621 and <i>string constants</i>. Rune, integer, floating-point,
  622 and complex constants are
  623 collectively called <i>numeric constants</i>.
  624 </p>
  625 
  626 <p>
  627 A constant value is represented by a
  628 <a href="#Rune_literals">rune</a>,
  629 <a href="#Integer_literals">integer</a>,
  630 <a href="#Floating-point_literals">floating-point</a>,
  631 <a href="#Imaginary_literals">imaginary</a>,
  632 or
  633 <a href="#String_literals">string</a> literal,
  634 an identifier denoting a constant,
  635 a <a href="#Constant_expressions">constant expression</a>,
  636 a <a href="#Conversions">conversion</a> with a result that is a constant, or
  637 the result value of some built-in functions such as
  638 <code>unsafe.Sizeof</code> applied to any value,
  639 <code>cap</code> or <code>len</code> applied to
  640 <a href="#Length_and_capacity">some expressions</a>,
  641 <code>real</code> and <code>imag</code> applied to a complex constant
  642 and <code>complex</code> applied to numeric constants.
  643 The boolean truth values are represented by the predeclared constants
  644 <code>true</code> and <code>false</code>. The predeclared identifier
  645 <a href="#Iota">iota</a> denotes an integer constant.
  646 </p>
  647 
  648 <p>
  649 In general, complex constants are a form of
  650 <a href="#Constant_expressions">constant expression</a>
  651 and are discussed in that section.
  652 </p>
  653 
  654 <p>
  655 Numeric constants represent exact values of arbitrary precision and do not overflow.
  656 Consequently, there are no constants denoting the IEEE-754 negative zero, infinity,
  657 and not-a-number values.
  658 </p>
  659 
  660 <p>
  661 Constants may be <a href="#Types">typed</a> or <i>untyped</i>.
  662 Literal constants, <code>true</code>, <code>false</code>, <code>iota</code>,
  663 and certain <a href="#Constant_expressions">constant expressions</a>
  664 containing only untyped constant operands are untyped.
  665 </p>
  666 
  667 <p>
  668 A constant may be given a type explicitly by a <a href="#Constant_declarations">constant declaration</a>
  669 or <a href="#Conversions">conversion</a>, or implicitly when used in a
  670 <a href="#Variable_declarations">variable declaration</a> or an
  671 <a href="#Assignments">assignment</a> or as an
  672 operand in an <a href="#Expressions">expression</a>.
  673 It is an error if the constant value
  674 cannot be <a href="#Representability">represented</a> as a value of the respective type.
  675 </p>
  676 
  677 <p>
  678 An untyped constant has a <i>default type</i> which is the type to which the
  679 constant is implicitly converted in contexts where a typed value is required,
  680 for instance, in a <a href="#Short_variable_declarations">short variable declaration</a>
  681 such as <code>i := 0</code> where there is no explicit type.
  682 The default type of an untyped constant is <code>bool</code>, <code>rune</code>,
  683 <code>int</code>, <code>float64</code>, <code>complex128</code> or <code>string</code>
  684 respectively, depending on whether it is a boolean, rune, integer, floating-point,
  685 complex, or string constant.
  686 </p>
  687 
  688 <p>
  689 Implementation restriction: Although numeric constants have arbitrary
  690 precision in the language, a compiler may implement them using an
  691 internal representation with limited precision.  That said, every
  692 implementation must:
  693 </p>
  694 
  695 <ul>
  696     <li>Represent integer constants with at least 256 bits.</li>
  697 
  698     <li>Represent floating-point constants, including the parts of
  699         a complex constant, with a mantissa of at least 256 bits
  700         and a signed binary exponent of at least 16 bits.</li>
  701 
  702     <li>Give an error if unable to represent an integer constant
  703         precisely.</li>
  704 
  705     <li>Give an error if unable to represent a floating-point or
  706         complex constant due to overflow.</li>
  707 
  708     <li>Round to the nearest representable constant if unable to
  709         represent a floating-point or complex constant due to limits
  710         on precision.</li>
  711 </ul>
  712 
  713 <p>
  714 These requirements apply both to literal constants and to the result
  715 of evaluating <a href="#Constant_expressions">constant
  716 expressions</a>.
  717 </p>
  718 
  719 
  720 <h2 id="Variables">Variables</h2>
  721 
  722 <p>
  723 A variable is a storage location for holding a <i>value</i>.
  724 The set of permissible values is determined by the
  725 variable's <i><a href="#Types">type</a></i>.
  726 </p>
  727 
  728 <p>
  729 A <a href="#Variable_declarations">variable declaration</a>
  730 or, for function parameters and results, the signature
  731 of a <a href="#Function_declarations">function declaration</a>
  732 or <a href="#Function_literals">function literal</a> reserves
  733 storage for a named variable.
  734 
  735 Calling the built-in function <a href="#Allocation"><code>new</code></a>
  736 or taking the address of a <a href="#Composite_literals">composite literal</a>
  737 allocates storage for a variable at run time.
  738 Such an anonymous variable is referred to via a (possibly implicit)
  739 <a href="#Address_operators">pointer indirection</a>.
  740 </p>
  741 
  742 <p>
  743 <i>Structured</i> variables of <a href="#Array_types">array</a>, <a href="#Slice_types">slice</a>,
  744 and <a href="#Struct_types">struct</a> types have elements and fields that may
  745 be <a href="#Address_operators">addressed</a> individually. Each such element
  746 acts like a variable.
  747 </p>
  748 
  749 <p>
  750 The <i>static type</i> (or just <i>type</i>) of a variable is the
  751 type given in its declaration, the type provided in the
  752 <code>new</code> call or composite literal, or the type of
  753 an element of a structured variable.
  754 Variables of interface type also have a distinct <i>dynamic type</i>,
  755 which is the concrete type of the value assigned to the variable at run time
  756 (unless the value is the predeclared identifier <code>nil</code>,
  757 which has no type).
  758 The dynamic type may vary during execution but values stored in interface
  759 variables are always <a href="#Assignability">assignable</a>
  760 to the static type of the variable.
  761 </p>
  762 
  763 <pre>
  764 var x interface{}  // x is nil and has static type interface{}
  765 var v *T           // v has value nil, static type *T
  766 x = 42             // x has value 42 and dynamic type int
  767 x = v              // x has value (*T)(nil) and dynamic type *T
  768 </pre>
  769 
  770 <p>
  771 A variable's value is retrieved by referring to the variable in an
  772 <a href="#Expressions">expression</a>; it is the most recent value
  773 <a href="#Assignments">assigned</a> to the variable.
  774 If a variable has not yet been assigned a value, its value is the
  775 <a href="#The_zero_value">zero value</a> for its type.
  776 </p>
  777 
  778 
  779 <h2 id="Types">Types</h2>
  780 
  781 <p>
  782 A type determines a set of values together with operations and methods specific
  783 to those values. A type may be denoted by a <i>type name</i>, if it has one,
  784 or specified using a <i>type literal</i>, which composes a type from existing types.
  785 </p>
  786 
  787 <pre class="ebnf">
  788 Type      = TypeName | TypeLit | "(" Type ")" .
  789 TypeName  = identifier | QualifiedIdent .
  790 TypeLit   = ArrayType | StructType | PointerType | FunctionType | InterfaceType |
  791         SliceType | MapType | ChannelType .
  792 </pre>
  793 
  794 <p>
  795 The language <a href="#Predeclared_identifiers">predeclares</a> certain type names.
  796 Others are introduced with <a href="#Type_declarations">type declarations</a>.
  797 <i>Composite types</i>&mdash;array, struct, pointer, function,
  798 interface, slice, map, and channel types&mdash;may be constructed using
  799 type literals.
  800 </p>
  801 
  802 <p>
  803 Each type <code>T</code> has an <i>underlying type</i>: If <code>T</code>
  804 is one of the predeclared boolean, numeric, or string types, or a type literal,
  805 the corresponding underlying
  806 type is <code>T</code> itself. Otherwise, <code>T</code>'s underlying type
  807 is the underlying type of the type to which <code>T</code> refers in its
  808 <a href="#Type_declarations">type declaration</a>.
  809 </p>
  810 
  811 <pre>
  812 type (
  813     A1 = string
  814     A2 = A1
  815 )
  816 
  817 type (
  818     B1 string
  819     B2 B1
  820     B3 []B1
  821     B4 B3
  822 )
  823 </pre>
  824 
  825 <p>
  826 The underlying type of <code>string</code>, <code>A1</code>, <code>A2</code>, <code>B1</code>,
  827 and <code>B2</code> is <code>string</code>.
  828 The underlying type of <code>[]B1</code>, <code>B3</code>, and <code>B4</code> is <code>[]B1</code>.
  829 </p>
  830 
  831 <h3 id="Method_sets">Method sets</h3>
  832 <p>
  833 A type may have a <i>method set</i> associated with it.
  834 The method set of an <a href="#Interface_types">interface type</a> is its interface.
  835 The method set of any other type <code>T</code> consists of all
  836 <a href="#Method_declarations">methods</a> declared with receiver type <code>T</code>.
  837 The method set of the corresponding <a href="#Pointer_types">pointer type</a> <code>*T</code>
  838 is the set of all methods declared with receiver <code>*T</code> or <code>T</code>
  839 (that is, it also contains the method set of <code>T</code>).
  840 Further rules apply to structs containing embedded fields, as described
  841 in the section on <a href="#Struct_types">struct types</a>.
  842 Any other type has an empty method set.
  843 In a method set, each method must have a
  844 <a href="#Uniqueness_of_identifiers">unique</a>
  845 non-<a href="#Blank_identifier">blank</a> <a href="#MethodName">method name</a>.
  846 </p>
  847 
  848 <p>
  849 The method set of a type determines the interfaces that the
  850 type <a href="#Interface_types">implements</a>
  851 and the methods that can be <a href="#Calls">called</a>
  852 using a receiver of that type.
  853 </p>
  854 
  855 <h3 id="Boolean_types">Boolean types</h3>
  856 
  857 <p>
  858 A <i>boolean type</i> represents the set of Boolean truth values
  859 denoted by the predeclared constants <code>true</code>
  860 and <code>false</code>. The predeclared boolean type is <code>bool</code>;
  861 it is a <a href="#Type_definitions">defined type</a>.
  862 </p>
  863 
  864 <h3 id="Numeric_types">Numeric types</h3>
  865 
  866 <p>
  867 A <i>numeric type</i> represents sets of integer or floating-point values.
  868 The predeclared architecture-independent numeric types are:
  869 </p>
  870 
  871 <pre class="grammar">
  872 uint8       the set of all unsigned  8-bit integers (0 to 255)
  873 uint16      the set of all unsigned 16-bit integers (0 to 65535)
  874 uint32      the set of all unsigned 32-bit integers (0 to 4294967295)
  875 uint64      the set of all unsigned 64-bit integers (0 to 18446744073709551615)
  876 
  877 int8        the set of all signed  8-bit integers (-128 to 127)
  878 int16       the set of all signed 16-bit integers (-32768 to 32767)
  879 int32       the set of all signed 32-bit integers (-2147483648 to 2147483647)
  880 int64       the set of all signed 64-bit integers (-9223372036854775808 to 9223372036854775807)
  881 
  882 float32     the set of all IEEE-754 32-bit floating-point numbers
  883 float64     the set of all IEEE-754 64-bit floating-point numbers
  884 
  885 complex64   the set of all complex numbers with float32 real and imaginary parts
  886 complex128  the set of all complex numbers with float64 real and imaginary parts
  887 
  888 byte        alias for uint8
  889 rune        alias for int32
  890 </pre>
  891 
  892 <p>
  893 The value of an <i>n</i>-bit integer is <i>n</i> bits wide and represented using
  894 <a href="https://en.wikipedia.org/wiki/Two's_complement">two's complement arithmetic</a>.
  895 </p>
  896 
  897 <p>
  898 There is also a set of predeclared numeric types with implementation-specific sizes:
  899 </p>
  900 
  901 <pre class="grammar">
  902 uint     either 32 or 64 bits
  903 int      same size as uint
  904 uintptr  an unsigned integer large enough to store the uninterpreted bits of a pointer value
  905 </pre>
  906 
  907 <p>
  908 To avoid portability issues all numeric types are <a href="#Type_definitions">defined
  909 types</a> and thus distinct except
  910 <code>byte</code>, which is an <a href="#Alias_declarations">alias</a> for <code>uint8</code>, and
  911 <code>rune</code>, which is an alias for <code>int32</code>.
  912 Explicit conversions
  913 are required when different numeric types are mixed in an expression
  914 or assignment. For instance, <code>int32</code> and <code>int</code>
  915 are not the same type even though they may have the same size on a
  916 particular architecture.
  917 
  918 
  919 <h3 id="String_types">String types</h3>
  920 
  921 <p>
  922 A <i>string type</i> represents the set of string values.
  923 A string value is a (possibly empty) sequence of bytes.
  924 The number of bytes is called the length of the string and is never negative.
  925 Strings are immutable: once created,
  926 it is impossible to change the contents of a string.
  927 The predeclared string type is <code>string</code>;
  928 it is a <a href="#Type_definitions">defined type</a>.
  929 </p>
  930 
  931 <p>
  932 The length of a string <code>s</code> can be discovered using
  933 the built-in function <a href="#Length_and_capacity"><code>len</code></a>.
  934 The length is a compile-time constant if the string is a constant.
  935 A string's bytes can be accessed by integer <a href="#Index_expressions">indices</a>
  936 0 through <code>len(s)-1</code>.
  937 It is illegal to take the address of such an element; if
  938 <code>s[i]</code> is the <code>i</code>'th byte of a
  939 string, <code>&amp;s[i]</code> is invalid.
  940 </p>
  941 
  942 
  943 <h3 id="Array_types">Array types</h3>
  944 
  945 <p>
  946 An array is a numbered sequence of elements of a single
  947 type, called the element type.
  948 The number of elements is called the length of the array and is never negative.
  949 </p>
  950 
  951 <pre class="ebnf">
  952 ArrayType   = "[" ArrayLength "]" ElementType .
  953 ArrayLength = Expression .
  954 ElementType = Type .
  955 </pre>
  956 
  957 <p>
  958 The length is part of the array's type; it must evaluate to a
  959 non-negative <a href="#Constants">constant</a>
  960 <a href="#Representability">representable</a> by a value
  961 of type <code>int</code>.
  962 The length of array <code>a</code> can be discovered
  963 using the built-in function <a href="#Length_and_capacity"><code>len</code></a>.
  964 The elements can be addressed by integer <a href="#Index_expressions">indices</a>
  965 0 through <code>len(a)-1</code>.
  966 Array types are always one-dimensional but may be composed to form
  967 multi-dimensional types.
  968 </p>
  969 
  970 <pre>
  971 [32]byte
  972 [2*N] struct { x, y int32 }
  973 [1000]*float64
  974 [3][5]int
  975 [2][2][2]float64  // same as [2]([2]([2]float64))
  976 </pre>
  977 
  978 <h3 id="Slice_types">Slice types</h3>
  979 
  980 <p>
  981 A slice is a descriptor for a contiguous segment of an <i>underlying array</i> and
  982 provides access to a numbered sequence of elements from that array.
  983 A slice type denotes the set of all slices of arrays of its element type.
  984 The number of elements is called the length of the slice and is never negative.
  985 The value of an uninitialized slice is <code>nil</code>.
  986 </p>
  987 
  988 <pre class="ebnf">
  989 SliceType = "[" "]" ElementType .
  990 </pre>
  991 
  992 <p>
  993 The length of a slice <code>s</code> can be discovered by the built-in function
  994 <a href="#Length_and_capacity"><code>len</code></a>; unlike with arrays it may change during
  995 execution.  The elements can be addressed by integer <a href="#Index_expressions">indices</a>
  996 0 through <code>len(s)-1</code>.  The slice index of a
  997 given element may be less than the index of the same element in the
  998 underlying array.
  999 </p>
 1000 <p>
 1001 A slice, once initialized, is always associated with an underlying
 1002 array that holds its elements.  A slice therefore shares storage
 1003 with its array and with other slices of the same array; by contrast,
 1004 distinct arrays always represent distinct storage.
 1005 </p>
 1006 <p>
 1007 The array underlying a slice may extend past the end of the slice.
 1008 The <i>capacity</i> is a measure of that extent: it is the sum of
 1009 the length of the slice and the length of the array beyond the slice;
 1010 a slice of length up to that capacity can be created by
 1011 <a href="#Slice_expressions"><i>slicing</i></a> a new one from the original slice.
 1012 The capacity of a slice <code>a</code> can be discovered using the
 1013 built-in function <a href="#Length_and_capacity"><code>cap(a)</code></a>.
 1014 </p>
 1015 
 1016 <p>
 1017 A new, initialized slice value for a given element type <code>T</code> is
 1018 made using the built-in function
 1019 <a href="#Making_slices_maps_and_channels"><code>make</code></a>,
 1020 which takes a slice type
 1021 and parameters specifying the length and optionally the capacity.
 1022 A slice created with <code>make</code> always allocates a new, hidden array
 1023 to which the returned slice value refers. That is, executing
 1024 </p>
 1025 
 1026 <pre>
 1027 make([]T, length, capacity)
 1028 </pre>
 1029 
 1030 <p>
 1031 produces the same slice as allocating an array and <a href="#Slice_expressions">slicing</a>
 1032 it, so these two expressions are equivalent:
 1033 </p>
 1034 
 1035 <pre>
 1036 make([]int, 50, 100)
 1037 new([100]int)[0:50]
 1038 </pre>
 1039 
 1040 <p>
 1041 Like arrays, slices are always one-dimensional but may be composed to construct
 1042 higher-dimensional objects.
 1043 With arrays of arrays, the inner arrays are, by construction, always the same length;
 1044 however with slices of slices (or arrays of slices), the inner lengths may vary dynamically.
 1045 Moreover, the inner slices must be initialized individually.
 1046 </p>
 1047 
 1048 <h3 id="Struct_types">Struct types</h3>
 1049 
 1050 <p>
 1051 A struct is a sequence of named elements, called fields, each of which has a
 1052 name and a type. Field names may be specified explicitly (IdentifierList) or
 1053 implicitly (EmbeddedField).
 1054 Within a struct, non-<a href="#Blank_identifier">blank</a> field names must
 1055 be <a href="#Uniqueness_of_identifiers">unique</a>.
 1056 </p>
 1057 
 1058 <pre class="ebnf">
 1059 StructType    = "struct" "{" { FieldDecl ";" } "}" .
 1060 FieldDecl     = (IdentifierList Type | EmbeddedField) [ Tag ] .
 1061 EmbeddedField = [ "*" ] TypeName .
 1062 Tag           = string_lit .
 1063 </pre>
 1064 
 1065 <pre>
 1066 // An empty struct.
 1067 struct {}
 1068 
 1069 // A struct with 6 fields.
 1070 struct {
 1071     x, y int
 1072     u float32
 1073     _ float32  // padding
 1074     A *[]int
 1075     F func()
 1076 }
 1077 </pre>
 1078 
 1079 <p>
 1080 A field declared with a type but no explicit field name is called an <i>embedded field</i>.
 1081 An embedded field must be specified as
 1082 a type name <code>T</code> or as a pointer to a non-interface type name <code>*T</code>,
 1083 and <code>T</code> itself may not be
 1084 a pointer type. The unqualified type name acts as the field name.
 1085 </p>
 1086 
 1087 <pre>
 1088 // A struct with four embedded fields of types T1, *T2, P.T3 and *P.T4
 1089 struct {
 1090     T1        // field name is T1
 1091     *T2       // field name is T2
 1092     P.T3      // field name is T3
 1093     *P.T4     // field name is T4
 1094     x, y int  // field names are x and y
 1095 }
 1096 </pre>
 1097 
 1098 <p>
 1099 The following declaration is illegal because field names must be unique
 1100 in a struct type:
 1101 </p>
 1102 
 1103 <pre>
 1104 struct {
 1105     T     // conflicts with embedded field *T and *P.T
 1106     *T    // conflicts with embedded field T and *P.T
 1107     *P.T  // conflicts with embedded field T and *T
 1108 }
 1109 </pre>
 1110 
 1111 <p>
 1112 A field or <a href="#Method_declarations">method</a> <code>f</code> of an
 1113 embedded field in a struct <code>x</code> is called <i>promoted</i> if
 1114 <code>x.f</code> is a legal <a href="#Selectors">selector</a> that denotes
 1115 that field or method <code>f</code>.
 1116 </p>
 1117 
 1118 <p>
 1119 Promoted fields act like ordinary fields
 1120 of a struct except that they cannot be used as field names in
 1121 <a href="#Composite_literals">composite literals</a> of the struct.
 1122 </p>
 1123 
 1124 <p>
 1125 Given a struct type <code>S</code> and a <a href="#Type_definitions">defined type</a>
 1126 <code>T</code>, promoted methods are included in the method set of the struct as follows:
 1127 </p>
 1128 <ul>
 1129     <li>
 1130     If <code>S</code> contains an embedded field <code>T</code>,
 1131     the <a href="#Method_sets">method sets</a> of <code>S</code>
 1132     and <code>*S</code> both include promoted methods with receiver
 1133     <code>T</code>. The method set of <code>*S</code> also
 1134     includes promoted methods with receiver <code>*T</code>.
 1135     </li>
 1136 
 1137     <li>
 1138     If <code>S</code> contains an embedded field <code>*T</code>,
 1139     the method sets of <code>S</code> and <code>*S</code> both
 1140     include promoted methods with receiver <code>T</code> or
 1141     <code>*T</code>.
 1142     </li>
 1143 </ul>
 1144 
 1145 <p>
 1146 A field declaration may be followed by an optional string literal <i>tag</i>,
 1147 which becomes an attribute for all the fields in the corresponding
 1148 field declaration. An empty tag string is equivalent to an absent tag.
 1149 The tags are made visible through a <a href="/pkg/reflect/#StructTag">reflection interface</a>
 1150 and take part in <a href="#Type_identity">type identity</a> for structs
 1151 but are otherwise ignored.
 1152 </p>
 1153 
 1154 <pre>
 1155 struct {
 1156     x, y float64 ""  // an empty tag string is like an absent tag
 1157     name string  "any string is permitted as a tag"
 1158     _    [4]byte "ceci n'est pas un champ de structure"
 1159 }
 1160 
 1161 // A struct corresponding to a TimeStamp protocol buffer.
 1162 // The tag strings define the protocol buffer field numbers;
 1163 // they follow the convention outlined by the reflect package.
 1164 struct {
 1165     microsec  uint64 `protobuf:"1"`
 1166     serverIP6 uint64 `protobuf:"2"`
 1167 }
 1168 </pre>
 1169 
 1170 <h3 id="Pointer_types">Pointer types</h3>
 1171 
 1172 <p>
 1173 A pointer type denotes the set of all pointers to <a href="#Variables">variables</a> of a given
 1174 type, called the <i>base type</i> of the pointer.
 1175 The value of an uninitialized pointer is <code>nil</code>.
 1176 </p>
 1177 
 1178 <pre class="ebnf">
 1179 PointerType = "*" BaseType .
 1180 BaseType    = Type .
 1181 </pre>
 1182 
 1183 <pre>
 1184 *Point
 1185 *[4]int
 1186 </pre>
 1187 
 1188 <h3 id="Function_types">Function types</h3>
 1189 
 1190 <p>
 1191 A function type denotes the set of all functions with the same parameter
 1192 and result types. The value of an uninitialized variable of function type
 1193 is <code>nil</code>.
 1194 </p>
 1195 
 1196 <pre class="ebnf">
 1197 FunctionType   = "func" Signature .
 1198 Signature      = Parameters [ Result ] .
 1199 Result         = Parameters | Type .
 1200 Parameters     = "(" [ ParameterList [ "," ] ] ")" .
 1201 ParameterList  = ParameterDecl { "," ParameterDecl } .
 1202 ParameterDecl  = [ IdentifierList ] [ "..." ] Type .
 1203 </pre>
 1204 
 1205 <p>
 1206 Within a list of parameters or results, the names (IdentifierList)
 1207 must either all be present or all be absent. If present, each name
 1208 stands for one item (parameter or result) of the specified type and
 1209 all non-<a href="#Blank_identifier">blank</a> names in the signature
 1210 must be <a href="#Uniqueness_of_identifiers">unique</a>.
 1211 If absent, each type stands for one item of that type.
 1212 Parameter and result
 1213 lists are always parenthesized except that if there is exactly
 1214 one unnamed result it may be written as an unparenthesized type.
 1215 </p>
 1216 
 1217 <p>
 1218 The final incoming parameter in a function signature may have
 1219 a type prefixed with <code>...</code>.
 1220 A function with such a parameter is called <i>variadic</i> and
 1221 may be invoked with zero or more arguments for that parameter.
 1222 </p>
 1223 
 1224 <pre>
 1225 func()
 1226 func(x int) int
 1227 func(a, _ int, z float32) bool
 1228 func(a, b int, z float32) (bool)
 1229 func(prefix string, values ...int)
 1230 func(a, b int, z float64, opt ...interface{}) (success bool)
 1231 func(int, int, float64) (float64, *[]int)
 1232 func(n int) func(p *T)
 1233 </pre>
 1234 
 1235 
 1236 <h3 id="Interface_types">Interface types</h3>
 1237 
 1238 <p>
 1239 An interface type specifies a <a href="#Method_sets">method set</a> called its <i>interface</i>.
 1240 A variable of interface type can store a value of any type with a method set
 1241 that is any superset of the interface. Such a type is said to
 1242 <i>implement the interface</i>.
 1243 The value of an uninitialized variable of interface type is <code>nil</code>.
 1244 </p>
 1245 
 1246 <pre class="ebnf">
 1247 InterfaceType      = "interface" "{" { ( MethodSpec | InterfaceTypeName ) ";" } "}" .
 1248 MethodSpec         = MethodName Signature .
 1249 MethodName         = identifier .
 1250 InterfaceTypeName  = TypeName .
 1251 </pre>
 1252 
 1253 <p>
 1254 An interface type may specify methods <i>explicitly</i> through method specifications,
 1255 or it may <i>embed</i> methods of other interfaces through interface type names.
 1256 </p>
 1257 
 1258 <pre>
 1259 // A simple File interface.
 1260 interface {
 1261     Read([]byte) (int, error)
 1262     Write([]byte) (int, error)
 1263     Close() error
 1264 }
 1265 </pre>
 1266 
 1267 <p>
 1268 The name of each explicitly specified method must be <a href="#Uniqueness_of_identifiers">unique</a>
 1269 and not <a href="#Blank_identifier">blank</a>.
 1270 </p>
 1271 
 1272 <pre>
 1273 interface {
 1274     String() string
 1275     String() string  // illegal: String not unique
 1276     _(x int)         // illegal: method must have non-blank name
 1277 }
 1278 </pre>
 1279 
 1280 <p>
 1281 More than one type may implement an interface.
 1282 For instance, if two types <code>S1</code> and <code>S2</code>
 1283 have the method set
 1284 </p>
 1285 
 1286 <pre>
 1287 func (p T) Read(p []byte) (n int, err error)
 1288 func (p T) Write(p []byte) (n int, err error)
 1289 func (p T) Close() error
 1290 </pre>
 1291 
 1292 <p>
 1293 (where <code>T</code> stands for either <code>S1</code> or <code>S2</code>)
 1294 then the <code>File</code> interface is implemented by both <code>S1</code> and
 1295 <code>S2</code>, regardless of what other methods
 1296 <code>S1</code> and <code>S2</code> may have or share.
 1297 </p>
 1298 
 1299 <p>
 1300 A type implements any interface comprising any subset of its methods
 1301 and may therefore implement several distinct interfaces. For
 1302 instance, all types implement the <i>empty interface</i>:
 1303 </p>
 1304 
 1305 <pre>
 1306 interface{}
 1307 </pre>
 1308 
 1309 <p>
 1310 Similarly, consider this interface specification,
 1311 which appears within a <a href="#Type_declarations">type declaration</a>
 1312 to define an interface called <code>Locker</code>:
 1313 </p>
 1314 
 1315 <pre>
 1316 type Locker interface {
 1317     Lock()
 1318     Unlock()
 1319 }
 1320 </pre>
 1321 
 1322 <p>
 1323 If <code>S1</code> and <code>S2</code> also implement
 1324 </p>
 1325 
 1326 <pre>
 1327 func (p T) Lock() { … }
 1328 func (p T) Unlock() { … }
 1329 </pre>
 1330 
 1331 <p>
 1332 they implement the <code>Locker</code> interface as well
 1333 as the <code>File</code> interface.
 1334 </p>
 1335 
 1336 <p>
 1337 An interface <code>T</code> may use a (possibly qualified) interface type
 1338 name <code>E</code> in place of a method specification. This is called
 1339 <i>embedding</i> interface <code>E</code> in <code>T</code>.
 1340 The <a href="#Method_sets">method set</a> of <code>T</code> is the <i>union</i>
 1341 of the method sets of <code>T</code>’s explicitly declared methods and of
 1342 <code>T</code>’s embedded interfaces.
 1343 </p>
 1344 
 1345 <pre>
 1346 type Reader interface {
 1347     Read(p []byte) (n int, err error)
 1348     Close() error
 1349 }
 1350 
 1351 type Writer interface {
 1352     Write(p []byte) (n int, err error)
 1353     Close() error
 1354 }
 1355 
 1356 // ReadWriter's methods are Read, Write, and Close.
 1357 type ReadWriter interface {
 1358     Reader  // includes methods of Reader in ReadWriter's method set
 1359     Writer  // includes methods of Writer in ReadWriter's method set
 1360 }
 1361 </pre>
 1362 
 1363 <p>
 1364 A <i>union</i> of method sets contains the (exported and non-exported)
 1365 methods of each method set exactly once, and methods with the
 1366 <a href="#Uniqueness_of_identifiers">same</a> names must
 1367 have <a href="#Type_identity">identical</a> signatures.
 1368 </p>
 1369 
 1370 <pre>
 1371 type ReadCloser interface {
 1372     Reader   // includes methods of Reader in ReadCloser's method set
 1373     Close()  // illegal: signatures of Reader.Close and Close are different
 1374 }
 1375 </pre>
 1376 
 1377 <p>
 1378 An interface type <code>T</code> may not embed itself
 1379 or any interface type that embeds <code>T</code>, recursively.
 1380 </p>
 1381 
 1382 <pre>
 1383 // illegal: Bad cannot embed itself
 1384 type Bad interface {
 1385     Bad
 1386 }
 1387 
 1388 // illegal: Bad1 cannot embed itself using Bad2
 1389 type Bad1 interface {
 1390     Bad2
 1391 }
 1392 type Bad2 interface {
 1393     Bad1
 1394 }
 1395 </pre>
 1396 
 1397 <h3 id="Map_types">Map types</h3>
 1398 
 1399 <p>
 1400 A map is an unordered group of elements of one type, called the
 1401 element type, indexed by a set of unique <i>keys</i> of another type,
 1402 called the key type.
 1403 The value of an uninitialized map is <code>nil</code>.
 1404 </p>
 1405 
 1406 <pre class="ebnf">
 1407 MapType     = "map" "[" KeyType "]" ElementType .
 1408 KeyType     = Type .
 1409 </pre>
 1410 
 1411 <p>
 1412 The <a href="#Comparison_operators">comparison operators</a>
 1413 <code>==</code> and <code>!=</code> must be fully defined
 1414 for operands of the key type; thus the key type must not be a function, map, or
 1415 slice.
 1416 If the key type is an interface type, these
 1417 comparison operators must be defined for the dynamic key values;
 1418 failure will cause a <a href="#Run_time_panics">run-time panic</a>.
 1419 
 1420 </p>
 1421 
 1422 <pre>
 1423 map[string]int
 1424 map[*T]struct{ x, y float64 }
 1425 map[string]interface{}
 1426 </pre>
 1427 
 1428 <p>
 1429 The number of map elements is called its length.
 1430 For a map <code>m</code>, it can be discovered using the
 1431 built-in function <a href="#Length_and_capacity"><code>len</code></a>
 1432 and may change during execution. Elements may be added during execution
 1433 using <a href="#Assignments">assignments</a> and retrieved with
 1434 <a href="#Index_expressions">index expressions</a>; they may be removed with the
 1435 <a href="#Deletion_of_map_elements"><code>delete</code></a> built-in function.
 1436 </p>
 1437 <p>
 1438 A new, empty map value is made using the built-in
 1439 function <a href="#Making_slices_maps_and_channels"><code>make</code></a>,
 1440 which takes the map type and an optional capacity hint as arguments:
 1441 </p>
 1442 
 1443 <pre>
 1444 make(map[string]int)
 1445 make(map[string]int, 100)
 1446 </pre>
 1447 
 1448 <p>
 1449 The initial capacity does not bound its size:
 1450 maps grow to accommodate the number of items
 1451 stored in them, with the exception of <code>nil</code> maps.
 1452 A <code>nil</code> map is equivalent to an empty map except that no elements
 1453 may be added.
 1454 
 1455 <h3 id="Channel_types">Channel types</h3>
 1456 
 1457 <p>
 1458 A channel provides a mechanism for
 1459 <a href="#Go_statements">concurrently executing functions</a>
 1460 to communicate by
 1461 <a href="#Send_statements">sending</a> and
 1462 <a href="#Receive_operator">receiving</a>
 1463 values of a specified element type.
 1464 The value of an uninitialized channel is <code>nil</code>.
 1465 </p>
 1466 
 1467 <pre class="ebnf">
 1468 ChannelType = ( "chan" | "chan" "&lt;-" | "&lt;-" "chan" ) ElementType .
 1469 </pre>
 1470 
 1471 <p>
 1472 The optional <code>&lt;-</code> operator specifies the channel <i>direction</i>,
 1473 <i>send</i> or <i>receive</i>. If no direction is given, the channel is
 1474 <i>bidirectional</i>.
 1475 A channel may be constrained only to send or only to receive by
 1476 <a href="#Assignments">assignment</a> or
 1477 explicit <a href="#Conversions">conversion</a>.
 1478 </p>
 1479 
 1480 <pre>
 1481 chan T          // can be used to send and receive values of type T
 1482 chan&lt;- float64  // can only be used to send float64s
 1483 &lt;-chan int      // can only be used to receive ints
 1484 </pre>
 1485 
 1486 <p>
 1487 The <code>&lt;-</code> operator associates with the leftmost <code>chan</code>
 1488 possible:
 1489 </p>
 1490 
 1491 <pre>
 1492 chan&lt;- chan int    // same as chan&lt;- (chan int)
 1493 chan&lt;- &lt;-chan int  // same as chan&lt;- (&lt;-chan int)
 1494 &lt;-chan &lt;-chan int  // same as &lt;-chan (&lt;-chan int)
 1495 chan (&lt;-chan int)
 1496 </pre>
 1497 
 1498 <p>
 1499 A new, initialized channel
 1500 value can be made using the built-in function
 1501 <a href="#Making_slices_maps_and_channels"><code>make</code></a>,
 1502 which takes the channel type and an optional <i>capacity</i> as arguments:
 1503 </p>
 1504 
 1505 <pre>
 1506 make(chan int, 100)
 1507 </pre>
 1508 
 1509 <p>
 1510 The capacity, in number of elements, sets the size of the buffer in the channel.
 1511 If the capacity is zero or absent, the channel is unbuffered and communication
 1512 succeeds only when both a sender and receiver are ready. Otherwise, the channel
 1513 is buffered and communication succeeds without blocking if the buffer
 1514 is not full (sends) or not empty (receives).
 1515 A <code>nil</code> channel is never ready for communication.
 1516 </p>
 1517 
 1518 <p>
 1519 A channel may be closed with the built-in function
 1520 <a href="#Close"><code>close</code></a>.
 1521 The multi-valued assignment form of the
 1522 <a href="#Receive_operator">receive operator</a>
 1523 reports whether a received value was sent before
 1524 the channel was closed.
 1525 </p>
 1526 
 1527 <p>
 1528 A single channel may be used in
 1529 <a href="#Send_statements">send statements</a>,
 1530 <a href="#Receive_operator">receive operations</a>,
 1531 and calls to the built-in functions
 1532 <a href="#Length_and_capacity"><code>cap</code></a> and
 1533 <a href="#Length_and_capacity"><code>len</code></a>
 1534 by any number of goroutines without further synchronization.
 1535 Channels act as first-in-first-out queues.
 1536 For example, if one goroutine sends values on a channel
 1537 and a second goroutine receives them, the values are
 1538 received in the order sent.
 1539 </p>
 1540 
 1541 <h2 id="Properties_of_types_and_values">Properties of types and values</h2>
 1542 
 1543 <h3 id="Type_identity">Type identity</h3>
 1544 
 1545 <p>
 1546 Two types are either <i>identical</i> or <i>different</i>.
 1547 </p>
 1548 
 1549 <p>
 1550 A <a href="#Type_definitions">defined type</a> is always different from any other type.
 1551 Otherwise, two types are identical if their <a href="#Types">underlying</a> type literals are
 1552 structurally equivalent; that is, they have the same literal structure and corresponding
 1553 components have identical types. In detail:
 1554 </p>
 1555 
 1556 <ul>
 1557     <li>Two array types are identical if they have identical element types and
 1558         the same array length.</li>
 1559 
 1560     <li>Two slice types are identical if they have identical element types.</li>
 1561 
 1562     <li>Two struct types are identical if they have the same sequence of fields,
 1563         and if corresponding fields have the same names, and identical types,
 1564         and identical tags.
 1565         <a href="#Exported_identifiers">Non-exported</a> field names from different
 1566         packages are always different.</li>
 1567 
 1568     <li>Two pointer types are identical if they have identical base types.</li>
 1569 
 1570     <li>Two function types are identical if they have the same number of parameters
 1571         and result values, corresponding parameter and result types are
 1572         identical, and either both functions are variadic or neither is.
 1573         Parameter and result names are not required to match.</li>
 1574 
 1575     <li>Two interface types are identical if they have the same set of methods
 1576         with the same names and identical function types.
 1577         <a href="#Exported_identifiers">Non-exported</a> method names from different
 1578         packages are always different. The order of the methods is irrelevant.</li>
 1579 
 1580     <li>Two map types are identical if they have identical key and element types.</li>
 1581 
 1582     <li>Two channel types are identical if they have identical element types and
 1583         the same direction.</li>
 1584 </ul>
 1585 
 1586 <p>
 1587 Given the declarations
 1588 </p>
 1589 
 1590 <pre>
 1591 type (
 1592     A0 = []string
 1593     A1 = A0
 1594     A2 = struct{ a, b int }
 1595     A3 = int
 1596     A4 = func(A3, float64) *A0
 1597     A5 = func(x int, _ float64) *[]string
 1598 )
 1599 
 1600 type (
 1601     B0 A0
 1602     B1 []string
 1603     B2 struct{ a, b int }
 1604     B3 struct{ a, c int }
 1605     B4 func(int, float64) *B0
 1606     B5 func(x int, y float64) *A1
 1607 )
 1608 
 1609 type    C0 = B0
 1610 </pre>
 1611 
 1612 <p>
 1613 these types are identical:
 1614 </p>
 1615 
 1616 <pre>
 1617 A0, A1, and []string
 1618 A2 and struct{ a, b int }
 1619 A3 and int
 1620 A4, func(int, float64) *[]string, and A5
 1621 
 1622 B0 and C0
 1623 []int and []int
 1624 struct{ a, b *T5 } and struct{ a, b *T5 }
 1625 func(x int, y float64) *[]string, func(int, float64) (result *[]string), and A5
 1626 </pre>
 1627 
 1628 <p>
 1629 <code>B0</code> and <code>B1</code> are different because they are new types
 1630 created by distinct <a href="#Type_definitions">type definitions</a>;
 1631 <code>func(int, float64) *B0</code> and <code>func(x int, y float64) *[]string</code>
 1632 are different because <code>B0</code> is different from <code>[]string</code>.
 1633 </p>
 1634 
 1635 
 1636 <h3 id="Assignability">Assignability</h3>
 1637 
 1638 <p>
 1639 A value <code>x</code> is <i>assignable</i> to a <a href="#Variables">variable</a> of type <code>T</code>
 1640 ("<code>x</code> is assignable to <code>T</code>") if one of the following conditions applies:
 1641 </p>
 1642 
 1643 <ul>
 1644 <li>
 1645 <code>x</code>'s type is identical to <code>T</code>.
 1646 </li>
 1647 <li>
 1648 <code>x</code>'s type <code>V</code> and <code>T</code> have identical
 1649 <a href="#Types">underlying types</a> and at least one of <code>V</code>
 1650 or <code>T</code> is not a <a href="#Type_definitions">defined</a> type.
 1651 </li>
 1652 <li>
 1653 <code>T</code> is an interface type and
 1654 <code>x</code> <a href="#Interface_types">implements</a> <code>T</code>.
 1655 </li>
 1656 <li>
 1657 <code>x</code> is a bidirectional channel value, <code>T</code> is a channel type,
 1658 <code>x</code>'s type <code>V</code> and <code>T</code> have identical element types,
 1659 and at least one of <code>V</code> or <code>T</code> is not a defined type.
 1660 </li>
 1661 <li>
 1662 <code>x</code> is the predeclared identifier <code>nil</code> and <code>T</code>
 1663 is a pointer, function, slice, map, channel, or interface type.
 1664 </li>
 1665 <li>
 1666 <code>x</code> is an untyped <a href="#Constants">constant</a>
 1667 <a href="#Representability">representable</a>
 1668 by a value of type <code>T</code>.
 1669 </li>
 1670 </ul>
 1671 
 1672 
 1673 <h3 id="Representability">Representability</h3>
 1674 
 1675 <p>
 1676 A <a href="#Constants">constant</a> <code>x</code> is <i>representable</i>
 1677 by a value of type <code>T</code> if one of the following conditions applies:
 1678 </p>
 1679 
 1680 <ul>
 1681 <li>
 1682 <code>x</code> is in the set of values <a href="#Types">determined</a> by <code>T</code>.
 1683 </li>
 1684 
 1685 <li>
 1686 <code>T</code> is a floating-point type and <code>x</code> can be rounded to <code>T</code>'s
 1687 precision without overflow. Rounding uses IEEE 754 round-to-even rules but with an IEEE
 1688 negative zero further simplified to an unsigned zero. Note that constant values never result
 1689 in an IEEE negative zero, NaN, or infinity.
 1690 </li>
 1691 
 1692 <li>
 1693 <code>T</code> is a complex type, and <code>x</code>'s
 1694 <a href="#Complex_numbers">components</a> <code>real(x)</code> and <code>imag(x)</code>
 1695 are representable by values of <code>T</code>'s component type (<code>float32</code> or
 1696 <code>float64</code>).
 1697 </li>
 1698 </ul>
 1699 
 1700 <pre>
 1701 x                   T           x is representable by a value of T because
 1702 
 1703 'a'                 byte        97 is in the set of byte values
 1704 97                  rune        rune is an alias for int32, and 97 is in the set of 32-bit integers
 1705 "foo"               string      "foo" is in the set of string values
 1706 1024                int16       1024 is in the set of 16-bit integers
 1707 42.0                byte        42 is in the set of unsigned 8-bit integers
 1708 1e10                uint64      10000000000 is in the set of unsigned 64-bit integers
 1709 2.718281828459045   float32     2.718281828459045 rounds to 2.7182817 which is in the set of float32 values
 1710 -1e-1000            float64     -1e-1000 rounds to IEEE -0.0 which is further simplified to 0.0
 1711 0i                  int         0 is an integer value
 1712 (42 + 0i)           float32     42.0 (with zero imaginary part) is in the set of float32 values
 1713 </pre>
 1714 
 1715 <pre>
 1716 x                   T           x is not representable by a value of T because
 1717 
 1718 0                   bool        0 is not in the set of boolean values
 1719 'a'                 string      'a' is a rune, it is not in the set of string values
 1720 1024                byte        1024 is not in the set of unsigned 8-bit integers
 1721 -1                  uint16      -1 is not in the set of unsigned 16-bit integers
 1722 1.1                 int         1.1 is not an integer value
 1723 42i                 float32     (0 + 42i) is not in the set of float32 values
 1724 1e1000              float64     1e1000 overflows to IEEE +Inf after rounding
 1725 </pre>
 1726 
 1727 
 1728 <h2 id="Blocks">Blocks</h2>
 1729 
 1730 <p>
 1731 A <i>block</i> is a possibly empty sequence of declarations and statements
 1732 within matching brace brackets.
 1733 </p>
 1734 
 1735 <pre class="ebnf">
 1736 Block = "{" StatementList "}" .
 1737 StatementList = { Statement ";" } .
 1738 </pre>
 1739 
 1740 <p>
 1741 In addition to explicit blocks in the source code, there are implicit blocks:
 1742 </p>
 1743 
 1744 <ol>
 1745     <li>The <i>universe block</i> encompasses all Go source text.</li>
 1746 
 1747     <li>Each <a href="#Packages">package</a> has a <i>package block</i> containing all
 1748         Go source text for that package.</li>
 1749 
 1750     <li>Each file has a <i>file block</i> containing all Go source text
 1751         in that file.</li>
 1752 
 1753     <li>Each <a href="#If_statements">"if"</a>,
 1754         <a href="#For_statements">"for"</a>, and
 1755         <a href="#Switch_statements">"switch"</a>
 1756         statement is considered to be in its own implicit block.</li>
 1757 
 1758     <li>Each clause in a <a href="#Switch_statements">"switch"</a>
 1759         or <a href="#Select_statements">"select"</a> statement
 1760         acts as an implicit block.</li>
 1761 </ol>
 1762 
 1763 <p>
 1764 Blocks nest and influence <a href="#Declarations_and_scope">scoping</a>.
 1765 </p>
 1766 
 1767 
 1768 <h2 id="Declarations_and_scope">Declarations and scope</h2>
 1769 
 1770 <p>
 1771 A <i>declaration</i> binds a non-<a href="#Blank_identifier">blank</a> identifier to a
 1772 <a href="#Constant_declarations">constant</a>,
 1773 <a href="#Type_declarations">type</a>,
 1774 <a href="#Variable_declarations">variable</a>,
 1775 <a href="#Function_declarations">function</a>,
 1776 <a href="#Labeled_statements">label</a>, or
 1777 <a href="#Import_declarations">package</a>.
 1778 Every identifier in a program must be declared.
 1779 No identifier may be declared twice in the same block, and
 1780 no identifier may be declared in both the file and package block.
 1781 </p>
 1782 
 1783 <p>
 1784 The <a href="#Blank_identifier">blank identifier</a> may be used like any other identifier
 1785 in a declaration, but it does not introduce a binding and thus is not declared.
 1786 In the package block, the identifier <code>init</code> may only be used for
 1787 <a href="#Package_initialization"><code>init</code> function</a> declarations,
 1788 and like the blank identifier it does not introduce a new binding.
 1789 </p>
 1790 
 1791 <pre class="ebnf">
 1792 Declaration   = ConstDecl | TypeDecl | VarDecl .
 1793 TopLevelDecl  = Declaration | FunctionDecl | MethodDecl .
 1794 </pre>
 1795 
 1796 <p>
 1797 The <i>scope</i> of a declared identifier is the extent of source text in which
 1798 the identifier denotes the specified constant, type, variable, function, label, or package.
 1799 </p>
 1800 
 1801 <p>
 1802 Go is lexically scoped using <a href="#Blocks">blocks</a>:
 1803 </p>
 1804 
 1805 <ol>
 1806     <li>The scope of a <a href="#Predeclared_identifiers">predeclared identifier</a> is the universe block.</li>
 1807 
 1808     <li>The scope of an identifier denoting a constant, type, variable,
 1809         or function (but not method) declared at top level (outside any
 1810         function) is the package block.</li>
 1811 
 1812     <li>The scope of the package name of an imported package is the file block
 1813         of the file containing the import declaration.</li>
 1814 
 1815     <li>The scope of an identifier denoting a method receiver, function parameter,
 1816         or result variable is the function body.</li>
 1817 
 1818     <li>The scope of a constant or variable identifier declared
 1819         inside a function begins at the end of the ConstSpec or VarSpec
 1820         (ShortVarDecl for short variable declarations)
 1821         and ends at the end of the innermost containing block.</li>
 1822 
 1823     <li>The scope of a type identifier declared inside a function
 1824         begins at the identifier in the TypeSpec
 1825         and ends at the end of the innermost containing block.</li>
 1826 </ol>
 1827 
 1828 <p>
 1829 An identifier declared in a block may be redeclared in an inner block.
 1830 While the identifier of the inner declaration is in scope, it denotes
 1831 the entity declared by the inner declaration.
 1832 </p>
 1833 
 1834 <p>
 1835 The <a href="#Package_clause">package clause</a> is not a declaration; the package name
 1836 does not appear in any scope. Its purpose is to identify the files belonging
 1837 to the same <a href="#Packages">package</a> and to specify the default package name for import
 1838 declarations.
 1839 </p>
 1840 
 1841 
 1842 <h3 id="Label_scopes">Label scopes</h3>
 1843 
 1844 <p>
 1845 Labels are declared by <a href="#Labeled_statements">labeled statements</a> and are
 1846 used in the <a href="#Break_statements">"break"</a>,
 1847 <a href="#Continue_statements">"continue"</a>, and
 1848 <a href="#Goto_statements">"goto"</a> statements.
 1849 It is illegal to define a label that is never used.
 1850 In contrast to other identifiers, labels are not block scoped and do
 1851 not conflict with identifiers that are not labels. The scope of a label
 1852 is the body of the function in which it is declared and excludes
 1853 the body of any nested function.
 1854 </p>
 1855 
 1856 
 1857 <h3 id="Blank_identifier">Blank identifier</h3>
 1858 
 1859 <p>
 1860 The <i>blank identifier</i> is represented by the underscore character <code>_</code>.
 1861 It serves as an anonymous placeholder instead of a regular (non-blank)
 1862 identifier and has special meaning in <a href="#Declarations_and_scope">declarations</a>,
 1863 as an <a href="#Operands">operand</a>, and in <a href="#Assignments">assignments</a>.
 1864 </p>
 1865 
 1866 
 1867 <h3 id="Predeclared_identifiers">Predeclared identifiers</h3>
 1868 
 1869 <p>
 1870 The following identifiers are implicitly declared in the
 1871 <a href="#Blocks">universe block</a>:
 1872 </p>
 1873 <pre class="grammar">
 1874 Types:
 1875     bool byte complex64 complex128 error float32 float64
 1876     int int8 int16 int32 int64 rune string
 1877     uint uint8 uint16 uint32 uint64 uintptr
 1878 
 1879 Constants:
 1880     true false iota
 1881 
 1882 Zero value:
 1883     nil
 1884 
 1885 Functions:
 1886     append cap close complex copy delete imag len
 1887     make new panic print println real recover
 1888 </pre>
 1889 
 1890 
 1891 <h3 id="Exported_identifiers">Exported identifiers</h3>
 1892 
 1893 <p>
 1894 An identifier may be <i>exported</i> to permit access to it from another package.
 1895 An identifier is exported if both:
 1896 </p>
 1897 <ol>
 1898     <li>the first character of the identifier's name is a Unicode upper case
 1899     letter (Unicode class "Lu"); and</li>
 1900     <li>the identifier is declared in the <a href="#Blocks">package block</a>
 1901     or it is a <a href="#Struct_types">field name</a> or
 1902     <a href="#MethodName">method name</a>.</li>
 1903 </ol>
 1904 <p>
 1905 All other identifiers are not exported.
 1906 </p>
 1907 
 1908 
 1909 <h3 id="Uniqueness_of_identifiers">Uniqueness of identifiers</h3>
 1910 
 1911 <p>
 1912 Given a set of identifiers, an identifier is called <i>unique</i> if it is
 1913 <i>different</i> from every other in the set.
 1914 Two identifiers are different if they are spelled differently, or if they
 1915 appear in different <a href="#Packages">packages</a> and are not
 1916 <a href="#Exported_identifiers">exported</a>. Otherwise, they are the same.
 1917 </p>
 1918 
 1919 <h3 id="Constant_declarations">Constant declarations</h3>
 1920 
 1921 <p>
 1922 A constant declaration binds a list of identifiers (the names of
 1923 the constants) to the values of a list of <a href="#Constant_expressions">constant expressions</a>.
 1924 The number of identifiers must be equal
 1925 to the number of expressions, and the <i>n</i>th identifier on
 1926 the left is bound to the value of the <i>n</i>th expression on the
 1927 right.
 1928 </p>
 1929 
 1930 <pre class="ebnf">
 1931 ConstDecl      = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
 1932 ConstSpec      = IdentifierList [ [ Type ] "=" ExpressionList ] .
 1933 
 1934 IdentifierList = identifier { "," identifier } .
 1935 ExpressionList = Expression { "," Expression } .
 1936 </pre>
 1937 
 1938 <p>
 1939 If the type is present, all constants take the type specified, and
 1940 the expressions must be <a href="#Assignability">assignable</a> to that type.
 1941 If the type is omitted, the constants take the
 1942 individual types of the corresponding expressions.
 1943 If the expression values are untyped <a href="#Constants">constants</a>,
 1944 the declared constants remain untyped and the constant identifiers
 1945 denote the constant values. For instance, if the expression is a
 1946 floating-point literal, the constant identifier denotes a floating-point
 1947 constant, even if the literal's fractional part is zero.
 1948 </p>
 1949 
 1950 <pre>
 1951 const Pi float64 = 3.14159265358979323846
 1952 const zero = 0.0         // untyped floating-point constant
 1953 const (
 1954     size int64 = 1024
 1955     eof        = -1  // untyped integer constant
 1956 )
 1957 const a, b, c = 3, 4, "foo"  // a = 3, b = 4, c = "foo", untyped integer and string constants
 1958 const u, v float32 = 0, 3    // u = 0.0, v = 3.0
 1959 </pre>
 1960 
 1961 <p>
 1962 Within a parenthesized <code>const</code> declaration list the
 1963 expression list may be omitted from any but the first ConstSpec.
 1964 Such an empty list is equivalent to the textual substitution of the
 1965 first preceding non-empty expression list and its type if any.
 1966 Omitting the list of expressions is therefore equivalent to
 1967 repeating the previous list.  The number of identifiers must be equal
 1968 to the number of expressions in the previous list.
 1969 Together with the <a href="#Iota"><code>iota</code> constant generator</a>
 1970 this mechanism permits light-weight declaration of sequential values:
 1971 </p>
 1972 
 1973 <pre>
 1974 const (
 1975     Sunday = iota
 1976     Monday
 1977     Tuesday
 1978     Wednesday
 1979     Thursday
 1980     Friday
 1981     Partyday
 1982     numberOfDays  // this constant is not exported
 1983 )
 1984 </pre>
 1985 
 1986 
 1987 <h3 id="Iota">Iota</h3>
 1988 
 1989 <p>
 1990 Within a <a href="#Constant_declarations">constant declaration</a>, the predeclared identifier
 1991 <code>iota</code> represents successive untyped integer <a href="#Constants">
 1992 constants</a>. Its value is the index of the respective <a href="#ConstSpec">ConstSpec</a>
 1993 in that constant declaration, starting at zero.
 1994 It can be used to construct a set of related constants:
 1995 </p>
 1996 
 1997 <pre>
 1998 const (
 1999     c0 = iota  // c0 == 0
 2000     c1 = iota  // c1 == 1
 2001     c2 = iota  // c2 == 2
 2002 )
 2003 
 2004 const (
 2005     a = 1 &lt;&lt; iota  // a == 1  (iota == 0)
 2006     b = 1 &lt;&lt; iota  // b == 2  (iota == 1)
 2007     c = 3          // c == 3  (iota == 2, unused)
 2008     d = 1 &lt;&lt; iota  // d == 8  (iota == 3)
 2009 )
 2010 
 2011 const (
 2012     u         = iota * 42  // u == 0     (untyped integer constant)
 2013     v float64 = iota * 42  // v == 42.0  (float64 constant)
 2014     w         = iota * 42  // w == 84    (untyped integer constant)
 2015 )
 2016 
 2017 const x = iota  // x == 0
 2018 const y = iota  // y == 0
 2019 </pre>
 2020 
 2021 <p>
 2022 By definition, multiple uses of <code>iota</code> in the same ConstSpec all have the same value:
 2023 </p>
 2024 
 2025 <pre>
 2026 const (
 2027     bit0, mask0 = 1 &lt;&lt; iota, 1&lt;&lt;iota - 1  // bit0 == 1, mask0 == 0  (iota == 0)
 2028     bit1, mask1                           // bit1 == 2, mask1 == 1  (iota == 1)
 2029     _, _                                  //                        (iota == 2, unused)
 2030     bit3, mask3                           // bit3 == 8, mask3 == 7  (iota == 3)
 2031 )
 2032 </pre>
 2033 
 2034 <p>
 2035 This last example exploits the <a href="#Constant_declarations">implicit repetition</a>
 2036 of the last non-empty expression list.
 2037 </p>
 2038 
 2039 
 2040 <h3 id="Type_declarations">Type declarations</h3>
 2041 
 2042 <p>
 2043 A type declaration binds an identifier, the <i>type name</i>, to a <a href="#Types">type</a>.
 2044 Type declarations come in two forms: alias declarations and type definitions.
 2045 </p>
 2046 
 2047 <pre class="ebnf">
 2048 TypeDecl = "type" ( TypeSpec | "(" { TypeSpec ";" } ")" ) .
 2049 TypeSpec = AliasDecl | TypeDef .
 2050 </pre>
 2051 
 2052 <h4 id="Alias_declarations">Alias declarations</h4>
 2053 
 2054 <p>
 2055 An alias declaration binds an identifier to the given type.
 2056 </p>
 2057 
 2058 <pre class="ebnf">
 2059 AliasDecl = identifier "=" Type .
 2060 </pre>
 2061 
 2062 <p>
 2063 Within the <a href="#Declarations_and_scope">scope</a> of
 2064 the identifier, it serves as an <i>alias</i> for the type.
 2065 </p>
 2066 
 2067 <pre>
 2068 type (
 2069     nodeList = []*Node  // nodeList and []*Node are identical types
 2070     Polar    = polar    // Polar and polar denote identical types
 2071 )
 2072 </pre>
 2073 
 2074 
 2075 <h4 id="Type_definitions">Type definitions</h4>
 2076 
 2077 <p>
 2078 A type definition creates a new, distinct type with the same
 2079 <a href="#Types">underlying type</a> and operations as the given type,
 2080 and binds an identifier to it.
 2081 </p>
 2082 
 2083 <pre class="ebnf">
 2084 TypeDef = identifier Type .
 2085 </pre>
 2086 
 2087 <p>
 2088 The new type is called a <i>defined type</i>.
 2089 It is <a href="#Type_identity">different</a> from any other type,
 2090 including the type it is created from.
 2091 </p>
 2092 
 2093 <pre>
 2094 type (
 2095     Point struct{ x, y float64 }  // Point and struct{ x, y float64 } are different types
 2096     polar Point                   // polar and Point denote different types
 2097 )
 2098 
 2099 type TreeNode struct {
 2100     left, right *TreeNode
 2101     value *Comparable
 2102 }
 2103 
 2104 type Block interface {
 2105     BlockSize() int
 2106     Encrypt(src, dst []byte)
 2107     Decrypt(src, dst []byte)
 2108 }
 2109 </pre>
 2110 
 2111 <p>
 2112 A defined type may have <a href="#Method_declarations">methods</a> associated with it.
 2113 It does not inherit any methods bound to the given type,
 2114 but the <a href="#Method_sets">method set</a>
 2115 of an interface type or of elements of a composite type remains unchanged:
 2116 </p>
 2117 
 2118 <pre>
 2119 // A Mutex is a data type with two methods, Lock and Unlock.
 2120 type Mutex struct         { /* Mutex fields */ }
 2121 func (m *Mutex) Lock()    { /* Lock implementation */ }
 2122 func (m *Mutex) Unlock()  { /* Unlock implementation */ }
 2123 
 2124 // NewMutex has the same composition as Mutex but its method set is empty.
 2125 type NewMutex Mutex
 2126 
 2127 // The method set of PtrMutex's underlying type *Mutex remains unchanged,
 2128 // but the method set of PtrMutex is empty.
 2129 type PtrMutex *Mutex
 2130 
 2131 // The method set of *PrintableMutex contains the methods
 2132 // Lock and Unlock bound to its embedded field Mutex.
 2133 type PrintableMutex struct {
 2134     Mutex
 2135 }
 2136 
 2137 // MyBlock is an interface type that has the same method set as Block.
 2138 type MyBlock Block
 2139 </pre>
 2140 
 2141 <p>
 2142 Type definitions may be used to define different boolean, numeric,
 2143 or string types and associate methods with them:
 2144 </p>
 2145 
 2146 <pre>
 2147 type TimeZone int
 2148 
 2149 const (
 2150     EST TimeZone = -(5 + iota)
 2151     CST
 2152     MST
 2153     PST
 2154 )
 2155 
 2156 func (tz TimeZone) String() string {
 2157     return fmt.Sprintf("GMT%+dh", tz)
 2158 }
 2159 </pre>
 2160 
 2161 
 2162 <h3 id="Variable_declarations">Variable declarations</h3>
 2163 
 2164 <p>
 2165 A variable declaration creates one or more <a href="#Variables">variables</a>,
 2166 binds corresponding identifiers to them, and gives each a type and an initial value.
 2167 </p>
 2168 
 2169 <pre class="ebnf">
 2170 VarDecl     = "var" ( VarSpec | "(" { VarSpec ";" } ")" ) .
 2171 VarSpec     = IdentifierList ( Type [ "=" ExpressionList ] | "=" ExpressionList ) .
 2172 </pre>
 2173 
 2174 <pre>
 2175 var i int
 2176 var U, V, W float64
 2177 var k = 0
 2178 var x, y float32 = -1, -2
 2179 var (
 2180     i       int
 2181     u, v, s = 2.0, 3.0, "bar"
 2182 )
 2183 var re, im = complexSqrt(-1)
 2184 var _, found = entries[name]  // map lookup; only interested in "found"
 2185 </pre>
 2186 
 2187 <p>
 2188 If a list of expressions is given, the variables are initialized
 2189 with the expressions following the rules for <a href="#Assignments">assignments</a>.
 2190 Otherwise, each variable is initialized to its <a href="#The_zero_value">zero value</a>.
 2191 </p>
 2192 
 2193 <p>
 2194 If a type is present, each variable is given that type.
 2195 Otherwise, each variable is given the type of the corresponding
 2196 initialization value in the assignment.
 2197 If that value is an untyped constant, it is first implicitly
 2198 <a href="#Conversions">converted</a> to its <a href="#Constants">default type</a>;
 2199 if it is an untyped boolean value, it is first implicitly converted to type <code>bool</code>.
 2200 The predeclared value <code>nil</code> cannot be used to initialize a variable
 2201 with no explicit type.
 2202 </p>
 2203 
 2204 <pre>
 2205 var d = math.Sin(0.5)  // d is float64
 2206 var i = 42             // i is int
 2207 var t, ok = x.(T)      // t is T, ok is bool
 2208 var n = nil            // illegal
 2209 </pre>
 2210 
 2211 <p>
 2212 Implementation restriction: A compiler may make it illegal to declare a variable
 2213 inside a <a href="#Function_declarations">function body</a> if the variable is
 2214 never used.
 2215 </p>
 2216 
 2217 <h3 id="Short_variable_declarations">Short variable declarations</h3>
 2218 
 2219 <p>
 2220 A <i>short variable declaration</i> uses the syntax:
 2221 </p>
 2222 
 2223 <pre class="ebnf">
 2224 ShortVarDecl = IdentifierList ":=" ExpressionList .
 2225 </pre>
 2226 
 2227 <p>
 2228 It is shorthand for a regular <a href="#Variable_declarations">variable declaration</a>
 2229 with initializer expressions but no types:
 2230 </p>
 2231 
 2232 <pre class="grammar">
 2233 "var" IdentifierList = ExpressionList .
 2234 </pre>
 2235 
 2236 <pre>
 2237 i, j := 0, 10
 2238 f := func() int { return 7 }
 2239 ch := make(chan int)
 2240 r, w, _ := os.Pipe()  // os.Pipe() returns a connected pair of Files and an error, if any
 2241 _, y, _ := coord(p)   // coord() returns three values; only interested in y coordinate
 2242 </pre>
 2243 
 2244 <p>
 2245 Unlike regular variable declarations, a short variable declaration may <i>redeclare</i>
 2246 variables provided they were originally declared earlier in the same block
 2247 (or the parameter lists if the block is the function body) with the same type,
 2248 and at least one of the non-<a href="#Blank_identifier">blank</a> variables is new.
 2249 As a consequence, redeclaration can only appear in a multi-variable short declaration.
 2250 Redeclaration does not introduce a new variable; it just assigns a new value to the original.
 2251 </p>
 2252 
 2253 <pre>
 2254 field1, offset := nextField(str, 0)
 2255 field2, offset := nextField(str, offset)  // redeclares offset
 2256 a, a := 1, 2                              // illegal: double declaration of a or no new variable if a was declared elsewhere
 2257 </pre>
 2258 
 2259 <p>
 2260 Short variable declarations may appear only inside functions.
 2261 In some contexts such as the initializers for
 2262 <a href="#If_statements">"if"</a>,
 2263 <a href="#For_statements">"for"</a>, or
 2264 <a href="#Switch_statements">"switch"</a> statements,
 2265 they can be used to declare local temporary variables.
 2266 </p>
 2267 
 2268 <h3 id="Function_declarations">Function declarations</h3>
 2269 
 2270 <p>
 2271 A function declaration binds an identifier, the <i>function name</i>,
 2272 to a function.
 2273 </p>
 2274 
 2275 <pre class="ebnf">
 2276 FunctionDecl = "func" FunctionName Signature [ FunctionBody ] .
 2277 FunctionName = identifier .
 2278 FunctionBody = Block .
 2279 </pre>
 2280 
 2281 <p>
 2282 If the function's <a href="#Function_types">signature</a> declares
 2283 result parameters, the function body's statement list must end in
 2284 a <a href="#Terminating_statements">terminating statement</a>.
 2285 </p>
 2286 
 2287 <pre>
 2288 func IndexRune(s string, r rune) int {
 2289     for i, c := range s {
 2290         if c == r {
 2291             return i
 2292         }
 2293     }
 2294     // invalid: missing return statement
 2295 }
 2296 </pre>
 2297 
 2298 <p>
 2299 A function declaration may omit the body. Such a declaration provides the
 2300 signature for a function implemented outside Go, such as an assembly routine.
 2301 </p>
 2302 
 2303 <pre>
 2304 func min(x int, y int) int {
 2305     if x &lt; y {
 2306         return x
 2307     }
 2308     return y
 2309 }
 2310 
 2311 func flushICache(begin, end uintptr)  // implemented externally
 2312 </pre>
 2313 
 2314 <h3 id="Method_declarations">Method declarations</h3>
 2315 
 2316 <p>
 2317 A method is a <a href="#Function_declarations">function</a> with a <i>receiver</i>.
 2318 A method declaration binds an identifier, the <i>method name</i>, to a method,
 2319 and associates the method with the receiver's <i>base type</i>.
 2320 </p>
 2321 
 2322 <pre class="ebnf">
 2323 MethodDecl = "func" Receiver MethodName Signature [ FunctionBody ] .
 2324 Receiver   = Parameters .
 2325 </pre>
 2326 
 2327 <p>
 2328 The receiver is specified via an extra parameter section preceding the method
 2329 name. That parameter section must declare a single non-variadic parameter, the receiver.
 2330 Its type must be a <a href="#Type_definitions">defined</a> type <code>T</code> or a
 2331 pointer to a defined type <code>T</code>. <code>T</code> is called the receiver
 2332 <i>base type</i>. A receiver base type cannot be a pointer or interface type and
 2333 it must be defined in the same package as the method.
 2334 The method is said to be <i>bound</i> to its receiver base type and the method name
 2335 is visible only within <a href="#Selectors">selectors</a> for type <code>T</code>
 2336 or <code>*T</code>.
 2337 </p>
 2338 
 2339 <p>
 2340 A non-<a href="#Blank_identifier">blank</a> receiver identifier must be
 2341 <a href="#Uniqueness_of_identifiers">unique</a> in the method signature.
 2342 If the receiver's value is not referenced inside the body of the method,
 2343 its identifier may be omitted in the declaration. The same applies in
 2344 general to parameters of functions and methods.
 2345 </p>
 2346 
 2347 <p>
 2348 For a base type, the non-blank names of methods bound to it must be unique.
 2349 If the base type is a <a href="#Struct_types">struct type</a>,
 2350 the non-blank method and field names must be distinct.
 2351 </p>
 2352 
 2353 <p>
 2354 Given defined type <code>Point</code>, the declarations
 2355 </p>
 2356 
 2357 <pre>
 2358 func (p *Point) Length() float64 {
 2359     return math.Sqrt(p.x * p.x + p.y * p.y)
 2360 }
 2361 
 2362 func (p *Point) Scale(factor float64) {
 2363     p.x *= factor
 2364     p.y *= factor
 2365 }
 2366 </pre>
 2367 
 2368 <p>
 2369 bind the methods <code>Length</code> and <code>Scale</code>,
 2370 with receiver type <code>*Point</code>,
 2371 to the base type <code>Point</code>.
 2372 </p>
 2373 
 2374 <p>
 2375 The type of a method is the type of a function with the receiver as first
 2376 argument.  For instance, the method <code>Scale</code> has type
 2377 </p>
 2378 
 2379 <pre>
 2380 func(p *Point, factor float64)
 2381 </pre>
 2382 
 2383 <p>
 2384 However, a function declared this way is not a method.
 2385 </p>
 2386 
 2387 
 2388 <h2 id="Expressions">Expressions</h2>
 2389 
 2390 <p>
 2391 An expression specifies the computation of a value by applying
 2392 operators and functions to operands.
 2393 </p>
 2394 
 2395 <h3 id="Operands">Operands</h3>
 2396 
 2397 <p>
 2398 Operands denote the elementary values in an expression. An operand may be a
 2399 literal, a (possibly <a href="#Qualified_identifiers">qualified</a>)
 2400 non-<a href="#Blank_identifier">blank</a> identifier denoting a
 2401 <a href="#Constant_declarations">constant</a>,
 2402 <a href="#Variable_declarations">variable</a>, or
 2403 <a href="#Function_declarations">function</a>,
 2404 or a parenthesized expression.
 2405 </p>
 2406 
 2407 <p>
 2408 The <a href="#Blank_identifier">blank identifier</a> may appear as an
 2409 operand only on the left-hand side of an <a href="#Assignments">assignment</a>.
 2410 </p>
 2411 
 2412 <pre class="ebnf">
 2413 Operand     = Literal | OperandName | "(" Expression ")" .
 2414 Literal     = BasicLit | CompositeLit | FunctionLit .
 2415 BasicLit    = int_lit | float_lit | imaginary_lit | rune_lit | string_lit .
 2416 OperandName = identifier | QualifiedIdent .
 2417 </pre>
 2418 
 2419 <h3 id="Qualified_identifiers">Qualified identifiers</h3>
 2420 
 2421 <p>
 2422 A qualified identifier is an identifier qualified with a package name prefix.
 2423 Both the package name and the identifier must not be
 2424 <a href="#Blank_identifier">blank</a>.
 2425 </p>
 2426 
 2427 <pre class="ebnf">
 2428 QualifiedIdent = PackageName "." identifier .
 2429 </pre>
 2430 
 2431 <p>
 2432 A qualified identifier accesses an identifier in a different package, which
 2433 must be <a href="#Import_declarations">imported</a>.
 2434 The identifier must be <a href="#Exported_identifiers">exported</a> and
 2435 declared in the <a href="#Blocks">package block</a> of that package.
 2436 </p>
 2437 
 2438 <pre>
 2439 math.Sin    // denotes the Sin function in package math
 2440 </pre>
 2441 
 2442 <h3 id="Composite_literals">Composite literals</h3>
 2443 
 2444 <p>
 2445 Composite literals construct values for structs, arrays, slices, and maps
 2446 and create a new value each time they are evaluated.
 2447 They consist of the type of the literal followed by a brace-bound list of elements.
 2448 Each element may optionally be preceded by a corresponding key.
 2449 </p>
 2450 
 2451 <pre class="ebnf">
 2452 CompositeLit  = LiteralType LiteralValue .
 2453 LiteralType   = StructType | ArrayType | "[" "..." "]" ElementType |
 2454                 SliceType | MapType | TypeName .
 2455 LiteralValue  = "{" [ ElementList [ "," ] ] "}" .
 2456 ElementList   = KeyedElement { "," KeyedElement } .
 2457 KeyedElement  = [ Key ":" ] Element .
 2458 Key           = FieldName | Expression | LiteralValue .
 2459 FieldName     = identifier .
 2460 Element       = Expression | LiteralValue .
 2461 </pre>
 2462 
 2463 <p>
 2464 The LiteralType's underlying type must be a struct, array, slice, or map type
 2465 (the grammar enforces this constraint except when the type is given
 2466 as a TypeName).
 2467 The types of the elements and keys must be <a href="#Assignability">assignable</a>
 2468 to the respective field, element, and key types of the literal type;
 2469 there is no additional conversion.
 2470 The key is interpreted as a field name for struct literals,
 2471 an index for array and slice literals, and a key for map literals.
 2472 For map literals, all elements must have a key. It is an error
 2473 to specify multiple elements with the same field name or
 2474 constant key value. For non-constant map keys, see the section on
 2475 <a href="#Order_of_evaluation">evaluation order</a>.
 2476 </p>
 2477 
 2478 <p>
 2479 For struct literals the following rules apply:
 2480 </p>
 2481 <ul>
 2482     <li>A key must be a field name declared in the struct type.
 2483     </li>
 2484     <li>An element list that does not contain any keys must
 2485         list an element for each struct field in the
 2486         order in which the fields are declared.
 2487     </li>
 2488     <li>If any element has a key, every element must have a key.
 2489     </li>
 2490     <li>An element list that contains keys does not need to
 2491         have an element for each struct field. Omitted fields
 2492         get the zero value for that field.
 2493     </li>
 2494     <li>A literal may omit the element list; such a literal evaluates
 2495         to the zero value for its type.
 2496     </li>
 2497     <li>It is an error to specify an element for a non-exported
 2498         field of a struct belonging to a different package.
 2499     </li>
 2500 </ul>
 2501 
 2502 <p>
 2503 Given the declarations
 2504 </p>
 2505 <pre>
 2506 type Point3D struct { x, y, z float64 }
 2507 type Line struct { p, q Point3D }
 2508 </pre>
 2509 
 2510 <p>
 2511 one may write
 2512 </p>
 2513 
 2514 <pre>
 2515 origin := Point3D{}                            // zero value for Point3D
 2516 line := Line{origin, Point3D{y: -4, z: 12.3}}  // zero value for line.q.x
 2517 </pre>
 2518 
 2519 <p>
 2520 For array and slice literals the following rules apply:
 2521 </p>
 2522 <ul>
 2523     <li>Each element has an associated integer index marking
 2524         its position in the array.
 2525     </li>
 2526     <li>An element with a key uses the key as its index. The
 2527         key must be a non-negative constant
 2528         <a href="#Representability">representable</a> by
 2529         a value of type <code>int</code>; and if it is typed
 2530         it must be of integer type.
 2531     </li>
 2532     <li>An element without a key uses the previous element's index plus one.
 2533         If the first element has no key, its index is zero.
 2534     </li>
 2535 </ul>
 2536 
 2537 <p>
 2538 <a href="#Address_operators">Taking the address</a> of a composite literal
 2539 generates a pointer to a unique <a href="#Variables">variable</a> initialized
 2540 with the literal's value.
 2541 </p>
 2542 
 2543 <pre>
 2544 var pointer *Point3D = &amp;Point3D{y: 1000}
 2545 </pre>
 2546 
 2547 <p>
 2548 Note that the <a href="#The_zero_value">zero value</a> for a slice or map
 2549 type is not the same as an initialized but empty value of the same type.
 2550 Consequently, taking the address of an empty slice or map composite literal
 2551 does not have the same effect as allocating a new slice or map value with
 2552 <a href="#Allocation">new</a>.
 2553 </p>
 2554 
 2555 <pre>
 2556 p1 := &amp;[]int{}    // p1 points to an initialized, empty slice with value []int{} and length 0
 2557 p2 := new([]int)  // p2 points to an uninitialized slice with value nil and length 0
 2558 </pre>
 2559 
 2560 <p>
 2561 The length of an array literal is the length specified in the literal type.
 2562 If fewer elements than the length are provided in the literal, the missing
 2563 elements are set to the zero value for the array element type.
 2564 It is an error to provide elements with index values outside the index range
 2565 of the array. The notation <code>...</code> specifies an array length equal
 2566 to the maximum element index plus one.
 2567 </p>
 2568 
 2569 <pre>
 2570 buffer := [10]string{}             // len(buffer) == 10
 2571 intSet := [6]int{1, 2, 3, 5}       // len(intSet) == 6
 2572 days := [...]string{"Sat", "Sun"}  // len(days) == 2
 2573 </pre>
 2574 
 2575 <p>
 2576 A slice literal describes the entire underlying array literal.
 2577 Thus the length and capacity of a slice literal are the maximum
 2578 element index plus one. A slice literal has the form
 2579 </p>
 2580 
 2581 <pre>
 2582 []T{x1, x2, … xn}
 2583 </pre>
 2584 
 2585 <p>
 2586 and is shorthand for a slice operation applied to an array:
 2587 </p>
 2588 
 2589 <pre>
 2590 tmp := [n]T{x1, x2, … xn}
 2591 tmp[0 : n]
 2592 </pre>
 2593 
 2594 <p>
 2595 Within a composite literal of array, slice, or map type <code>T</code>,
 2596 elements or map keys that are themselves composite literals may elide the respective
 2597 literal type if it is identical to the element or key type of <code>T</code>.
 2598 Similarly, elements or keys that are addresses of composite literals may elide
 2599 the <code>&amp;T</code> when the element or key type is <code>*T</code>.
 2600 </p>
 2601 
 2602 <pre>
 2603 [...]Point{{1.5, -3.5}, {0, 0}}     // same as [...]Point{Point{1.5, -3.5}, Point{0, 0}}
 2604 [][]int{{1, 2, 3}, {4, 5}}          // same as [][]int{[]int{1, 2, 3}, []int{4, 5}}
 2605 [][]Point{{{0, 1}, {1, 2}}}         // same as [][]Point{[]Point{Point{0, 1}, Point{1, 2}}}
 2606 map[string]Point{"orig": {0, 0}}    // same as map[string]Point{"orig": Point{0, 0}}
 2607 map[Point]string{{0, 0}: "orig"}    // same as map[Point]string{Point{0, 0}: "orig"}
 2608 
 2609 type PPoint *Point
 2610 [2]*Point{{1.5, -3.5}, {}}          // same as [2]*Point{&amp;Point{1.5, -3.5}, &amp;Point{}}
 2611 [2]PPoint{{1.5, -3.5}, {}}          // same as [2]PPoint{PPoint(&amp;Point{1.5, -3.5}), PPoint(&amp;Point{})}
 2612 </pre>
 2613 
 2614 <p>
 2615 A parsing ambiguity arises when a composite literal using the
 2616 TypeName form of the LiteralType appears as an operand between the
 2617 <a href="#Keywords">keyword</a> and the opening brace of the block
 2618 of an "if", "for", or "switch" statement, and the composite literal
 2619 is not enclosed in parentheses, square brackets, or curly braces.
 2620 In this rare case, the opening brace of the literal is erroneously parsed
 2621 as the one introducing the block of statements. To resolve the ambiguity,
 2622 the composite literal must appear within parentheses.
 2623 </p>
 2624 
 2625 <pre>
 2626 if x == (T{a,b,c}[i]) { … }
 2627 if (x == T{a,b,c}[i]) { … }
 2628 </pre>
 2629 
 2630 <p>
 2631 Examples of valid array, slice, and map literals:
 2632 </p>
 2633 
 2634 <pre>
 2635 // list of prime numbers
 2636 primes := []int{2, 3, 5, 7, 9, 2147483647}
 2637 
 2638 // vowels[ch] is true if ch is a vowel
 2639 vowels := [128]bool{'a': true, 'e': true, 'i': true, 'o': true, 'u': true, 'y': true}
 2640 
 2641 // the array [10]float32{-1, 0, 0, 0, -0.1, -0.1, 0, 0, 0, -1}
 2642 filter := [10]float32{-1, 4: -0.1, -0.1, 9: -1}
 2643 
 2644 // frequencies in Hz for equal-tempered scale (A4 = 440Hz)
 2645 noteFrequency := map[string]float32{
 2646     "C0": 16.35, "D0": 18.35, "E0": 20.60, "F0": 21.83,
 2647     "G0": 24.50, "A0": 27.50, "B0": 30.87,
 2648 }
 2649 </pre>
 2650 
 2651 
 2652 <h3 id="Function_literals">Function literals</h3>
 2653 
 2654 <p>
 2655 A function literal represents an anonymous <a href="#Function_declarations">function</a>.
 2656 </p>
 2657 
 2658 <pre class="ebnf">
 2659 FunctionLit = "func" Signature FunctionBody .
 2660 </pre>
 2661 
 2662 <pre>
 2663 func(a, b int, z float64) bool { return a*b &lt; int(z) }
 2664 </pre>
 2665 
 2666 <p>
 2667 A function literal can be assigned to a variable or invoked directly.
 2668 </p>
 2669 
 2670 <pre>
 2671 f := func(x, y int) int { return x + y }
 2672 func(ch chan int) { ch &lt;- ACK }(replyChan)
 2673 </pre>
 2674 
 2675 <p>
 2676 Function literals are <i>closures</i>: they may refer to variables
 2677 defined in a surrounding function. Those variables are then shared between
 2678 the surrounding function and the function literal, and they survive as long
 2679 as they are accessible.
 2680 </p>
 2681 
 2682 
 2683 <h3 id="Primary_expressions">Primary expressions</h3>
 2684 
 2685 <p>
 2686 Primary expressions are the operands for unary and binary expressions.
 2687 </p>
 2688 
 2689 <pre class="ebnf">
 2690 PrimaryExpr =
 2691     Operand |
 2692     Conversion |
 2693     MethodExpr |
 2694     PrimaryExpr Selector |
 2695     PrimaryExpr Index |
 2696     PrimaryExpr Slice |
 2697     PrimaryExpr TypeAssertion |
 2698     PrimaryExpr Arguments .
 2699 
 2700 Selector       = "." identifier .
 2701 Index          = "[" Expression "]" .
 2702 Slice          = "[" [ Expression ] ":" [ Expression ] "]" |
 2703                  "[" [ Expression ] ":" Expression ":" Expression "]" .
 2704 TypeAssertion  = "." "(" Type ")" .
 2705 Arguments      = "(" [ ( ExpressionList | Type [ "," ExpressionList ] ) [ "..." ] [ "," ] ] ")" .
 2706 </pre>
 2707 
 2708 
 2709 <pre>
 2710 x
 2711 2
 2712 (s + ".txt")
 2713 f(3.1415, true)
 2714 Point{1, 2}
 2715 m["foo"]
 2716 s[i : j + 1]
 2717 obj.color
 2718 f.p[i].x()
 2719 </pre>
 2720 
 2721 
 2722 <h3 id="Selectors">Selectors</h3>
 2723 
 2724 <p>
 2725 For a <a href="#Primary_expressions">primary expression</a> <code>x</code>
 2726 that is not a <a href="#Package_clause">package name</a>, the
 2727 <i>selector expression</i>
 2728 </p>
 2729 
 2730 <pre>
 2731 x.f
 2732 </pre>
 2733 
 2734 <p>
 2735 denotes the field or method <code>f</code> of the value <code>x</code>
 2736 (or sometimes <code>*x</code>; see below).
 2737 The identifier <code>f</code> is called the (field or method) <i>selector</i>;
 2738 it must not be the <a href="#Blank_identifier">blank identifier</a>.
 2739 The type of the selector expression is the type of <code>f</code>.
 2740 If <code>x</code> is a package name, see the section on
 2741 <a href="#Qualified_identifiers">qualified identifiers</a>.
 2742 </p>
 2743 
 2744 <p>
 2745 A selector <code>f</code> may denote a field or method <code>f</code> of
 2746 a type <code>T</code>, or it may refer
 2747 to a field or method <code>f</code> of a nested
 2748 <a href="#Struct_types">embedded field</a> of <code>T</code>.
 2749 The number of embedded fields traversed
 2750 to reach <code>f</code> is called its <i>depth</i> in <code>T</code>.
 2751 The depth of a field or method <code>f</code>
 2752 declared in <code>T</code> is zero.
 2753 The depth of a field or method <code>f</code> declared in
 2754 an embedded field <code>A</code> in <code>T</code> is the
 2755 depth of <code>f</code> in <code>A</code> plus one.
 2756 </p>
 2757 
 2758 <p>
 2759 The following rules apply to selectors:
 2760 </p>
 2761 
 2762 <ol>
 2763 <li>
 2764 For a value <code>x</code> of type <code>T</code> or <code>*T</code>
 2765 where <code>T</code> is not a pointer or interface type,
 2766 <code>x.f</code> denotes the field or method at the shallowest depth
 2767 in <code>T</code> where there
 2768 is such an <code>f</code>.
 2769 If there is not exactly <a href="#Uniqueness_of_identifiers">one <code>f</code></a>
 2770 with shallowest depth, the selector expression is illegal.
 2771 </li>
 2772 
 2773 <li>
 2774 For a value <code>x</code> of type <code>I</code> where <code>I</code>
 2775 is an interface type, <code>x.f</code> denotes the actual method with name
 2776 <code>f</code> of the dynamic value of <code>x</code>.
 2777 If there is no method with name <code>f</code> in the
 2778 <a href="#Method_sets">method set</a> of <code>I</code>, the selector
 2779 expression is illegal.
 2780 </li>
 2781 
 2782 <li>
 2783 As an exception, if the type of <code>x</code> is a <a href="#Type_definitions">defined</a>
 2784 pointer type and <code>(*x).f</code> is a valid selector expression denoting a field
 2785 (but not a method), <code>x.f</code> is shorthand for <code>(*x).f</code>.
 2786 </li>
 2787 
 2788 <li>
 2789 In all other cases, <code>x.f</code> is illegal.
 2790 </li>
 2791 
 2792 <li>
 2793 If <code>x</code> is of pointer type and has the value
 2794 <code>nil</code> and <code>x.f</code> denotes a struct field,
 2795 assigning to or evaluating <code>x.f</code>
 2796 causes a <a href="#Run_time_panics">run-time panic</a>.
 2797 </li>
 2798 
 2799 <li>
 2800 If <code>x</code> is of interface type and has the value
 2801 <code>nil</code>, <a href="#Calls">calling</a> or
 2802 <a href="#Method_values">evaluating</a> the method <code>x.f</code>
 2803 causes a <a href="#Run_time_panics">run-time panic</a>.
 2804 </li>
 2805 </ol>
 2806 
 2807 <p>
 2808 For example, given the declarations:
 2809 </p>
 2810 
 2811 <pre>
 2812 type T0 struct {
 2813     x int
 2814 }
 2815 
 2816 func (*T0) M0()
 2817 
 2818 type T1 struct {
 2819     y int
 2820 }
 2821 
 2822 func (T1) M1()
 2823 
 2824 type T2 struct {
 2825     z int
 2826     T1
 2827     *T0
 2828 }
 2829 
 2830 func (*T2) M2()
 2831 
 2832 type Q *T2
 2833 
 2834 var t T2     // with t.T0 != nil
 2835 var p *T2    // with p != nil and (*p).T0 != nil
 2836 var q Q = p
 2837 </pre>
 2838 
 2839 <p>
 2840 one may write:
 2841 </p>
 2842 
 2843 <pre>
 2844 t.z          // t.z
 2845 t.y          // t.T1.y
 2846 t.x          // (*t.T0).x
 2847 
 2848 p.z          // (*p).z
 2849 p.y          // (*p).T1.y
 2850 p.x          // (*(*p).T0).x
 2851 
 2852 q.x          // (*(*q).T0).x        (*q).x is a valid field selector
 2853 
 2854 p.M0()       // ((*p).T0).M0()      M0 expects *T0 receiver
 2855 p.M1()       // ((*p).T1).M1()      M1 expects T1 receiver
 2856 p.M2()       // p.M2()              M2 expects *T2 receiver
 2857 t.M2()       // (&amp;t).M2()           M2 expects *T2 receiver, see section on Calls
 2858 </pre>
 2859 
 2860 <p>
 2861 but the following is invalid:
 2862 </p>
 2863 
 2864 <pre>
 2865 q.M0()       // (*q).M0 is valid but not a field selector
 2866 </pre>
 2867 
 2868 
 2869 <h3 id="Method_expressions">Method expressions</h3>
 2870 
 2871 <p>
 2872 If <code>M</code> is in the <a href="#Method_sets">method set</a> of type <code>T</code>,
 2873 <code>T.M</code> is a function that is callable as a regular function
 2874 with the same arguments as <code>M</code> prefixed by an additional
 2875 argument that is the receiver of the method.
 2876 </p>
 2877 
 2878 <pre class="ebnf">
 2879 MethodExpr    = ReceiverType "." MethodName .
 2880 ReceiverType  = Type .
 2881 </pre>
 2882 
 2883 <p>
 2884 Consider a struct type <code>T</code> with two methods,
 2885 <code>Mv</code>, whose receiver is of type <code>T</code>, and
 2886 <code>Mp</code>, whose receiver is of type <code>*T</code>.
 2887 </p>
 2888 
 2889 <pre>
 2890 type T struct {
 2891     a int
 2892 }
 2893 func (tv  T) Mv(a int) int         { return 0 }  // value receiver
 2894 func (tp *T) Mp(f float32) float32 { return 1 }  // pointer receiver
 2895 
 2896 var t T
 2897 </pre>
 2898 
 2899 <p>
 2900 The expression
 2901 </p>
 2902 
 2903 <pre>
 2904 T.Mv
 2905 </pre>
 2906 
 2907 <p>
 2908 yields a function equivalent to <code>Mv</code> but
 2909 with an explicit receiver as its first argument; it has signature
 2910 </p>
 2911 
 2912 <pre>
 2913 func(tv T, a int) int
 2914 </pre>
 2915 
 2916 <p>
 2917 That function may be called normally with an explicit receiver, so
 2918 these five invocations are equivalent:
 2919 </p>
 2920 
 2921 <pre>
 2922 t.Mv(7)
 2923 T.Mv(t, 7)
 2924 (T).Mv(t, 7)
 2925 f1 := T.Mv; f1(t, 7)
 2926 f2 := (T).Mv; f2(t, 7)
 2927 </pre>
 2928 
 2929 <p>
 2930 Similarly, the expression
 2931 </p>
 2932 
 2933 <pre>
 2934 (*T).Mp
 2935 </pre>
 2936 
 2937 <p>
 2938 yields a function value representing <code>Mp</code> with signature
 2939 </p>
 2940 
 2941 <pre>
 2942 func(tp *T, f float32) float32
 2943 </pre>
 2944 
 2945 <p>
 2946 For a method with a value receiver, one can derive a function
 2947 with an explicit pointer receiver, so
 2948 </p>
 2949 
 2950 <pre>
 2951 (*T).Mv
 2952 </pre>
 2953 
 2954 <p>
 2955 yields a function value representing <code>Mv</code> with signature
 2956 </p>
 2957 
 2958 <pre>
 2959 func(tv *T, a int) int
 2960 </pre>
 2961 
 2962 <p>
 2963 Such a function indirects through the receiver to create a value
 2964 to pass as the receiver to the underlying method;
 2965 the method does not overwrite the value whose address is passed in
 2966 the function call.
 2967 </p>
 2968 
 2969 <p>
 2970 The final case, a value-receiver function for a pointer-receiver method,
 2971 is illegal because pointer-receiver methods are not in the method set
 2972 of the value type.
 2973 </p>
 2974 
 2975 <p>
 2976 Function values derived from methods are called with function call syntax;
 2977 the receiver is provided as the first argument to the call.
 2978 That is, given <code>f := T.Mv</code>, <code>f</code> is invoked
 2979 as <code>f(t, 7)</code> not <code>t.f(7)</code>.
 2980 To construct a function that binds the receiver, use a
 2981 <a href="#Function_literals">function literal</a> or
 2982 <a href="#Method_values">method value</a>.
 2983 </p>
 2984 
 2985 <p>
 2986 It is legal to derive a function value from a method of an interface type.
 2987 The resulting function takes an explicit receiver of that interface type.
 2988 </p>
 2989 
 2990 <h3 id="Method_values">Method values</h3>
 2991 
 2992 <p>
 2993 If the expression <code>x</code> has static type <code>T</code> and
 2994 <code>M</code> is in the <a href="#Method_sets">method set</a> of type <code>T</code>,
 2995 <code>x.M</code> is called a <i>method value</i>.
 2996 The method value <code>x.M</code> is a function value that is callable
 2997 with the same arguments as a method call of <code>x.M</code>.
 2998 The expression <code>x</code> is evaluated and saved during the evaluation of the
 2999 method value; the saved copy is then used as the receiver in any calls,
 3000 which may be executed later.
 3001 </p>
 3002 
 3003 <p>
 3004 The type <code>T</code> may be an interface or non-interface type.
 3005 </p>
 3006 
 3007 <p>
 3008 As in the discussion of <a href="#Method_expressions">method expressions</a> above,
 3009 consider a struct type <code>T</code> with two methods,
 3010 <code>Mv</code>, whose receiver is of type <code>T</code>, and
 3011 <code>Mp</code>, whose receiver is of type <code>*T</code>.
 3012 </p>
 3013 
 3014 <pre>
 3015 type T struct {
 3016     a int
 3017 }
 3018 func (tv  T) Mv(a int) int         { return 0 }  // value receiver
 3019 func (tp *T) Mp(f float32) float32 { return 1 }  // pointer receiver
 3020 
 3021 var t T
 3022 var pt *T
 3023 func makeT() T
 3024 </pre>
 3025 
 3026 <p>
 3027 The expression
 3028 </p>
 3029 
 3030 <pre>
 3031 t.Mv
 3032 </pre>
 3033 
 3034 <p>
 3035 yields a function value of type
 3036 </p>
 3037 
 3038 <pre>
 3039 func(int) int
 3040 </pre>
 3041 
 3042 <p>
 3043 These two invocations are equivalent:
 3044 </p>
 3045 
 3046 <pre>
 3047 t.Mv(7)
 3048 f := t.Mv; f(7)
 3049 </pre>
 3050 
 3051 <p>
 3052 Similarly, the expression
 3053 </p>
 3054 
 3055 <pre>
 3056 pt.Mp
 3057 </pre>
 3058 
 3059 <p>
 3060 yields a function value of type
 3061 </p>
 3062 
 3063 <pre>
 3064 func(float32) float32
 3065 </pre>
 3066 
 3067 <p>
 3068 As with <a href="#Selectors">selectors</a>, a reference to a non-interface method with a value receiver
 3069 using a pointer will automatically dereference that pointer: <code>pt.Mv</code> is equivalent to <code>(*pt).Mv</code>.
 3070 </p>
 3071 
 3072 <p>
 3073 As with <a href="#Calls">method calls</a>, a reference to a non-interface method with a pointer receiver
 3074 using an addressable value will automatically take the address of that value: <code>t.Mp</code> is equivalent to <code>(&amp;t).Mp</code>.
 3075 </p>
 3076 
 3077 <pre>
 3078 f := t.Mv; f(7)   // like t.Mv(7)
 3079 f := pt.Mp; f(7)  // like pt.Mp(7)
 3080 f := pt.Mv; f(7)  // like (*pt).Mv(7)
 3081 f := t.Mp; f(7)   // like (&amp;t).Mp(7)
 3082 f := makeT().Mp   // invalid: result of makeT() is not addressable
 3083 </pre>
 3084 
 3085 <p>
 3086 Although the examples above use non-interface types, it is also legal to create a method value
 3087 from a value of interface type.
 3088 </p>
 3089 
 3090 <pre>
 3091 var i interface { M(int) } = myVal
 3092 f := i.M; f(7)  // like i.M(7)
 3093 </pre>
 3094 
 3095 
 3096 <h3 id="Index_expressions">Index expressions</h3>
 3097 
 3098 <p>
 3099 A primary expression of the form
 3100 </p>
 3101 
 3102 <pre>
 3103 a[x]
 3104 </pre>
 3105 
 3106 <p>
 3107 denotes the element of the array, pointer to array, slice, string or map <code>a</code> indexed by <code>x</code>.
 3108 The value <code>x</code> is called the <i>index</i> or <i>map key</i>, respectively.
 3109 The following rules apply:
 3110 </p>
 3111 
 3112 <p>
 3113 If <code>a</code> is not a map:
 3114 </p>
 3115 <ul>
 3116     <li>the index <code>x</code> must be of integer type or an untyped constant</li>
 3117     <li>a constant index must be non-negative and
 3118         <a href="#Representability">representable</a> by a value of type <code>int</code></li>
 3119     <li>a constant index that is untyped is given type <code>int</code></li>
 3120     <li>the index <code>x</code> is <i>in range</i> if <code>0 &lt;= x &lt; len(a)</code>,
 3121         otherwise it is <i>out of range</i></li>
 3122 </ul>
 3123 
 3124 <p>
 3125 For <code>a</code> of <a href="#Array_types">array type</a> <code>A</code>:
 3126 </p>
 3127 <ul>
 3128     <li>a <a href="#Constants">constant</a> index must be in range</li>
 3129     <li>if <code>x</code> is out of range at run time,
 3130         a <a href="#Run_time_panics">run-time panic</a> occurs</li>
 3131     <li><code>a[x]</code> is the array element at index <code>x</code> and the type of
 3132         <code>a[x]</code> is the element type of <code>A</code></li>
 3133 </ul>
 3134 
 3135 <p>
 3136 For <code>a</code> of <a href="#Pointer_types">pointer</a> to array type:
 3137 </p>
 3138 <ul>
 3139     <li><code>a[x]</code> is shorthand for <code>(*a)[x]</code></li>
 3140 </ul>
 3141 
 3142 <p>
 3143 For <code>a</code> of <a href="#Slice_types">slice type</a> <code>S</code>:
 3144 </p>
 3145 <ul>
 3146     <li>if <code>x</code> is out of range at run time,
 3147         a <a href="#Run_time_panics">run-time panic</a> occurs</li>
 3148     <li><code>a[x]</code> is the slice element at index <code>x</code> and the type of
 3149         <code>a[x]</code> is the element type of <code>S</code></li>
 3150 </ul>
 3151 
 3152 <p>
 3153 For <code>a</code> of <a href="#String_types">string type</a>:
 3154 </p>
 3155 <ul>
 3156     <li>a <a href="#Constants">constant</a> index must be in range
 3157         if the string <code>a</code> is also constant</li>
 3158     <li>if <code>x</code> is out of range at run time,
 3159         a <a href="#Run_time_panics">run-time panic</a> occurs</li>
 3160     <li><code>a[x]</code> is the non-constant byte value at index <code>x</code> and the type of
 3161         <code>a[x]</code> is <code>byte</code></li>
 3162     <li><code>a[x]</code> may not be assigned to</li>
 3163 </ul>
 3164 
 3165 <p>
 3166 For <code>a</code> of <a href="#Map_types">map type</a> <code>M</code>:
 3167 </p>
 3168 <ul>
 3169     <li><code>x</code>'s type must be
 3170         <a href="#Assignability">assignable</a>
 3171         to the key type of <code>M</code></li>
 3172     <li>if the map contains an entry with key <code>x</code>,
 3173         <code>a[x]</code> is the map element with key <code>x</code>
 3174         and the type of <code>a[x]</code> is the element type of <code>M</code></li>
 3175     <li>if the map is <code>nil</code> or does not contain such an entry,
 3176         <code>a[x]</code> is the <a href="#The_zero_value">zero value</a>
 3177         for the element type of <code>M</code></li>
 3178 </ul>
 3179 
 3180 <p>
 3181 Otherwise <code>a[x]</code> is illegal.
 3182 </p>
 3183 
 3184 <p>
 3185 An index expression on a map <code>a</code> of type <code>map[K]V</code>
 3186 used in an <a href="#Assignments">assignment</a> or initialization of the special form
 3187 </p>
 3188 
 3189 <pre>
 3190 v, ok = a[x]
 3191 v, ok := a[x]
 3192 var v, ok = a[x]
 3193 </pre>
 3194 
 3195 <p>
 3196 yields an additional untyped boolean value. The value of <code>ok</code> is
 3197 <code>true</code> if the key <code>x</code> is present in the map, and
 3198 <code>false</code> otherwise.
 3199 </p>
 3200 
 3201 <p>
 3202 Assigning to an element of a <code>nil</code> map causes a
 3203 <a href="#Run_time_panics">run-time panic</a>.
 3204 </p>
 3205 
 3206 
 3207 <h3 id="Slice_expressions">Slice expressions</h3>
 3208 
 3209 <p>
 3210 Slice expressions construct a substring or slice from a string, array, pointer
 3211 to array, or slice. There are two variants: a simple form that specifies a low
 3212 and high bound, and a full form that also specifies a bound on the capacity.
 3213 </p>
 3214 
 3215 <h4>Simple slice expressions</h4>
 3216 
 3217 <p>
 3218 For a string, array, pointer to array, or slice <code>a</code>, the primary expression
 3219 </p>
 3220 
 3221 <pre>
 3222 a[low : high]
 3223 </pre>
 3224 
 3225 <p>
 3226 constructs a substring or slice. The <i>indices</i> <code>low</code> and
 3227 <code>high</code> select which elements of operand <code>a</code> appear
 3228 in the result. The result has indices starting at 0 and length equal to
 3229 <code>high</code>&nbsp;-&nbsp;<code>low</code>.
 3230 After slicing the array <code>a</code>
 3231 </p>
 3232 
 3233 <pre>
 3234 a := [5]int{1, 2, 3, 4, 5}
 3235 s := a[1:4]
 3236 </pre>
 3237 
 3238 <p>
 3239 the slice <code>s</code> has type <code>[]int</code>, length 3, capacity 4, and elements
 3240 </p>
 3241 
 3242 <pre>
 3243 s[0] == 2
 3244 s[1] == 3
 3245 s[2] == 4
 3246 </pre>
 3247 
 3248 <p>
 3249 For convenience, any of the indices may be omitted. A missing <code>low</code>
 3250 index defaults to zero; a missing <code>high</code> index defaults to the length of the
 3251 sliced operand:
 3252 </p>
 3253 
 3254 <pre>
 3255 a[2:]  // same as a[2 : len(a)]
 3256 a[:3]  // same as a[0 : 3]
 3257 a[:]   // same as a[0 : len(a)]
 3258 </pre>
 3259 
 3260 <p>
 3261 If <code>a</code> is a pointer to an array, <code>a[low : high]</code> is shorthand for
 3262 <code>(*a)[low : high]</code>.
 3263 </p>
 3264 
 3265 <p>
 3266 For arrays or strings, the indices are <i>in range</i> if
 3267 <code>0</code> &lt;= <code>low</code> &lt;= <code>high</code> &lt;= <code>len(a)</code>,
 3268 otherwise they are <i>out of range</i>.
 3269 For slices, the upper index bound is the slice capacity <code>cap(a)</code> rather than the length.
 3270 A <a href="#Constants">constant</a> index must be non-negative and
 3271 <a href="#Representability">representable</a> by a value of type
 3272 <code>int</code>; for arrays or constant strings, constant indices must also be in range.
 3273 If both indices are constant, they must satisfy <code>low &lt;= high</code>.
 3274 If the indices are out of range at run time, a <a href="#Run_time_panics">run-time panic</a> occurs.
 3275 </p>
 3276 
 3277 <p>
 3278 Except for <a href="#Constants">untyped strings</a>, if the sliced operand is a string or slice,
 3279 the result of the slice operation is a non-constant value of the same type as the operand.
 3280 For untyped string operands the result is a non-constant value of type <code>string</code>.
 3281 If the sliced operand is an array, it must be <a href="#Address_operators">addressable</a>
 3282 and the result of the slice operation is a slice with the same element type as the array.
 3283 </p>
 3284 
 3285 <p>
 3286 If the sliced operand of a valid slice expression is a <code>nil</code> slice, the result
 3287 is a <code>nil</code> slice. Otherwise, if the result is a slice, it shares its underlying
 3288 array with the operand.
 3289 </p>
 3290 
 3291 <pre>
 3292 var a [10]int
 3293 s1 := a[3:7]   // underlying array of s1 is array a; &amp;s1[2] == &amp;a[5]
 3294 s2 := s1[1:4]  // underlying array of s2 is underlying array of s1 which is array a; &amp;s2[1] == &amp;a[5]
 3295 s2[1] = 42     // s2[1] == s1[2] == a[5] == 42; they all refer to the same underlying array element
 3296 </pre>
 3297 
 3298 
 3299 <h4>Full slice expressions</h4>
 3300 
 3301 <p>
 3302 For an array, pointer to array, or slice <code>a</code> (but not a string), the primary expression
 3303 </p>
 3304 
 3305 <pre>
 3306 a[low : high : max]
 3307 </pre>
 3308 
 3309 <p>
 3310 constructs a slice of the same type, and with the same length and elements as the simple slice
 3311 expression <code>a[low : high]</code>. Additionally, it controls the resulting slice's capacity
 3312 by setting it to <code>max - low</code>. Only the first index may be omitted; it defaults to 0.
 3313 After slicing the array <code>a</code>
 3314 </p>
 3315 
 3316 <pre>
 3317 a := [5]int{1, 2, 3, 4, 5}
 3318 t := a[1:3:5]
 3319 </pre>
 3320 
 3321 <p>
 3322 the slice <code>t</code> has type <code>[]int</code>, length 2, capacity 4, and elements
 3323 </p>
 3324 
 3325 <pre>
 3326 t[0] == 2
 3327 t[1] == 3
 3328 </pre>
 3329 
 3330 <p>
 3331 As for simple slice expressions, if <code>a</code> is a pointer to an array,
 3332 <code>a[low : high : max]</code> is shorthand for <code>(*a)[low : high : max]</code>.
 3333 If the sliced operand is an array, it must be <a href="#Address_operators">addressable</a>.
 3334 </p>
 3335 
 3336 <p>
 3337 The indices are <i>in range</i> if <code>0 &lt;= low &lt;= high &lt;= max &lt;= cap(a)</code>,
 3338 otherwise they are <i>out of range</i>.
 3339 A <a href="#Constants">constant</a> index must be non-negative and
 3340 <a href="#Representability">representable</a> by a value of type
 3341 <code>int</code>; for arrays, constant indices must also be in range.
 3342 If multiple indices are constant, the constants that are present must be in range relative to each
 3343 other.
 3344 If the indices are out of range at run time, a <a href="#Run_time_panics">run-time panic</a> occurs.
 3345 </p>
 3346 
 3347 <h3 id="Type_assertions">Type assertions</h3>
 3348 
 3349 <p>
 3350 For an expression <code>x</code> of <a href="#Interface_types">interface type</a>
 3351 and a type <code>T</code>, the primary expression
 3352 </p>
 3353 
 3354 <pre>
 3355 x.(T)
 3356 </pre>
 3357 
 3358 <p>
 3359 asserts that <code>x</code> is not <code>nil</code>
 3360 and that the value stored in <code>x</code> is of type <code>T</code>.
 3361 The notation <code>x.(T)</code> is called a <i>type assertion</i>.
 3362 </p>
 3363 <p>
 3364 More precisely, if <code>T</code> is not an interface type, <code>x.(T)</code> asserts
 3365 that the dynamic type of <code>x</code> is <a href="#Type_identity">identical</a>
 3366 to the type <code>T</code>.
 3367 In this case, <code>T</code> must <a href="#Method_sets">implement</a> the (interface) type of <code>x</code>;
 3368 otherwise the type assertion is invalid since it is not possible for <code>x</code>
 3369 to store a value of type <code>T</code>.
 3370 If <code>T</code> is an interface type, <code>x.(T)</code> asserts that the dynamic type
 3371 of <code>x</code> implements the interface <code>T</code>.
 3372 </p>
 3373 <p>
 3374 If the type assertion holds, the value of the expression is the value
 3375 stored in <code>x</code> and its type is <code>T</code>. If the type assertion is false,
 3376 a <a href="#Run_time_panics">run-time panic</a> occurs.
 3377 In other words, even though the dynamic type of <code>x</code>
 3378 is known only at run time, the type of <code>x.(T)</code> is
 3379 known to be <code>T</code> in a correct program.
 3380 </p>
 3381 
 3382 <pre>
 3383 var x interface{} = 7          // x has dynamic type int and value 7
 3384 i := x.(int)                   // i has type int and value 7
 3385 
 3386 type I interface { m() }
 3387 
 3388 func f(y I) {
 3389     s := y.(string)        // illegal: string does not implement I (missing method m)
 3390     r := y.(io.Reader)     // r has type io.Reader and the dynamic type of y must implement both I and io.Reader
 3391 
 3392 }
 3393 </pre>
 3394 
 3395 <p>
 3396 A type assertion used in an <a href="#Assignments">assignment</a> or initialization of the special form
 3397 </p>
 3398 
 3399 <pre>
 3400 v, ok = x.(T)
 3401 v, ok := x.(T)
 3402 var v, ok = x.(T)
 3403 var v, ok T1 = x.(T)
 3404 </pre>
 3405 
 3406 <p>
 3407 yields an additional untyped boolean value. The value of <code>ok</code> is <code>true</code>
 3408 if the assertion holds. Otherwise it is <code>false</code> and the value of <code>v</code> is
 3409 the <a href="#The_zero_value">zero value</a> for type <code>T</code>.
 3410 No <a href="#Run_time_panics">run-time panic</a> occurs in this case.
 3411 </p>
 3412 
 3413 
 3414 <h3 id="Calls">Calls</h3>
 3415 
 3416 <p>
 3417 Given an expression <code>f</code> of function type
 3418 <code>F</code>,
 3419 </p>
 3420 
 3421 <pre>
 3422 f(a1, a2, … an)
 3423 </pre>
 3424 
 3425 <p>
 3426 calls <code>f</code> with arguments <code>a1, a2, … an</code>.
 3427 Except for one special case, arguments must be single-valued expressions
 3428 <a href="#Assignability">assignable</a> to the parameter types of
 3429 <code>F</code> and are evaluated before the function is called.
 3430 The type of the expression is the result type
 3431 of <code>F</code>.
 3432 A method invocation is similar but the method itself
 3433 is specified as a selector upon a value of the receiver type for
 3434 the method.
 3435 </p>
 3436 
 3437 <pre>
 3438 math.Atan2(x, y)  // function call
 3439 var pt *Point
 3440 pt.Scale(3.5)     // method call with receiver pt
 3441 </pre>
 3442 
 3443 <p>
 3444 In a function call, the function value and arguments are evaluated in
 3445 <a href="#Order_of_evaluation">the usual order</a>.
 3446 After they are evaluated, the parameters of the call are passed by value to the function
 3447 and the called function begins execution.
 3448 The return parameters of the function are passed by value
 3449 back to the calling function when the function returns.
 3450 </p>
 3451 
 3452 <p>
 3453 Calling a <code>nil</code> function value
 3454 causes a <a href="#Run_time_panics">run-time panic</a>.
 3455 </p>
 3456 
 3457 <p>
 3458 As a special case, if the return values of a function or method
 3459 <code>g</code> are equal in number and individually
 3460 assignable to the parameters of another function or method
 3461 <code>f</code>, then the call <code>f(g(<i>parameters_of_g</i>))</code>
 3462 will invoke <code>f</code> after binding the return values of
 3463 <code>g</code> to the parameters of <code>f</code> in order.  The call
 3464 of <code>f</code> must contain no parameters other than the call of <code>g</code>,
 3465 and <code>g</code> must have at least one return value.
 3466 If <code>f</code> has a final <code>...</code> parameter, it is
 3467 assigned the return values of <code>g</code> that remain after
 3468 assignment of regular parameters.
 3469 </p>
 3470 
 3471 <pre>
 3472 func Split(s string, pos int) (string, string) {
 3473     return s[0:pos], s[pos:]
 3474 }
 3475 
 3476 func Join(s, t string) string {
 3477     return s + t
 3478 }
 3479 
 3480 if Join(Split(value, len(value)/2)) != value {
 3481     log.Panic("test fails")
 3482 }
 3483 </pre>
 3484 
 3485 <p>
 3486 A method call <code>x.m()</code> is valid if the <a href="#Method_sets">method set</a>
 3487 of (the type of) <code>x</code> contains <code>m</code> and the
 3488 argument list can be assigned to the parameter list of <code>m</code>.
 3489 If <code>x</code> is <a href="#Address_operators">addressable</a> and <code>&amp;x</code>'s method
 3490 set contains <code>m</code>, <code>x.m()</code> is shorthand
 3491 for <code>(&amp;x).m()</code>:
 3492 </p>
 3493 
 3494 <pre>
 3495 var p Point
 3496 p.Scale(3.5)
 3497 </pre>
 3498 
 3499 <p>
 3500 There is no distinct method type and there are no method literals.
 3501 </p>
 3502 
 3503 <h3 id="Passing_arguments_to_..._parameters">Passing arguments to <code>...</code> parameters</h3>
 3504 
 3505 <p>
 3506 If <code>f</code> is <a href="#Function_types">variadic</a> with a final
 3507 parameter <code>p</code> of type <code>...T</code>, then within <code>f</code>
 3508 the type of <code>p</code> is equivalent to type <code>[]T</code>.
 3509 If <code>f</code> is invoked with no actual arguments for <code>p</code>,
 3510 the value passed to <code>p</code> is <code>nil</code>.
 3511 Otherwise, the value passed is a new slice
 3512 of type <code>[]T</code> with a new underlying array whose successive elements
 3513 are the actual arguments, which all must be <a href="#Assignability">assignable</a>
 3514 to <code>T</code>. The length and capacity of the slice is therefore
 3515 the number of arguments bound to <code>p</code> and may differ for each
 3516 call site.
 3517 </p>
 3518 
 3519 <p>
 3520 Given the function and calls
 3521 </p>
 3522 <pre>
 3523 func Greeting(prefix string, who ...string)
 3524 Greeting("nobody")
 3525 Greeting("hello:", "Joe", "Anna", "Eileen")
 3526 </pre>
 3527 
 3528 <p>
 3529 within <code>Greeting</code>, <code>who</code> will have the value
 3530 <code>nil</code> in the first call, and
 3531 <code>[]string{"Joe", "Anna", "Eileen"}</code> in the second.
 3532 </p>
 3533 
 3534 <p>
 3535 If the final argument is assignable to a slice type <code>[]T</code>, it is
 3536 passed unchanged as the value for a <code>...T</code> parameter if the argument
 3537 is followed by <code>...</code>. In this case no new slice is created.
 3538 </p>
 3539 
 3540 <p>
 3541 Given the slice <code>s</code> and call
 3542 </p>
 3543 
 3544 <pre>
 3545 s := []string{"James", "Jasmine"}
 3546 Greeting("goodbye:", s...)
 3547 </pre>
 3548 
 3549 <p>
 3550 within <code>Greeting</code>, <code>who</code> will have the same value as <code>s</code>
 3551 with the same underlying array.
 3552 </p>
 3553 
 3554 
 3555 <h3 id="Operators">Operators</h3>
 3556 
 3557 <p>
 3558 Operators combine operands into expressions.
 3559 </p>
 3560 
 3561 <pre class="ebnf">
 3562 Expression = UnaryExpr | Expression binary_op Expression .
 3563 UnaryExpr  = PrimaryExpr | unary_op UnaryExpr .
 3564 
 3565 binary_op  = "||" | "&amp;&amp;" | rel_op | add_op | mul_op .
 3566 rel_op     = "==" | "!=" | "&lt;" | "&lt;=" | ">" | ">=" .
 3567 add_op     = "+" | "-" | "|" | "^" .
 3568 mul_op     = "*" | "/" | "%" | "&lt;&lt;" | "&gt;&gt;" | "&amp;" | "&amp;^" .
 3569 
 3570 unary_op   = "+" | "-" | "!" | "^" | "*" | "&amp;" | "&lt;-" .
 3571 </pre>
 3572 
 3573 <p>
 3574 Comparisons are discussed <a href="#Comparison_operators">elsewhere</a>.
 3575 For other binary operators, the operand types must be <a href="#Type_identity">identical</a>
 3576 unless the operation involves shifts or untyped <a href="#Constants">constants</a>.
 3577 For operations involving constants only, see the section on
 3578 <a href="#Constant_expressions">constant expressions</a>.
 3579 </p>
 3580 
 3581 <p>
 3582 Except for shift operations, if one operand is an untyped <a href="#Constants">constant</a>
 3583 and the other operand is not, the constant is implicitly <a href="#Conversions">converted</a>
 3584 to the type of the other operand.
 3585 </p>
 3586 
 3587 <p>
 3588 The right operand in a shift expression must have integer type
 3589 or be an untyped constant <a href="#Representability">representable</a> by a
 3590 value of type <code>uint</code>.
 3591 If the left operand of a non-constant shift expression is an untyped constant,
 3592 it is first implicitly converted to the type it would assume if the shift expression were
 3593 replaced by its left operand alone.
 3594 </p>
 3595 
 3596 <pre>
 3597 var s uint = 33
 3598 var i = 1&lt;&lt;s                  // 1 has type int
 3599 var j int32 = 1&lt;&lt;s            // 1 has type int32; j == 0
 3600 var k = uint64(1&lt;&lt;s)          // 1 has type uint64; k == 1&lt;&lt;33
 3601 var m int = 1.0&lt;&lt;s            // 1.0 has type int; m == 0 if ints are 32bits in size
 3602 var n = 1.0&lt;&lt;s == j           // 1.0 has type int32; n == true
 3603 var o = 1&lt;&lt;s == 2&lt;&lt;s          // 1 and 2 have type int; o == true if ints are 32bits in size
 3604 var p = 1&lt;&lt;s == 1&lt;&lt;33         // illegal if ints are 32bits in size: 1 has type int, but 1&lt;&lt;33 overflows int
 3605 var u = 1.0&lt;&lt;s                // illegal: 1.0 has type float64, cannot shift
 3606 var u1 = 1.0&lt;&lt;s != 0          // illegal: 1.0 has type float64, cannot shift
 3607 var u2 = 1&lt;&lt;s != 1.0          // illegal: 1 has type float64, cannot shift
 3608 var v float32 = 1&lt;&lt;s          // illegal: 1 has type float32, cannot shift
 3609 var w int64 = 1.0&lt;&lt;33         // 1.0&lt;&lt;33 is a constant shift expression
 3610 var x = a[1.0&lt;&lt;s]             // 1.0 has type int; x == a[0] if ints are 32bits in size
 3611 var a = make([]byte, 1.0&lt;&lt;s)  // 1.0 has type int; len(a) == 0 if ints are 32bits in size
 3612 </pre>
 3613 
 3614 
 3615 <h4 id="Operator_precedence">Operator precedence</h4>
 3616 <p>
 3617 Unary operators have the highest precedence.
 3618 As the  <code>++</code> and <code>--</code> operators form
 3619 statements, not expressions, they fall
 3620 outside the operator hierarchy.
 3621 As a consequence, statement <code>*p++</code> is the same as <code>(*p)++</code>.
 3622 <p>
 3623 There are five precedence levels for binary operators.
 3624 Multiplication operators bind strongest, followed by addition
 3625 operators, comparison operators, <code>&amp;&amp;</code> (logical AND),
 3626 and finally <code>||</code> (logical OR):
 3627 </p>
 3628 
 3629 <pre class="grammar">
 3630 Precedence    Operator
 3631     5             *  /  %  &lt;&lt;  &gt;&gt;  &amp;  &amp;^
 3632     4             +  -  |  ^
 3633     3             ==  !=  &lt;  &lt;=  &gt;  &gt;=
 3634     2             &amp;&amp;
 3635     1             ||
 3636 </pre>
 3637 
 3638 <p>
 3639 Binary operators of the same precedence associate from left to right.
 3640 For instance, <code>x / y * z</code> is the same as <code>(x / y) * z</code>.
 3641 </p>
 3642 
 3643 <pre>
 3644 +x
 3645 23 + 3*x[i]
 3646 x &lt;= f()
 3647 ^a &gt;&gt; b
 3648 f() || g()
 3649 x == y+1 &amp;&amp; &lt;-chanPtr &gt; 0
 3650 </pre>
 3651 
 3652 
 3653 <h3 id="Arithmetic_operators">Arithmetic operators</h3>
 3654 <p>
 3655 Arithmetic operators apply to numeric values and yield a result of the same
 3656 type as the first operand. The four standard arithmetic operators (<code>+</code>,
 3657 <code>-</code>, <code>*</code>, <code>/</code>) apply to integer,
 3658 floating-point, and complex types; <code>+</code> also applies to strings.
 3659 The bitwise logical and shift operators apply to integers only.
 3660 </p>
 3661 
 3662 <pre class="grammar">
 3663 +    sum                    integers, floats, complex values, strings
 3664 -    difference             integers, floats, complex values
 3665 *    product                integers, floats, complex values
 3666 /    quotient               integers, floats, complex values
 3667 %    remainder              integers
 3668 
 3669 &amp;    bitwise AND            integers
 3670 |    bitwise OR             integers
 3671 ^    bitwise XOR            integers
 3672 &amp;^   bit clear (AND NOT)    integers
 3673 
 3674 &lt;&lt;   left shift             integer &lt;&lt; unsigned integer
 3675 &gt;&gt;   right shift            integer &gt;&gt; unsigned integer
 3676 </pre>
 3677 
 3678 
 3679 <h4 id="Integer_operators">Integer operators</h4>
 3680 
 3681 <p>
 3682 For two integer values <code>x</code> and <code>y</code>, the integer quotient
 3683 <code>q = x / y</code> and remainder <code>r = x % y</code> satisfy the following
 3684 relationships:
 3685 </p>
 3686 
 3687 <pre>
 3688 x = q*y + r  and  |r| &lt; |y|
 3689 </pre>
 3690 
 3691 <p>
 3692 with <code>x / y</code> truncated towards zero
 3693 (<a href="https://en.wikipedia.org/wiki/Modulo_operation">"truncated division"</a>).
 3694 </p>
 3695 
 3696 <pre>
 3697  x     y     x / y     x % y
 3698  5     3       1         2
 3699 -5     3      -1        -2
 3700  5    -3      -1         2
 3701 -5    -3       1        -2
 3702 </pre>
 3703 
 3704 <p>
 3705 The one exception to this rule is that if the dividend <code>x</code> is
 3706 the most negative value for the int type of <code>x</code>, the quotient
 3707 <code>q = x / -1</code> is equal to <code>x</code> (and <code>r = 0</code>)
 3708 due to two's-complement <a href="#Integer_overflow">integer overflow</a>:
 3709 </p>
 3710 
 3711 <pre>
 3712              x, q
 3713 int8                     -128
 3714 int16                  -32768
 3715 int32             -2147483648
 3716 int64    -9223372036854775808
 3717 </pre>
 3718 
 3719 <p>
 3720 If the divisor is a <a href="#Constants">constant</a>, it must not be zero.
 3721 If the divisor is zero at run time, a <a href="#Run_time_panics">run-time panic</a> occurs.
 3722 If the dividend is non-negative and the divisor is a constant power of 2,
 3723 the division may be replaced by a right shift, and computing the remainder may
 3724 be replaced by a bitwise AND operation:
 3725 </p>
 3726 
 3727 <pre>
 3728  x     x / 4     x % 4     x &gt;&gt; 2     x &amp; 3
 3729  11      2         3         2          3
 3730 -11     -2        -3        -3          1
 3731 </pre>
 3732 
 3733 <p>
 3734 The shift operators shift the left operand by the shift count specified by the
 3735 right operand, which must be non-negative. If the shift count is negative at run time,
 3736 a <a href="#Run_time_panics">run-time panic</a> occurs.
 3737 The shift operators implement arithmetic shifts if the left operand is a signed
 3738 integer and logical shifts if it is an unsigned integer.
 3739 There is no upper limit on the shift count. Shifts behave
 3740 as if the left operand is shifted <code>n</code> times by 1 for a shift
 3741 count of <code>n</code>.
 3742 As a result, <code>x &lt;&lt; 1</code> is the same as <code>x*2</code>
 3743 and <code>x &gt;&gt; 1</code> is the same as
 3744 <code>x/2</code> but truncated towards negative infinity.
 3745 </p>
 3746 
 3747 <p>
 3748 For integer operands, the unary operators
 3749 <code>+</code>, <code>-</code>, and <code>^</code> are defined as
 3750 follows:
 3751 </p>
 3752 
 3753 <pre class="grammar">
 3754 +x                          is 0 + x
 3755 -x    negation              is 0 - x
 3756 ^x    bitwise complement    is m ^ x  with m = "all bits set to 1" for unsigned x
 3757                                       and  m = -1 for signed x
 3758 </pre>
 3759 
 3760 
 3761 <h4 id="Integer_overflow">Integer overflow</h4>
 3762 
 3763 <p>
 3764 For unsigned integer values, the operations <code>+</code>,
 3765 <code>-</code>, <code>*</code>, and <code>&lt;&lt;</code> are
 3766 computed modulo 2<sup><i>n</i></sup>, where <i>n</i> is the bit width of
 3767 the <a href="#Numeric_types">unsigned integer</a>'s type.
 3768 Loosely speaking, these unsigned integer operations
 3769 discard high bits upon overflow, and programs may rely on "wrap around".
 3770 </p>
 3771 <p>
 3772 For signed integers, the operations <code>+</code>,
 3773 <code>-</code>, <code>*</code>, <code>/</code>, and <code>&lt;&lt;</code> may legally
 3774 overflow and the resulting value exists and is deterministically defined
 3775 by the signed integer representation, the operation, and its operands.
 3776 Overflow does not cause a <a href="#Run_time_panics">run-time panic</a>.
 3777 A compiler may not optimize code under the assumption that overflow does
 3778 not occur. For instance, it may not assume that <code>x &lt; x + 1</code> is always true.
 3779 </p>
 3780 
 3781 
 3782 <h4 id="Floating_point_operators">Floating-point operators</h4>
 3783 
 3784 <p>
 3785 For floating-point and complex numbers,
 3786 <code>+x</code> is the same as <code>x</code>,
 3787 while <code>-x</code> is the negation of <code>x</code>.
 3788 The result of a floating-point or complex division by zero is not specified beyond the
 3789 IEEE-754 standard; whether a <a href="#Run_time_panics">run-time panic</a>
 3790 occurs is implementation-specific.
 3791 </p>
 3792 
 3793 <p>
 3794 An implementation may combine multiple floating-point operations into a single
 3795 fused operation, possibly across statements, and produce a result that differs
 3796 from the value obtained by executing and rounding the instructions individually.
 3797 An explicit floating-point type <a href="#Conversions">conversion</a> rounds to
 3798 the precision of the target type, preventing fusion that would discard that rounding.
 3799 </p>
 3800 
 3801 <p>
 3802 For instance, some architectures provide a "fused multiply and add" (FMA) instruction
 3803 that computes <code>x*y + z</code> without rounding the intermediate result <code>x*y</code>.
 3804 These examples show when a Go implementation can use that instruction:
 3805 </p>
 3806 
 3807 <pre>
 3808 // FMA allowed for computing r, because x*y is not explicitly rounded:
 3809 r  = x*y + z
 3810 r  = z;   r += x*y
 3811 t  = x*y; r = t + z
 3812 *p = x*y; r = *p + z
 3813 r  = x*y + float64(z)
 3814 
 3815 // FMA disallowed for computing r, because it would omit rounding of x*y:
 3816 r  = float64(x*y) + z
 3817 r  = z; r += float64(x*y)
 3818 t  = float64(x*y); r = t + z
 3819 </pre>
 3820 
 3821 <h4 id="String_concatenation">String concatenation</h4>
 3822 
 3823 <p>
 3824 Strings can be concatenated using the <code>+</code> operator
 3825 or the <code>+=</code> assignment operator:
 3826 </p>
 3827 
 3828 <pre>
 3829 s := "hi" + string(c)
 3830 s += " and good bye"
 3831 </pre>
 3832 
 3833 <p>
 3834 String addition creates a new string by concatenating the operands.
 3835 </p>
 3836 
 3837 
 3838 <h3 id="Comparison_operators">Comparison operators</h3>
 3839 
 3840 <p>
 3841 Comparison operators compare two operands and yield an untyped boolean value.
 3842 </p>
 3843 
 3844 <pre class="grammar">
 3845 ==    equal
 3846 !=    not equal
 3847 &lt;     less
 3848 &lt;=    less or equal
 3849 &gt;     greater
 3850 &gt;=    greater or equal
 3851 </pre>
 3852 
 3853 <p>
 3854 In any comparison, the first operand
 3855 must be <a href="#Assignability">assignable</a>
 3856 to the type of the second operand, or vice versa.
 3857 </p>
 3858 <p>
 3859 The equality operators <code>==</code> and <code>!=</code> apply
 3860 to operands that are <i>comparable</i>.
 3861 The ordering operators <code>&lt;</code>, <code>&lt;=</code>, <code>&gt;</code>, and <code>&gt;=</code>
 3862 apply to operands that are <i>ordered</i>.
 3863 These terms and the result of the comparisons are defined as follows:
 3864 </p>
 3865 
 3866 <ul>
 3867     <li>
 3868     Boolean values are comparable.
 3869     Two boolean values are equal if they are either both
 3870     <code>true</code> or both <code>false</code>.
 3871     </li>
 3872 
 3873     <li>
 3874     Integer values are comparable and ordered, in the usual way.
 3875     </li>
 3876 
 3877     <li>
 3878     Floating-point values are comparable and ordered,
 3879     as defined by the IEEE-754 standard.
 3880     </li>
 3881 
 3882     <li>
 3883     Complex values are comparable.
 3884     Two complex values <code>u</code> and <code>v</code> are
 3885     equal if both <code>real(u) == real(v)</code> and
 3886     <code>imag(u) == imag(v)</code>.
 3887     </li>
 3888 
 3889     <li>
 3890     String values are comparable and ordered, lexically byte-wise.
 3891     </li>
 3892 
 3893     <li>
 3894     Pointer values are comparable.
 3895     Two pointer values are equal if they point to the same variable or if both have value <code>nil</code>.
 3896     Pointers to distinct <a href="#Size_and_alignment_guarantees">zero-size</a> variables may or may not be equal.
 3897     </li>
 3898 
 3899     <li>
 3900     Channel values are comparable.
 3901     Two channel values are equal if they were created by the same call to
 3902     <a href="#Making_slices_maps_and_channels"><code>make</code></a>
 3903     or if both have value <code>nil</code>.
 3904     </li>
 3905 
 3906     <li>
 3907     Interface values are comparable.
 3908     Two interface values are equal if they have <a href="#Type_identity">identical</a> dynamic types
 3909     and equal dynamic values or if both have value <code>nil</code>.
 3910     </li>
 3911 
 3912     <li>
 3913     A value <code>x</code> of non-interface type <code>X</code> and
 3914     a value <code>t</code> of interface type <code>T</code> are comparable when values
 3915     of type <code>X</code> are comparable and
 3916     <code>X</code> implements <code>T</code>.
 3917     They are equal if <code>t</code>'s dynamic type is identical to <code>X</code>
 3918     and <code>t</code>'s dynamic value is equal to <code>x</code>.
 3919     </li>
 3920 
 3921     <li>
 3922     Struct values are comparable if all their fields are comparable.
 3923     Two struct values are equal if their corresponding
 3924     non-<a href="#Blank_identifier">blank</a> fields are equal.
 3925     </li>
 3926 
 3927     <li>
 3928     Array values are comparable if values of the array element type are comparable.
 3929     Two array values are equal if their corresponding elements are equal.
 3930     </li>
 3931 </ul>
 3932 
 3933 <p>
 3934 A comparison of two interface values with identical dynamic types
 3935 causes a <a href="#Run_time_panics">run-time panic</a> if values
 3936 of that type are not comparable.  This behavior applies not only to direct interface
 3937 value comparisons but also when comparing arrays of interface values
 3938 or structs with interface-valued fields.
 3939 </p>
 3940 
 3941 <p>
 3942 Slice, map, and function values are not comparable.
 3943 However, as a special case, a slice, map, or function value may
 3944 be compared to the predeclared identifier <code>nil</code>.
 3945 Comparison of pointer, channel, and interface values to <code>nil</code>
 3946 is also allowed and follows from the general rules above.
 3947 </p>
 3948 
 3949 <pre>
 3950 const c = 3 &lt; 4            // c is the untyped boolean constant true
 3951 
 3952 type MyBool bool
 3953 var x, y int
 3954 var (
 3955     // The result of a comparison is an untyped boolean.
 3956     // The usual assignment rules apply.
 3957     b3        = x == y // b3 has type bool
 3958     b4 bool   = x == y // b4 has type bool
 3959     b5 MyBool = x == y // b5 has type MyBool
 3960 )
 3961 </pre>
 3962 
 3963 <h3 id="Logical_operators">Logical operators</h3>
 3964 
 3965 <p>
 3966 Logical operators apply to <a href="#Boolean_types">boolean</a> values
 3967 and yield a result of the same type as the operands.
 3968 The right operand is evaluated conditionally.
 3969 </p>
 3970 
 3971 <pre class="grammar">
 3972 &amp;&amp;    conditional AND    p &amp;&amp; q  is  "if p then q else false"
 3973 ||    conditional OR     p || q  is  "if p then true else q"
 3974 !     NOT                !p      is  "not p"
 3975 </pre>
 3976 
 3977 
 3978 <h3 id="Address_operators">Address operators</h3>
 3979 
 3980 <p>
 3981 For an operand <code>x</code> of type <code>T</code>, the address operation
 3982 <code>&amp;x</code> generates a pointer of type <code>*T</code> to <code>x</code>.
 3983 The operand must be <i>addressable</i>,
 3984 that is, either a variable, pointer indirection, or slice indexing
 3985 operation; or a field selector of an addressable struct operand;
 3986 or an array indexing operation of an addressable array.
 3987 As an exception to the addressability requirement, <code>x</code> may also be a
 3988 (possibly parenthesized)
 3989 <a href="#Composite_literals">composite literal</a>.
 3990 If the evaluation of <code>x</code> would cause a <a href="#Run_time_panics">run-time panic</a>,
 3991 then the evaluation of <code>&amp;x</code> does too.
 3992 </p>
 3993 
 3994 <p>
 3995 For an operand <code>x</code> of pointer type <code>*T</code>, the pointer
 3996 indirection <code>*x</code> denotes the <a href="#Variables">variable</a> of type <code>T</code> pointed
 3997 to by <code>x</code>.
 3998 If <code>x</code> is <code>nil</code>, an attempt to evaluate <code>*x</code>
 3999 will cause a <a href="#Run_time_panics">run-time panic</a>.
 4000 </p>
 4001 
 4002 <pre>
 4003 &amp;x
 4004 &amp;a[f(2)]
 4005 &amp;Point{2, 3}
 4006 *p
 4007 *pf(x)
 4008 
 4009 var x *int = nil
 4010 *x   // causes a run-time panic
 4011 &amp;*x  // causes a run-time panic
 4012 </pre>
 4013 
 4014 
 4015 <h3 id="Receive_operator">Receive operator</h3>
 4016 
 4017 <p>
 4018 For an operand <code>ch</code> of <a href="#Channel_types">channel type</a>,
 4019 the value of the receive operation <code>&lt;-ch</code> is the value received
 4020 from the channel <code>ch</code>. The channel direction must permit receive operations,
 4021 and the type of the receive operation is the element type of the channel.
 4022 The expression blocks until a value is available.
 4023 Receiving from a <code>nil</code> channel blocks forever.
 4024 A receive operation on a <a href="#Close">closed</a> channel can always proceed
 4025 immediately, yielding the element type's <a href="#The_zero_value">zero value</a>
 4026 after any previously sent values have been received.
 4027 </p>
 4028 
 4029 <pre>
 4030 v1 := &lt;-ch
 4031 v2 = &lt;-ch
 4032 f(&lt;-ch)
 4033 &lt;-strobe  // wait until clock pulse and discard received value
 4034 </pre>
 4035 
 4036 <p>
 4037 A receive expression used in an <a href="#Assignments">assignment</a> or initialization of the special form
 4038 </p>
 4039 
 4040 <pre>
 4041 x, ok = &lt;-ch
 4042 x, ok := &lt;-ch
 4043 var x, ok = &lt;-ch
 4044 var x, ok T = &lt;-ch
 4045 </pre>
 4046 
 4047 <p>
 4048 yields an additional untyped boolean result reporting whether the
 4049 communication succeeded. The value of <code>ok</code> is <code>true</code>
 4050 if the value received was delivered by a successful send operation to the
 4051 channel, or <code>false</code> if it is a zero value generated because the
 4052 channel is closed and empty.
 4053 </p>
 4054 
 4055 
 4056 <h3 id="Conversions">Conversions</h3>
 4057 
 4058 <p>
 4059 A conversion changes the <a href="#Types">type</a> of an expression
 4060 to the type specified by the conversion.
 4061 A conversion may appear literally in the source, or it may be <i>implied</i>
 4062 by the context in which an expression appears.
 4063 </p>
 4064 
 4065 <p>
 4066 An <i>explicit</i> conversion is an expression of the form <code>T(x)</code>
 4067 where <code>T</code> is a type and <code>x</code> is an expression
 4068 that can be converted to type <code>T</code>.
 4069 </p>
 4070 
 4071 <pre class="ebnf">
 4072 Conversion = Type "(" Expression [ "," ] ")" .
 4073 </pre>
 4074 
 4075 <p>
 4076 If the type starts with the operator <code>*</code> or <code>&lt;-</code>,
 4077 or if the type starts with the keyword <code>func</code>
 4078 and has no result list, it must be parenthesized when
 4079 necessary to avoid ambiguity:
 4080 </p>
 4081 
 4082 <pre>
 4083 *Point(p)        // same as *(Point(p))
 4084 (*Point)(p)      // p is converted to *Point
 4085 &lt;-chan int(c)    // same as &lt;-(chan int(c))
 4086 (&lt;-chan int)(c)  // c is converted to &lt;-chan int
 4087 func()(x)        // function signature func() x
 4088 (func())(x)      // x is converted to func()
 4089 (func() int)(x)  // x is converted to func() int
 4090 func() int(x)    // x is converted to func() int (unambiguous)
 4091 </pre>
 4092 
 4093 <p>
 4094 A <a href="#Constants">constant</a> value <code>x</code> can be converted to
 4095 type <code>T</code> if <code>x</code> is <a href="#Representability">representable</a>
 4096 by a value of <code>T</code>.
 4097 As a special case, an integer constant <code>x</code> can be explicitly converted to a
 4098 <a href="#String_types">string type</a> using the
 4099 <a href="#Conversions_to_and_from_a_string_type">same rule</a>
 4100 as for non-constant <code>x</code>.
 4101 </p>
 4102 
 4103 <p>
 4104 Converting a constant yields a typed constant as result.
 4105 </p>
 4106 
 4107 <pre>
 4108 uint(iota)               // iota value of type uint
 4109 float32(2.718281828)     // 2.718281828 of type float32
 4110 complex128(1)            // 1.0 + 0.0i of type complex128
 4111 float32(0.49999999)      // 0.5 of type float32
 4112 float64(-1e-1000)        // 0.0 of type float64
 4113 string('x')              // "x" of type string
 4114 string(0x266c)           // "" of type string
 4115 MyString("foo" + "bar")  // "foobar" of type MyString
 4116 string([]byte{'a'})      // not a constant: []byte{'a'} is not a constant
 4117 (*int)(nil)              // not a constant: nil is not a constant, *int is not a boolean, numeric, or string type
 4118 int(1.2)                 // illegal: 1.2 cannot be represented as an int
 4119 string(65.0)             // illegal: 65.0 is not an integer constant
 4120 </pre>
 4121 
 4122 <p>
 4123 A non-constant value <code>x</code> can be converted to type <code>T</code>
 4124 in any of these cases:
 4125 </p>
 4126 
 4127 <ul>
 4128     <li>
 4129     <code>x</code> is <a href="#Assignability">assignable</a>
 4130     to <code>T</code>.
 4131     </li>
 4132     <li>
 4133     ignoring struct tags (see below),
 4134     <code>x</code>'s type and <code>T</code> have <a href="#Type_identity">identical</a>
 4135     <a href="#Types">underlying types</a>.
 4136     </li>
 4137     <li>
 4138     ignoring struct tags (see below),
 4139     <code>x</code>'s type and <code>T</code> are pointer types
 4140     that are not <a href="#Type_definitions">defined types</a>,
 4141     and their pointer base types have identical underlying types.
 4142     </li>
 4143     <li>
 4144     <code>x</code>'s type and <code>T</code> are both integer or floating
 4145     point types.
 4146     </li>
 4147     <li>
 4148     <code>x</code>'s type and <code>T</code> are both complex types.
 4149     </li>
 4150     <li>
 4151     <code>x</code> is an integer or a slice of bytes or runes
 4152     and <code>T</code> is a string type.
 4153     </li>
 4154     <li>
 4155     <code>x</code> is a string and <code>T</code> is a slice of bytes or runes.
 4156     </li>
 4157 </ul>
 4158 
 4159 <p>
 4160 <a href="#Struct_types">Struct tags</a> are ignored when comparing struct types
 4161 for identity for the purpose of conversion:
 4162 </p>
 4163 
 4164 <pre>
 4165 type Person struct {
 4166     Name    string
 4167     Address *struct {
 4168         Street string
 4169         City   string
 4170     }
 4171 }
 4172 
 4173 var data *struct {
 4174     Name    string `json:"name"`
 4175     Address *struct {
 4176         Street string `json:"street"`
 4177         City   string `json:"city"`
 4178     } `json:"address"`
 4179 }
 4180 
 4181 var person = (*Person)(data)  // ignoring tags, the underlying types are identical
 4182 </pre>
 4183 
 4184 <p>
 4185 Specific rules apply to (non-constant) conversions between numeric types or
 4186 to and from a string type.
 4187 These conversions may change the representation of <code>x</code>
 4188 and incur a run-time cost.
 4189 All other conversions only change the type but not the representation
 4190 of <code>x</code>.
 4191 </p>
 4192 
 4193 <p>
 4194 There is no linguistic mechanism to convert between pointers and integers.
 4195 The package <a href="#Package_unsafe"><code>unsafe</code></a>
 4196 implements this functionality under
 4197 restricted circumstances.
 4198 </p>
 4199 
 4200 <h4>Conversions between numeric types</h4>
 4201 
 4202 <p>
 4203 For the conversion of non-constant numeric values, the following rules apply:
 4204 </p>
 4205 
 4206 <ol>
 4207 <li>
 4208 When converting between integer types, if the value is a signed integer, it is
 4209 sign extended to implicit infinite precision; otherwise it is zero extended.
 4210 It is then truncated to fit in the result type's size.
 4211 For example, if <code>v := uint16(0x10F0)</code>, then <code>uint32(int8(v)) == 0xFFFFFFF0</code>.
 4212 The conversion always yields a valid value; there is no indication of overflow.
 4213 </li>
 4214 <li>
 4215 When converting a floating-point number to an integer, the fraction is discarded
 4216 (truncation towards zero).
 4217 </li>
 4218 <li>
 4219 When converting an integer or floating-point number to a floating-point type,
 4220 or a complex number to another complex type, the result value is rounded
 4221 to the precision specified by the destination type.
 4222 For instance, the value of a variable <code>x</code> of type <code>float32</code>
 4223 may be stored using additional precision beyond that of an IEEE-754 32-bit number,
 4224 but float32(x) represents the result of rounding <code>x</code>'s value to
 4225 32-bit precision. Similarly, <code>x + 0.1</code> may use more than 32 bits
 4226 of precision, but <code>float32(x + 0.1)</code> does not.
 4227 </li>
 4228 </ol>
 4229 
 4230 <p>
 4231 In all non-constant conversions involving floating-point or complex values,
 4232 if the result type cannot represent the value the conversion
 4233 succeeds but the result value is implementation-dependent.
 4234 </p>
 4235 
 4236 <h4 id="Conversions_to_and_from_a_string_type">Conversions to and from a string type</h4>
 4237 
 4238 <ol>
 4239 <li>
 4240 Converting a signed or unsigned integer value to a string type yields a
 4241 string containing the UTF-8 representation of the integer. Values outside
 4242 the range of valid Unicode code points are converted to <code>"\uFFFD"</code>.
 4243 
 4244 <pre>
 4245 string('a')       // "a"
 4246 string(-1)        // "\ufffd" == "\xef\xbf\xbd"
 4247 string(0xf8)      // "\u00f8" == "ø" == "\xc3\xb8"
 4248 type MyString string
 4249 MyString(0x65e5)  // "\u65e5" == "" == "\xe6\x97\xa5"
 4250 </pre>
 4251 </li>
 4252 
 4253 <li>
 4254 Converting a slice of bytes to a string type yields
 4255 a string whose successive bytes are the elements of the slice.
 4256 
 4257 <pre>
 4258 string([]byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'})   // "hellø"
 4259 string([]byte{})                                     // ""
 4260 string([]byte(nil))                                  // ""
 4261 
 4262 type MyBytes []byte
 4263 string(MyBytes{'h', 'e', 'l', 'l', '\xc3', '\xb8'})  // "hellø"
 4264 </pre>
 4265 </li>
 4266 
 4267 <li>
 4268 Converting a slice of runes to a string type yields
 4269 a string that is the concatenation of the individual rune values
 4270 converted to strings.
 4271 
 4272 <pre>
 4273 string([]rune{0x767d, 0x9d6c, 0x7fd4})   // "\u767d\u9d6c\u7fd4" == "白鵬翔"
 4274 string([]rune{})                         // ""
 4275 string([]rune(nil))                      // ""
 4276 
 4277 type MyRunes []rune
 4278 string(MyRunes{0x767d, 0x9d6c, 0x7fd4})  // "\u767d\u9d6c\u7fd4" == "白鵬翔"
 4279 </pre>
 4280 </li>
 4281 
 4282 <li>
 4283 Converting a value of a string type to a slice of bytes type
 4284 yields a slice whose successive elements are the bytes of the string.
 4285 
 4286 <pre>
 4287 []byte("hellø")   // []byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'}
 4288 []byte("")        // []byte{}
 4289 
 4290 MyBytes("hellø")  // []byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'}
 4291 </pre>
 4292 </li>
 4293 
 4294 <li>
 4295 Converting a value of a string type to a slice of runes type
 4296 yields a slice containing the individual Unicode code points of the string.
 4297 
 4298 <pre>
 4299 []rune(MyString("白鵬翔"))  // []rune{0x767d, 0x9d6c, 0x7fd4}
 4300 []rune("")                 // []rune{}
 4301 
 4302 MyRunes("白鵬翔")           // []rune{0x767d, 0x9d6c, 0x7fd4}
 4303 </pre>
 4304 </li>
 4305 </ol>
 4306 
 4307 
 4308 <h3 id="Constant_expressions">Constant expressions</h3>
 4309 
 4310 <p>
 4311 Constant expressions may contain only <a href="#Constants">constant</a>
 4312 operands and are evaluated at compile time.
 4313 </p>
 4314 
 4315 <p>
 4316 Untyped boolean, numeric, and string constants may be used as operands
 4317 wherever it is legal to use an operand of boolean, numeric, or string type,
 4318 respectively.
 4319 </p>
 4320 
 4321 <p>
 4322 A constant <a href="#Comparison_operators">comparison</a> always yields
 4323 an untyped boolean constant.  If the left operand of a constant
 4324 <a href="#Operators">shift expression</a> is an untyped constant, the
 4325 result is an integer constant; otherwise it is a constant of the same
 4326 type as the left operand, which must be of
 4327 <a href="#Numeric_types">integer type</a>.
 4328 </p>
 4329 
 4330 <p>
 4331 Any other operation on untyped constants results in an untyped constant of the
 4332 same kind; that is, a boolean, integer, floating-point, complex, or string
 4333 constant.
 4334 If the untyped operands of a binary operation (other than a shift) are of
 4335 different kinds, the result is of the operand's kind that appears later in this
 4336 list: integer, rune, floating-point, complex.
 4337 For example, an untyped integer constant divided by an
 4338 untyped complex constant yields an untyped complex constant.
 4339 </p>
 4340 
 4341 <pre>
 4342 const a = 2 + 3.0          // a == 5.0   (untyped floating-point constant)
 4343 const b = 15 / 4           // b == 3     (untyped integer constant)
 4344 const c = 15 / 4.0         // c == 3.75  (untyped floating-point constant)
 4345 const Θ float64 = 3/2      // Θ == 1.0   (type float64, 3/2 is integer division)
 4346 const Π float64 = 3/2.     // Π == 1.5   (type float64, 3/2. is float division)
 4347 const d = 1 &lt;&lt; 3.0         // d == 8     (untyped integer constant)
 4348 const e = 1.0 &lt;&lt; 3         // e == 8     (untyped integer constant)
 4349 const f = int32(1) &lt;&lt; 33   // illegal    (constant 8589934592 overflows int32)
 4350 const g = float64(2) &gt;&gt; 1  // illegal    (float64(2) is a typed floating-point constant)
 4351 const h = "foo" &gt; "bar"    // h == true  (untyped boolean constant)
 4352 const j = true             // j == true  (untyped boolean constant)
 4353 const k = 'w' + 1          // k == 'x'   (untyped rune constant)
 4354 const l = "hi"             // l == "hi"  (untyped string constant)
 4355 const m = string(k)        // m == "x"   (type string)
 4356 const Σ = 1 - 0.707i       //            (untyped complex constant)
 4357 const Δ = Σ + 2.0e-4       //            (untyped complex constant)
 4358 const Φ = iota*1i - 1/1i   //            (untyped complex constant)
 4359 </pre>
 4360 
 4361 <p>
 4362 Applying the built-in function <code>complex</code> to untyped
 4363 integer, rune, or floating-point constants yields
 4364 an untyped complex constant.
 4365 </p>
 4366 
 4367 <pre>
 4368 const ic = complex(0, c)   // ic == 3.75i  (untyped complex constant)
 4369 const iΘ = complex(0, Θ)   // iΘ == 1i     (type complex128)
 4370 </pre>
 4371 
 4372 <p>
 4373 Constant expressions are always evaluated exactly; intermediate values and the
 4374 constants themselves may require precision significantly larger than supported
 4375 by any predeclared type in the language. The following are legal declarations:
 4376 </p>
 4377 
 4378 <pre>
 4379 const Huge = 1 &lt;&lt; 100         // Huge == 1267650600228229401496703205376  (untyped integer constant)
 4380 const Four int8 = Huge &gt;&gt; 98  // Four == 4                                (type int8)
 4381 </pre>
 4382 
 4383 <p>
 4384 The divisor of a constant division or remainder operation must not be zero:
 4385 </p>
 4386 
 4387 <pre>
 4388 3.14 / 0.0   // illegal: division by zero
 4389 </pre>
 4390 
 4391 <p>
 4392 The values of <i>typed</i> constants must always be accurately
 4393 <a href="#Representability">representable</a> by values
 4394 of the constant type. The following constant expressions are illegal:
 4395 </p>
 4396 
 4397 <pre>
 4398 uint(-1)     // -1 cannot be represented as a uint
 4399 int(3.14)    // 3.14 cannot be represented as an int
 4400 int64(Huge)  // 1267650600228229401496703205376 cannot be represented as an int64
 4401 Four * 300   // operand 300 cannot be represented as an int8 (type of Four)
 4402 Four * 100   // product 400 cannot be represented as an int8 (type of Four)
 4403 </pre>
 4404 
 4405 <p>
 4406 The mask used by the unary bitwise complement operator <code>^</code> matches
 4407 the rule for non-constants: the mask is all 1s for unsigned constants
 4408 and -1 for signed and untyped constants.
 4409 </p>
 4410 
 4411 <pre>
 4412 ^1         // untyped integer constant, equal to -2
 4413 uint8(^1)  // illegal: same as uint8(-2), -2 cannot be represented as a uint8
 4414 ^uint8(1)  // typed uint8 constant, same as 0xFF ^ uint8(1) = uint8(0xFE)
 4415 int8(^1)   // same as int8(-2)
 4416 ^int8(1)   // same as -1 ^ int8(1) = -2
 4417 </pre>
 4418 
 4419 <p>
 4420 Implementation restriction: A compiler may use rounding while
 4421 computing untyped floating-point or complex constant expressions; see
 4422 the implementation restriction in the section
 4423 on <a href="#Constants">constants</a>.  This rounding may cause a
 4424 floating-point constant expression to be invalid in an integer
 4425 context, even if it would be integral when calculated using infinite
 4426 precision, and vice versa.
 4427 </p>
 4428 
 4429 
 4430 <h3 id="Order_of_evaluation">Order of evaluation</h3>
 4431 
 4432 <p>
 4433 At package level, <a href="#Package_initialization">initialization dependencies</a>
 4434 determine the evaluation order of individual initialization expressions in
 4435 <a href="#Variable_declarations">variable declarations</a>.
 4436 Otherwise, when evaluating the <a href="#Operands">operands</a> of an
 4437 expression, assignment, or
 4438 <a href="#Return_statements">return statement</a>,
 4439 all function calls, method calls, and
 4440 communication operations are evaluated in lexical left-to-right
 4441 order.
 4442 </p>
 4443 
 4444 <p>
 4445 For example, in the (function-local) assignment
 4446 </p>
 4447 <pre>
 4448 y[f()], ok = g(h(), i()+x[j()], &lt;-c), k()
 4449 </pre>
 4450 <p>
 4451 the function calls and communication happen in the order
 4452 <code>f()</code>, <code>h()</code>, <code>i()</code>, <code>j()</code>,
 4453 <code>&lt;-c</code>, <code>g()</code>, and <code>k()</code>.
 4454 However, the order of those events compared to the evaluation
 4455 and indexing of <code>x</code> and the evaluation
 4456 of <code>y</code> is not specified.
 4457 </p>
 4458 
 4459 <pre>
 4460 a := 1
 4461 f := func() int { a++; return a }
 4462 x := []int{a, f()}            // x may be [1, 2] or [2, 2]: evaluation order between a and f() is not specified
 4463 m := map[int]int{a: 1, a: 2}  // m may be {2: 1} or {2: 2}: evaluation order between the two map assignments is not specified
 4464 n := map[int]int{a: f()}      // n may be {2: 3} or {3: 3}: evaluation order between the key and the value is not specified
 4465 </pre>
 4466 
 4467 <p>
 4468 At package level, initialization dependencies override the left-to-right rule
 4469 for individual initialization expressions, but not for operands within each
 4470 expression:
 4471 </p>
 4472 
 4473 <pre>
 4474 var a, b, c = f() + v(), g(), sqr(u()) + v()
 4475 
 4476 func f() int        { return c }
 4477 func g() int        { return a }
 4478 func sqr(x int) int { return x*x }
 4479 
 4480 // functions u and v are independent of all other variables and functions
 4481 </pre>
 4482 
 4483 <p>
 4484 The function calls happen in the order
 4485 <code>u()</code>, <code>sqr()</code>, <code>v()</code>,
 4486 <code>f()</code>, <code>v()</code>, and <code>g()</code>.
 4487 </p>
 4488 
 4489 <p>
 4490 Floating-point operations within a single expression are evaluated according to
 4491 the associativity of the operators.  Explicit parentheses affect the evaluation
 4492 by overriding the default associativity.
 4493 In the expression <code>x + (y + z)</code> the addition <code>y + z</code>
 4494 is performed before adding <code>x</code>.
 4495 </p>
 4496 
 4497 <h2 id="Statements">Statements</h2>
 4498 
 4499 <p>
 4500 Statements control execution.
 4501 </p>
 4502 
 4503 <pre class="ebnf">
 4504 Statement =
 4505     Declaration | LabeledStmt | SimpleStmt |
 4506     GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
 4507     FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
 4508     DeferStmt .
 4509 
 4510 SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt | Assignment | ShortVarDecl .
 4511 </pre>
 4512 
 4513 <h3 id="Terminating_statements">Terminating statements</h3>
 4514 
 4515 <p>
 4516 A <i>terminating statement</i> prevents execution of all statements that lexically
 4517 appear after it in the same <a href="#Blocks">block</a>. The following statements
 4518 are terminating:
 4519 </p>
 4520 
 4521 <ol>
 4522 <li>
 4523     A <a href="#Return_statements">"return"</a> or
 4524         <a href="#Goto_statements">"goto"</a> statement.
 4525     <!-- ul below only for regular layout -->
 4526     <ul> </ul>
 4527 </li>
 4528 
 4529 <li>
 4530     A call to the built-in function
 4531     <a href="#Handling_panics"><code>panic</code></a>.
 4532     <!-- ul below only for regular layout -->
 4533     <ul> </ul>
 4534 </li>
 4535 
 4536 <li>
 4537     A <a href="#Blocks">block</a> in which the statement list ends in a terminating statement.
 4538     <!-- ul below only for regular layout -->
 4539     <ul> </ul>
 4540 </li>
 4541 
 4542 <li>
 4543     An <a href="#If_statements">"if" statement</a> in which:
 4544     <ul>
 4545     <li>the "else" branch is present, and</li>
 4546     <li>both branches are terminating statements.</li>
 4547     </ul>
 4548 </li>
 4549 
 4550 <li>
 4551     A <a href="#For_statements">"for" statement</a> in which:
 4552     <ul>
 4553     <li>there are no "break" statements referring to the "for" statement, and</li>
 4554     <li>the loop condition is absent.</li>
 4555     </ul>
 4556 </li>
 4557 
 4558 <li>
 4559     A <a href="#Switch_statements">"switch" statement</a> in which:
 4560     <ul>
 4561     <li>there are no "break" statements referring to the "switch" statement,</li>
 4562     <li>there is a default case, and</li>
 4563     <li>the statement lists in each case, including the default, end in a terminating
 4564         statement, or a possibly labeled <a href="#Fallthrough_statements">"fallthrough"
 4565         statement</a>.</li>
 4566     </ul>
 4567 </li>
 4568 
 4569 <li>
 4570     A <a href="#Select_statements">"select" statement</a> in which:
 4571     <ul>
 4572     <li>there are no "break" statements referring to the "select" statement, and</li>
 4573     <li>the statement lists in each case, including the default if present,
 4574         end in a terminating statement.</li>
 4575     </ul>
 4576 </li>
 4577 
 4578 <li>
 4579     A <a href="#Labeled_statements">labeled statement</a> labeling
 4580     a terminating statement.
 4581 </li>
 4582 </ol>
 4583 
 4584 <p>
 4585 All other statements are not terminating.
 4586 </p>
 4587 
 4588 <p>
 4589 A <a href="#Blocks">statement list</a> ends in a terminating statement if the list
 4590 is not empty and its final non-empty statement is terminating.
 4591 </p>
 4592 
 4593 
 4594 <h3 id="Empty_statements">Empty statements</h3>
 4595 
 4596 <p>
 4597 The empty statement does nothing.
 4598 </p>
 4599 
 4600 <pre class="ebnf">
 4601 EmptyStmt = .
 4602 </pre>
 4603 
 4604 
 4605 <h3 id="Labeled_statements">Labeled statements</h3>
 4606 
 4607 <p>
 4608 A labeled statement may be the target of a <code>goto</code>,
 4609 <code>break</code> or <code>continue</code> statement.
 4610 </p>
 4611 
 4612 <pre class="ebnf">
 4613 LabeledStmt = Label ":" Statement .
 4614 Label       = identifier .
 4615 </pre>
 4616 
 4617 <pre>
 4618 Error: log.Panic("error encountered")
 4619 </pre>
 4620 
 4621 
 4622 <h3 id="Expression_statements">Expression statements</h3>
 4623 
 4624 <p>
 4625 With the exception of specific built-in functions,
 4626 function and method <a href="#Calls">calls</a> and
 4627 <a href="#Receive_operator">receive operations</a>
 4628 can appear in statement context. Such statements may be parenthesized.
 4629 </p>
 4630 
 4631 <pre class="ebnf">
 4632 ExpressionStmt = Expression .
 4633 </pre>
 4634 
 4635 <p>
 4636 The following built-in functions are not permitted in statement context:
 4637 </p>
 4638 
 4639 <pre>
 4640 append cap complex imag len make new real
 4641 unsafe.Alignof unsafe.Offsetof unsafe.Sizeof
 4642 </pre>
 4643 
 4644 <pre>
 4645 h(x+y)
 4646 f.Close()
 4647 &lt;-ch
 4648 (&lt;-ch)
 4649 len("foo")  // illegal if len is the built-in function
 4650 </pre>
 4651 
 4652 
 4653 <h3 id="Send_statements">Send statements</h3>
 4654 
 4655 <p>
 4656 A send statement sends a value on a channel.
 4657 The channel expression must be of <a href="#Channel_types">channel type</a>,
 4658 the channel direction must permit send operations,
 4659 and the type of the value to be sent must be <a href="#Assignability">assignable</a>
 4660 to the channel's element type.
 4661 </p>
 4662 
 4663 <pre class="ebnf">
 4664 SendStmt = Channel "&lt;-" Expression .
 4665 Channel  = Expression .
 4666 </pre>
 4667 
 4668 <p>
 4669 Both the channel and the value expression are evaluated before communication
 4670 begins. Communication blocks until the send can proceed.
 4671 A send on an unbuffered channel can proceed if a receiver is ready.
 4672 A send on a buffered channel can proceed if there is room in the buffer.
 4673 A send on a closed channel proceeds by causing a <a href="#Run_time_panics">run-time panic</a>.
 4674 A send on a <code>nil</code> channel blocks forever.
 4675 </p>
 4676 
 4677 <pre>
 4678 ch &lt;- 3  // send value 3 to channel ch
 4679 </pre>
 4680 
 4681 
 4682 <h3 id="IncDec_statements">IncDec statements</h3>
 4683 
 4684 <p>
 4685 The "++" and "--" statements increment or decrement their operands
 4686 by the untyped <a href="#Constants">constant</a> <code>1</code>.
 4687 As with an assignment, the operand must be <a href="#Address_operators">addressable</a>
 4688 or a map index expression.
 4689 </p>
 4690 
 4691 <pre class="ebnf">
 4692 IncDecStmt = Expression ( "++" | "--" ) .
 4693 </pre>
 4694 
 4695 <p>
 4696 The following <a href="#Assignments">assignment statements</a> are semantically
 4697 equivalent:
 4698 </p>
 4699 
 4700 <pre class="grammar">
 4701 IncDec statement    Assignment
 4702 x++                 x += 1
 4703 x--                 x -= 1
 4704 </pre>
 4705 
 4706 
 4707 <h3 id="Assignments">Assignments</h3>
 4708 
 4709 <pre class="ebnf">
 4710 Assignment = ExpressionList assign_op ExpressionList .
 4711 
 4712 assign_op = [ add_op | mul_op ] "=" .
 4713 </pre>
 4714 
 4715 <p>
 4716 Each left-hand side operand must be <a href="#Address_operators">addressable</a>,
 4717 a map index expression, or (for <code>=</code> assignments only) the
 4718 <a href="#Blank_identifier">blank identifier</a>.
 4719 Operands may be parenthesized.
 4720 </p>
 4721 
 4722 <pre>
 4723 x = 1
 4724 *p = f()
 4725 a[i] = 23
 4726 (k) = &lt;-ch  // same as: k = &lt;-ch
 4727 </pre>
 4728 
 4729 <p>
 4730 An <i>assignment operation</i> <code>x</code> <i>op</i><code>=</code>
 4731 <code>y</code> where <i>op</i> is a binary <a href="#Arithmetic_operators">arithmetic operator</a>
 4732 is equivalent to <code>x</code> <code>=</code> <code>x</code> <i>op</i>
 4733 <code>(y)</code> but evaluates <code>x</code>
 4734 only once.  The <i>op</i><code>=</code> construct is a single token.
 4735 In assignment operations, both the left- and right-hand expression lists
 4736 must contain exactly one single-valued expression, and the left-hand
 4737 expression must not be the blank identifier.
 4738 </p>
 4739 
 4740 <pre>
 4741 a[i] &lt;&lt;= 2
 4742 i &amp;^= 1&lt;&lt;n
 4743 </pre>
 4744 
 4745 <p>
 4746 A tuple assignment assigns the individual elements of a multi-valued
 4747 operation to a list of variables.  There are two forms.  In the
 4748 first, the right hand operand is a single multi-valued expression
 4749 such as a function call, a <a href="#Channel_types">channel</a> or
 4750 <a href="#Map_types">map</a> operation, or a <a href="#Type_assertions">type assertion</a>.
 4751 The number of operands on the left
 4752 hand side must match the number of values.  For instance, if
 4753 <code>f</code> is a function returning two values,
 4754 </p>
 4755 
 4756 <pre>
 4757 x, y = f()
 4758 </pre>
 4759 
 4760 <p>
 4761 assigns the first value to <code>x</code> and the second to <code>y</code>.
 4762 In the second form, the number of operands on the left must equal the number
 4763 of expressions on the right, each of which must be single-valued, and the
 4764 <i>n</i>th expression on the right is assigned to the <i>n</i>th
 4765 operand on the left:
 4766 </p>
 4767 
 4768 <pre>
 4769 one, two, three = '一', '二', '三'
 4770 </pre>
 4771 
 4772 <p>
 4773 The <a href="#Blank_identifier">blank identifier</a> provides a way to
 4774 ignore right-hand side values in an assignment:
 4775 </p>
 4776 
 4777 <pre>
 4778 _ = x       // evaluate x but ignore it
 4779 x, _ = f()  // evaluate f() but ignore second result value
 4780 </pre>
 4781 
 4782 <p>
 4783 The assignment proceeds in two phases.
 4784 First, the operands of <a href="#Index_expressions">index expressions</a>
 4785 and <a href="#Address_operators">pointer indirections</a>
 4786 (including implicit pointer indirections in <a href="#Selectors">selectors</a>)
 4787 on the left and the expressions on the right are all
 4788 <a href="#Order_of_evaluation">evaluated in the usual order</a>.
 4789 Second, the assignments are carried out in left-to-right order.
 4790 </p>
 4791 
 4792 <pre>
 4793 a, b = b, a  // exchange a and b
 4794 
 4795 x := []int{1, 2, 3}
 4796 i := 0
 4797 i, x[i] = 1, 2  // set i = 1, x[0] = 2
 4798 
 4799 i = 0
 4800 x[i], i = 2, 1  // set x[0] = 2, i = 1
 4801 
 4802 x[0], x[0] = 1, 2  // set x[0] = 1, then x[0] = 2 (so x[0] == 2 at end)
 4803 
 4804 x[1], x[3] = 4, 5  // set x[1] = 4, then panic setting x[3] = 5.
 4805 
 4806 type Point struct { x, y int }
 4807 var p *Point
 4808 x[2], p.x = 6, 7  // set x[2] = 6, then panic setting p.x = 7
 4809 
 4810 i = 2
 4811 x = []int{3, 5, 7}
 4812 for i, x[i] = range x {  // set i, x[2] = 0, x[0]
 4813     break
 4814 }
 4815 // after this loop, i == 0 and x == []int{3, 5, 3}
 4816 </pre>
 4817 
 4818 <p>
 4819 In assignments, each value must be <a href="#Assignability">assignable</a>
 4820 to the type of the operand to which it is assigned, with the following special cases:
 4821 </p>
 4822 
 4823 <ol>
 4824 <li>
 4825     Any typed value may be assigned to the blank identifier.
 4826 </li>
 4827 
 4828 <li>
 4829     If an untyped constant
 4830     is assigned to a variable of interface type or the blank identifier,
 4831     the constant is first implicitly <a href="#Conversions">converted</a> to its
 4832      <a href="#Constants">default type</a>.
 4833 </li>
 4834 
 4835 <li>
 4836     If an untyped boolean value is assigned to a variable of interface type or
 4837     the blank identifier, it is first implicitly converted to type <code>bool</code>.
 4838 </li>
 4839 </ol>
 4840 
 4841 <h3 id="If_statements">If statements</h3>
 4842 
 4843 <p>
 4844 "If" statements specify the conditional execution of two branches
 4845 according to the value of a boolean expression.  If the expression
 4846 evaluates to true, the "if" branch is executed, otherwise, if
 4847 present, the "else" branch is executed.
 4848 </p>
 4849 
 4850 <pre class="ebnf">
 4851 IfStmt = "if" [ SimpleStmt ";" ] Expression Block [ "else" ( IfStmt | Block ) ] .
 4852 </pre>
 4853 
 4854 <pre>
 4855 if x &gt; max {
 4856     x = max
 4857 }
 4858 </pre>
 4859 
 4860 <p>
 4861 The expression may be preceded by a simple statement, which
 4862 executes before the expression is evaluated.
 4863 </p>
 4864 
 4865 <pre>
 4866 if x := f(); x &lt; y {
 4867     return x
 4868 } else if x &gt; z {
 4869     return z
 4870 } else {
 4871     return y
 4872 }
 4873 </pre>
 4874 
 4875 
 4876 <h3 id="Switch_statements">Switch statements</h3>
 4877 
 4878 <p>
 4879 "Switch" statements provide multi-way execution.
 4880 An expression or type specifier is compared to the "cases"
 4881 inside the "switch" to determine which branch
 4882 to execute.
 4883 </p>
 4884 
 4885 <pre class="ebnf">
 4886 SwitchStmt = ExprSwitchStmt | TypeSwitchStmt .
 4887 </pre>
 4888 
 4889 <p>
 4890 There are two forms: expression switches and type switches.
 4891 In an expression switch, the cases contain expressions that are compared
 4892 against the value of the switch expression.
 4893 In a type switch, the cases contain types that are compared against the
 4894 type of a specially annotated switch expression.
 4895 The switch expression is evaluated exactly once in a switch statement.
 4896 </p>
 4897 
 4898 <h4 id="Expression_switches">Expression switches</h4>
 4899 
 4900 <p>
 4901 In an expression switch,
 4902 the switch expression is evaluated and
 4903 the case expressions, which need not be constants,
 4904 are evaluated left-to-right and top-to-bottom; the first one that equals the
 4905 switch expression
 4906 triggers execution of the statements of the associated case;
 4907 the other cases are skipped.
 4908 If no case matches and there is a "default" case,
 4909 its statements are executed.
 4910 There can be at most one default case and it may appear anywhere in the
 4911 "switch" statement.
 4912 A missing switch expression is equivalent to the boolean value
 4913 <code>true</code>.
 4914 </p>
 4915 
 4916 <pre class="ebnf">
 4917 ExprSwitchStmt = "switch" [ SimpleStmt ";" ] [ Expression ] "{" { ExprCaseClause } "}" .
 4918 ExprCaseClause = ExprSwitchCase ":" StatementList .
 4919 ExprSwitchCase = "case" ExpressionList | "default" .
 4920 </pre>
 4921 
 4922 <p>
 4923 If the switch expression evaluates to an untyped constant, it is first implicitly
 4924 <a href="#Conversions">converted</a> to its <a href="#Constants">default type</a>;
 4925 if it is an untyped boolean value, it is first implicitly converted to type <code>bool</code>.
 4926 The predeclared untyped value <code>nil</code> cannot be used as a switch expression.
 4927 </p>
 4928 
 4929 <p>
 4930 If a case expression is untyped, it is first implicitly <a href="#Conversions">converted</a>
 4931 to the type of the switch expression.
 4932 For each (possibly converted) case expression <code>x</code> and the value <code>t</code>
 4933 of the switch expression, <code>x == t</code> must be a valid <a href="#Comparison_operators">comparison</a>.
 4934 </p>
 4935 
 4936 <p>
 4937 In other words, the switch expression is treated as if it were used to declare and
 4938 initialize a temporary variable <code>t</code> without explicit type; it is that
 4939 value of <code>t</code> against which each case expression <code>x</code> is tested
 4940 for equality.
 4941 </p>
 4942 
 4943 <p>
 4944 In a case or default clause, the last non-empty statement
 4945 may be a (possibly <a href="#Labeled_statements">labeled</a>)
 4946 <a href="#Fallthrough_statements">"fallthrough" statement</a> to
 4947 indicate that control should flow from the end of this clause to
 4948 the first statement of the next clause.
 4949 Otherwise control flows to the end of the "switch" statement.
 4950 A "fallthrough" statement may appear as the last statement of all
 4951 but the last clause of an expression switch.
 4952 </p>
 4953 
 4954 <p>
 4955 The switch expression may be preceded by a simple statement, which
 4956 executes before the expression is evaluated.
 4957 </p>
 4958 
 4959 <pre>
 4960 switch tag {
 4961 default: s3()
 4962 case 0, 1, 2, 3: s1()
 4963 case 4, 5, 6, 7: s2()
 4964 }
 4965 
 4966 switch x := f(); {  // missing switch expression means "true"
 4967 case x &lt; 0: return -x
 4968 default: return x
 4969 }
 4970 
 4971 switch {
 4972 case x &lt; y: f1()
 4973 case x &lt; z: f2()
 4974 case x == 4: f3()
 4975 }
 4976 </pre>
 4977 
 4978 <p>
 4979 Implementation restriction: A compiler may disallow multiple case
 4980 expressions evaluating to the same constant.
 4981 For instance, the current compilers disallow duplicate integer,
 4982 floating point, or string constants in case expressions.
 4983 </p>
 4984 
 4985 <h4 id="Type_switches">Type switches</h4>
 4986 
 4987 <p>
 4988 A type switch compares types rather than values. It is otherwise similar
 4989 to an expression switch. It is marked by a special switch expression that
 4990 has the form of a <a href="#Type_assertions">type assertion</a>
 4991 using the reserved word <code>type</code> rather than an actual type:
 4992 </p>
 4993 
 4994 <pre>
 4995 switch x.(type) {
 4996 // cases
 4997 }
 4998 </pre>
 4999 
 5000 <p>
 5001 Cases then match actual types <code>T</code> against the dynamic type of the
 5002 expression <code>x</code>. As with type assertions, <code>x</code> must be of
 5003 <a href="#Interface_types">interface type</a>, and each non-interface type
 5004 <code>T</code> listed in a case must implement the type of <code>x</code>.
 5005 The types listed in the cases of a type switch must all be
 5006 <a href="#Type_identity">different</a>.
 5007 </p>
 5008 
 5009 <pre class="ebnf">
 5010 TypeSwitchStmt  = "switch" [ SimpleStmt ";" ] TypeSwitchGuard "{" { TypeCaseClause } "}" .
 5011 TypeSwitchGuard = [ identifier ":=" ] PrimaryExpr "." "(" "type" ")" .
 5012 TypeCaseClause  = TypeSwitchCase ":" StatementList .
 5013 TypeSwitchCase  = "case" TypeList | "default" .
 5014 TypeList        = Type { "," Type } .
 5015 </pre>
 5016 
 5017 <p>
 5018 The TypeSwitchGuard may include a
 5019 <a href="#Short_variable_declarations">short variable declaration</a>.
 5020 When that form is used, the variable is declared at the end of the
 5021 TypeSwitchCase in the <a href="#Blocks">implicit block</a> of each clause.
 5022 In clauses with a case listing exactly one type, the variable
 5023 has that type; otherwise, the variable has the type of the expression
 5024 in the TypeSwitchGuard.
 5025 </p>
 5026 
 5027 <p>
 5028 Instead of a type, a case may use the predeclared identifier
 5029 <a href="#Predeclared_identifiers"><code>nil</code></a>;
 5030 that case is selected when the expression in the TypeSwitchGuard
 5031 is a <code>nil</code> interface value.
 5032 There may be at most one <code>nil</code> case.
 5033 </p>
 5034 
 5035 <p>
 5036 Given an expression <code>x</code> of type <code>interface{}</code>,
 5037 the following type switch:
 5038 </p>
 5039 
 5040 <pre>
 5041 switch i := x.(type) {
 5042 case nil:
 5043     printString("x is nil")                // type of i is type of x (interface{})
 5044 case int:
 5045     printInt(i)                            // type of i is int
 5046 case float64:
 5047     printFloat64(i)                        // type of i is float64
 5048 case func(int) float64:
 5049     printFunction(i)                       // type of i is func(int) float64
 5050 case bool, string:
 5051     printString("type is bool or string")  // type of i is type of x (interface{})
 5052 default:
 5053     printString("don't know the type")     // type of i is type of x (interface{})
 5054 }
 5055 </pre>
 5056 
 5057 <p>
 5058 could be rewritten:
 5059 </p>
 5060 
 5061 <pre>
 5062 v := x  // x is evaluated exactly once
 5063 if v == nil {
 5064     i := v                                 // type of i is type of x (interface{})
 5065     printString("x is nil")
 5066 } else if i, isInt := v.(int); isInt {
 5067     printInt(i)                            // type of i is int
 5068 } else if i, isFloat64 := v.(float64); isFloat64 {
 5069     printFloat64(i)                        // type of i is float64
 5070 } else if i, isFunc := v.(func(int) float64); isFunc {
 5071     printFunction(i)                       // type of i is func(int) float64
 5072 } else {
 5073     _, isBool := v.(bool)
 5074     _, isString := v.(string)
 5075     if isBool || isString {
 5076         i := v                         // type of i is type of x (interface{})
 5077         printString("type is bool or string")
 5078     } else {
 5079         i := v                         // type of i is type of x (interface{})
 5080         printString("don't know the type")
 5081     }
 5082 }
 5083 </pre>
 5084 
 5085 <p>
 5086 The type switch guard may be preceded by a simple statement, which
 5087 executes before the guard is evaluated.
 5088 </p>
 5089 
 5090 <p>
 5091 The "fallthrough" statement is not permitted in a type switch.
 5092 </p>
 5093 
 5094 <h3 id="For_statements">For statements</h3>
 5095 
 5096 <p>
 5097 A "for" statement specifies repeated execution of a block. There are three forms:
 5098 The iteration may be controlled by a single condition, a "for" clause, or a "range" clause.
 5099 </p>
 5100 
 5101 <pre class="ebnf">
 5102 ForStmt = "for" [ Condition | ForClause | RangeClause ] Block .
 5103 Condition = Expression .
 5104 </pre>
 5105 
 5106 <h4 id="For_condition">For statements with single condition</h4>
 5107 
 5108 <p>
 5109 In its simplest form, a "for" statement specifies the repeated execution of
 5110 a block as long as a boolean condition evaluates to true.
 5111 The condition is evaluated before each iteration.
 5112 If the condition is absent, it is equivalent to the boolean value
 5113 <code>true</code>.
 5114 </p>
 5115 
 5116 <pre>
 5117 for a &lt; b {
 5118     a *= 2
 5119 }
 5120 </pre>
 5121 
 5122 <h4 id="For_clause">For statements with <code>for</code> clause</h4>
 5123 
 5124 <p>
 5125 A "for" statement with a ForClause is also controlled by its condition, but
 5126 additionally it may specify an <i>init</i>
 5127 and a <i>post</i> statement, such as an assignment,
 5128 an increment or decrement statement. The init statement may be a
 5129 <a href="#Short_variable_declarations">short variable declaration</a>, but the post statement must not.
 5130 Variables declared by the init statement are re-used in each iteration.
 5131 </p>
 5132 
 5133 <pre class="ebnf">
 5134 ForClause = [ InitStmt ] ";" [ Condition ] ";" [ PostStmt ] .
 5135 InitStmt = SimpleStmt .
 5136 PostStmt = SimpleStmt .
 5137 </pre>
 5138 
 5139 <pre>
 5140 for i := 0; i &lt; 10; i++ {
 5141     f(i)
 5142 }
 5143 </pre>
 5144 
 5145 <p>
 5146 If non-empty, the init statement is executed once before evaluating the
 5147 condition for the first iteration;
 5148 the post statement is executed after each execution of the block (and
 5149 only if the block was executed).
 5150 Any element of the ForClause may be empty but the
 5151 <a href="#Semicolons">semicolons</a> are
 5152 required unless there is only a condition.
 5153 If the condition is absent, it is equivalent to the boolean value
 5154 <code>true</code>.
 5155 </p>
 5156 
 5157 <pre>
 5158 for cond { S() }    is the same as    for ; cond ; { S() }
 5159 for      { S() }    is the same as    for true     { S() }
 5160 </pre>
 5161 
 5162 <h4 id="For_range">For statements with <code>range</code> clause</h4>
 5163 
 5164 <p>
 5165 A "for" statement with a "range" clause
 5166 iterates through all entries of an array, slice, string or map,
 5167 or values received on a channel. For each entry it assigns <i>iteration values</i>
 5168 to corresponding <i>iteration variables</i> if present and then executes the block.
 5169 </p>
 5170 
 5171 <pre class="ebnf">
 5172 RangeClause = [ ExpressionList "=" | IdentifierList ":=" ] "range" Expression .
 5173 </pre>
 5174 
 5175 <p>
 5176 The expression on the right in the "range" clause is called the <i>range expression</i>,
 5177 which may be an array, pointer to an array, slice, string, map, or channel permitting
 5178 <a href="#Receive_operator">receive operations</a>.
 5179 As with an assignment, if present the operands on the left must be
 5180 <a href="#Address_operators">addressable</a> or map index expressions; they
 5181 denote the iteration variables. If the range expression is a channel, at most
 5182 one iteration variable is permitted, otherwise there may be up to two.
 5183 If the last iteration variable is the <a href="#Blank_identifier">blank identifier</a>,
 5184 the range clause is equivalent to the same clause without that identifier.
 5185 </p>
 5186 
 5187 <p>
 5188 The range expression <code>x</code> is evaluated once before beginning the loop,
 5189 with one exception: if at most one iteration variable is present and
 5190 <code>len(x)</code> is <a href="#Length_and_capacity">constant</a>,
 5191 the range expression is not evaluated.
 5192 </p>
 5193 
 5194 <p>
 5195 Function calls on the left are evaluated once per iteration.
 5196 For each iteration, iteration values are produced as follows
 5197 if the respective iteration variables are present:
 5198 </p>
 5199 
 5200 <pre class="grammar">
 5201 Range expression                          1st value          2nd value
 5202 
 5203 array or slice  a  [n]E, *[n]E, or []E    index    i  int    a[i]       E
 5204 string          s  string type            index    i  int    see below  rune
 5205 map             m  map[K]V                key      k  K      m[k]       V
 5206 channel         c  chan E, &lt;-chan E       element  e  E
 5207 </pre>
 5208 
 5209 <ol>
 5210 <li>
 5211 For an array, pointer to array, or slice value <code>a</code>, the index iteration
 5212 values are produced in increasing order, starting at element index 0.
 5213 If at most one iteration variable is present, the range loop produces
 5214 iteration values from 0 up to <code>len(a)-1</code> and does not index into the array
 5215 or slice itself. For a <code>nil</code> slice, the number of iterations is 0.
 5216 </li>
 5217 
 5218 <li>
 5219 For a string value, the "range" clause iterates over the Unicode code points
 5220 in the string starting at byte index 0.  On successive iterations, the index value will be the
 5221 index of the first byte of successive UTF-8-encoded code points in the string,
 5222 and the second value, of type <code>rune</code>, will be the value of
 5223 the corresponding code point.  If the iteration encounters an invalid
 5224 UTF-8 sequence, the second value will be <code>0xFFFD</code>,
 5225 the Unicode replacement character, and the next iteration will advance
 5226 a single byte in the string.
 5227 </li>
 5228 
 5229 <li>
 5230 The iteration order over maps is not specified
 5231 and is not guaranteed to be the same from one iteration to the next.
 5232 If a map entry that has not yet been reached is removed during iteration,
 5233 the corresponding iteration value will not be produced. If a map entry is
 5234 created during iteration, that entry may be produced during the iteration or
 5235 may be skipped. The choice may vary for each entry created and from one
 5236 iteration to the next.
 5237 If the map is <code>nil</code>, the number of iterations is 0.
 5238 </li>
 5239 
 5240 <li>
 5241 For channels, the iteration values produced are the successive values sent on
 5242 the channel until the channel is <a href="#Close">closed</a>. If the channel
 5243 is <code>nil</code>, the range expression blocks forever.
 5244 </li>
 5245 </ol>
 5246 
 5247 <p>
 5248 The iteration values are assigned to the respective
 5249 iteration variables as in an <a href="#Assignments">assignment statement</a>.
 5250 </p>
 5251 
 5252 <p>
 5253 The iteration variables may be declared by the "range" clause using a form of
 5254 <a href="#Short_variable_declarations">short variable declaration</a>
 5255 (<code>:=</code>).
 5256 In this case their types are set to the types of the respective iteration values
 5257 and their <a href="#Declarations_and_scope">scope</a> is the block of the "for"
 5258 statement; they are re-used in each iteration.
 5259 If the iteration variables are declared outside the "for" statement,
 5260 after execution their values will be those of the last iteration.
 5261 </p>
 5262 
 5263 <pre>
 5264 var testdata *struct {
 5265     a *[7]int
 5266 }
 5267 for i, _ := range testdata.a {
 5268     // testdata.a is never evaluated; len(testdata.a) is constant
 5269     // i ranges from 0 to 6
 5270     f(i)
 5271 }
 5272 
 5273 var a [10]string
 5274 for i, s := range a {
 5275     // type of i is int
 5276     // type of s is string
 5277     // s == a[i]
 5278     g(i, s)
 5279 }
 5280 
 5281 var key string
 5282 var val interface{}  // element type of m is assignable to val
 5283 m := map[string]int{"mon":0, "tue":1, "wed":2, "thu":3, "fri":4, "sat":5, "sun":6}
 5284 for key, val = range m {
 5285     h(key, val)
 5286 }
 5287 // key == last map key encountered in iteration
 5288 // val == map[key]
 5289 
 5290 var ch chan Work = producer()
 5291 for w := range ch {
 5292     doWork(w)
 5293 }
 5294 
 5295 // empty a channel
 5296 for range ch {}
 5297 </pre>
 5298 
 5299 
 5300 <h3 id="Go_statements">Go statements</h3>
 5301 
 5302 <p>
 5303 A "go" statement starts the execution of a function call
 5304 as an independent concurrent thread of control, or <i>goroutine</i>,
 5305 within the same address space.
 5306 </p>
 5307 
 5308 <pre class="ebnf">
 5309 GoStmt = "go" Expression .
 5310 </pre>
 5311 
 5312 <p>
 5313 The expression must be a function or method call; it cannot be parenthesized.
 5314 Calls of built-in functions are restricted as for
 5315 <a href="#Expression_statements">expression statements</a>.
 5316 </p>
 5317 
 5318 <p>
 5319 The function value and parameters are
 5320 <a href="#Calls">evaluated as usual</a>
 5321 in the calling goroutine, but
 5322 unlike with a regular call, program execution does not wait
 5323 for the invoked function to complete.
 5324 Instead, the function begins executing independently
 5325 in a new goroutine.
 5326 When the function terminates, its goroutine also terminates.
 5327 If the function has any return values, they are discarded when the
 5328 function completes.
 5329 </p>
 5330 
 5331 <pre>
 5332 go Server()
 5333 go func(ch chan&lt;- bool) { for { sleep(10); ch &lt;- true }} (c)
 5334 </pre>
 5335 
 5336 
 5337 <h3 id="Select_statements">Select statements</h3>
 5338 
 5339 <p>
 5340 A "select" statement chooses which of a set of possible
 5341 <a href="#Send_statements">send</a> or
 5342 <a href="#Receive_operator">receive</a>
 5343 operations will proceed.
 5344 It looks similar to a
 5345 <a href="#Switch_statements">"switch"</a> statement but with the
 5346 cases all referring to communication operations.
 5347 </p>
 5348 
 5349 <pre class="ebnf">
 5350 SelectStmt = "select" "{" { CommClause } "}" .
 5351 CommClause = CommCase ":" StatementList .
 5352 CommCase   = "case" ( SendStmt | RecvStmt ) | "default" .
 5353 RecvStmt   = [ ExpressionList "=" | IdentifierList ":=" ] RecvExpr .
 5354 RecvExpr   = Expression .
 5355 </pre>
 5356 
 5357 <p>
 5358 A case with a RecvStmt may assign the result of a RecvExpr to one or
 5359 two variables, which may be declared using a
 5360 <a href="#Short_variable_declarations">short variable declaration</a>.
 5361 The RecvExpr must be a (possibly parenthesized) receive operation.
 5362 There can be at most one default case and it may appear anywhere
 5363 in the list of cases.
 5364 </p>
 5365 
 5366 <p>
 5367 Execution of a "select" statement proceeds in several steps:
 5368 </p>
 5369 
 5370 <ol>
 5371 <li>
 5372 For all the cases in the statement, the channel operands of receive operations
 5373 and the channel and right-hand-side expressions of send statements are
 5374 evaluated exactly once, in source order, upon entering the "select" statement.
 5375 The result is a set of channels to receive from or send to,
 5376 and the corresponding values to send.
 5377 Any side effects in that evaluation will occur irrespective of which (if any)
 5378 communication operation is selected to proceed.
 5379 Expressions on the left-hand side of a RecvStmt with a short variable declaration
 5380 or assignment are not yet evaluated.
 5381 </li>
 5382 
 5383 <li>
 5384 If one or more of the communications can proceed,
 5385 a single one that can proceed is chosen via a uniform pseudo-random selection.
 5386 Otherwise, if there is a default case, that case is chosen.
 5387 If there is no default case, the "select" statement blocks until
 5388 at least one of the communications can proceed.
 5389 </li>
 5390 
 5391 <li>
 5392 Unless the selected case is the default case, the respective communication
 5393 operation is executed.
 5394 </li>
 5395 
 5396 <li>
 5397 If the selected case is a RecvStmt with a short variable declaration or
 5398 an assignment, the left-hand side expressions are evaluated and the
 5399 received value (or values) are assigned.
 5400 </li>
 5401 
 5402 <li>
 5403 The statement list of the selected case is executed.
 5404 </li>
 5405 </ol>
 5406 
 5407 <p>
 5408 Since communication on <code>nil</code> channels can never proceed,
 5409 a select with only <code>nil</code> channels and no default case blocks forever.
 5410 </p>
 5411 
 5412 <pre>
 5413 var a []int
 5414 var c, c1, c2, c3, c4 chan int
 5415 var i1, i2 int
 5416 select {
 5417 case i1 = &lt;-c1:
 5418     print("received ", i1, " from c1\n")
 5419 case c2 &lt;- i2:
 5420     print("sent ", i2, " to c2\n")
 5421 case i3, ok := (&lt;-c3):  // same as: i3, ok := &lt;-c3
 5422     if ok {
 5423         print("received ", i3, " from c3\n")
 5424     } else {
 5425         print("c3 is closed\n")
 5426     }
 5427 case a[f()] = &lt;-c4:
 5428     // same as:
 5429     // case t := &lt;-c4
 5430     //  a[f()] = t
 5431 default:
 5432     print("no communication\n")
 5433 }
 5434 
 5435 for {  // send random sequence of bits to c
 5436     select {
 5437     case c &lt;- 0:  // note: no statement, no fallthrough, no folding of cases
 5438     case c &lt;- 1:
 5439     }
 5440 }
 5441 
 5442 select {}  // block forever
 5443 </pre>
 5444 
 5445 
 5446 <h3 id="Return_statements">Return statements</h3>
 5447 
 5448 <p>
 5449 A "return" statement in a function <code>F</code> terminates the execution
 5450 of <code>F</code>, and optionally provides one or more result values.
 5451 Any functions <a href="#Defer_statements">deferred</a> by <code>F</code>
 5452 are executed before <code>F</code> returns to its caller.
 5453 </p>
 5454 
 5455 <pre class="ebnf">
 5456 ReturnStmt = "return" [ ExpressionList ] .
 5457 </pre>
 5458 
 5459 <p>
 5460 In a function without a result type, a "return" statement must not
 5461 specify any result values.
 5462 </p>
 5463 <pre>
 5464 func noResult() {
 5465     return
 5466 }
 5467 </pre>
 5468 
 5469 <p>
 5470 There are three ways to return values from a function with a result
 5471 type:
 5472 </p>
 5473 
 5474 <ol>
 5475     <li>The return value or values may be explicitly listed
 5476         in the "return" statement. Each expression must be single-valued
 5477         and <a href="#Assignability">assignable</a>
 5478         to the corresponding element of the function's result type.
 5479 <pre>
 5480 func simpleF() int {
 5481     return 2
 5482 }
 5483 
 5484 func complexF1() (re float64, im float64) {
 5485     return -7.0, -4.0
 5486 }
 5487 </pre>
 5488     </li>
 5489     <li>The expression list in the "return" statement may be a single
 5490         call to a multi-valued function. The effect is as if each value
 5491         returned from that function were assigned to a temporary
 5492         variable with the type of the respective value, followed by a
 5493         "return" statement listing these variables, at which point the
 5494         rules of the previous case apply.
 5495 <pre>
 5496 func complexF2() (re float64, im float64) {
 5497     return complexF1()
 5498 }
 5499 </pre>
 5500     </li>
 5501     <li>The expression list may be empty if the function's result
 5502         type specifies names for its <a href="#Function_types">result parameters</a>.
 5503         The result parameters act as ordinary local variables
 5504         and the function may assign values to them as necessary.
 5505         The "return" statement returns the values of these variables.
 5506 <pre>
 5507 func complexF3() (re float64, im float64) {
 5508     re = 7.0
 5509     im = 4.0
 5510     return
 5511 }
 5512 
 5513 func (devnull) Write(p []byte) (n int, _ error) {
 5514     n = len(p)
 5515     return
 5516 }
 5517 </pre>
 5518     </li>
 5519 </ol>
 5520 
 5521 <p>
 5522 Regardless of how they are declared, all the result values are initialized to
 5523 the <a href="#The_zero_value">zero values</a> for their type upon entry to the
 5524 function. A "return" statement that specifies results sets the result parameters before
 5525 any deferred functions are executed.
 5526 </p>
 5527 
 5528 <p>
 5529 Implementation restriction: A compiler may disallow an empty expression list
 5530 in a "return" statement if a different entity (constant, type, or variable)
 5531 with the same name as a result parameter is in
 5532 <a href="#Declarations_and_scope">scope</a> at the place of the return.
 5533 </p>
 5534 
 5535 <pre>
 5536 func f(n int) (res int, err error) {
 5537     if _, err := f(n-1); err != nil {
 5538         return  // invalid return statement: err is shadowed
 5539     }
 5540     return
 5541 }
 5542 </pre>
 5543 
 5544 <h3 id="Break_statements">Break statements</h3>
 5545 
 5546 <p>
 5547 A "break" statement terminates execution of the innermost
 5548 <a href="#For_statements">"for"</a>,
 5549 <a href="#Switch_statements">"switch"</a>, or
 5550 <a href="#Select_statements">"select"</a> statement
 5551 within the same function.
 5552 </p>
 5553 
 5554 <pre class="ebnf">
 5555 BreakStmt = "break" [ Label ] .
 5556 </pre>
 5557 
 5558 <p>
 5559 If there is a label, it must be that of an enclosing
 5560 "for", "switch", or "select" statement,
 5561 and that is the one whose execution terminates.
 5562 </p>
 5563 
 5564 <pre>
 5565 OuterLoop:
 5566     for i = 0; i &lt; n; i++ {
 5567         for j = 0; j &lt; m; j++ {
 5568             switch a[i][j] {
 5569             case nil:
 5570                 state = Error
 5571                 break OuterLoop
 5572             case item:
 5573                 state = Found
 5574                 break OuterLoop
 5575             }
 5576         }
 5577     }
 5578 </pre>
 5579 
 5580 <h3 id="Continue_statements">Continue statements</h3>
 5581 
 5582 <p>
 5583 A "continue" statement begins the next iteration of the
 5584 innermost <a href="#For_statements">"for" loop</a> at its post statement.
 5585 The "for" loop must be within the same function.
 5586 </p>
 5587 
 5588 <pre class="ebnf">
 5589 ContinueStmt = "continue" [ Label ] .
 5590 </pre>
 5591 
 5592 <p>
 5593 If there is a label, it must be that of an enclosing
 5594 "for" statement, and that is the one whose execution
 5595 advances.
 5596 </p>
 5597 
 5598 <pre>
 5599 RowLoop:
 5600     for y, row := range rows {
 5601         for x, data := range row {
 5602             if data == endOfRow {
 5603                 continue RowLoop
 5604             }
 5605             row[x] = data + bias(x, y)
 5606         }
 5607     }
 5608 </pre>
 5609 
 5610 <h3 id="Goto_statements">Goto statements</h3>
 5611 
 5612 <p>
 5613 A "goto" statement transfers control to the statement with the corresponding label
 5614 within the same function.
 5615 </p>
 5616 
 5617 <pre class="ebnf">
 5618 GotoStmt = "goto" Label .
 5619 </pre>
 5620 
 5621 <pre>
 5622 goto Error
 5623 </pre>
 5624 
 5625 <p>
 5626 Executing the "goto" statement must not cause any variables to come into
 5627 <a href="#Declarations_and_scope">scope</a> that were not already in scope at the point of the goto.
 5628 For instance, this example:
 5629 </p>
 5630 
 5631 <pre>
 5632     goto L  // BAD
 5633     v := 3
 5634 L:
 5635 </pre>
 5636 
 5637 <p>
 5638 is erroneous because the jump to label <code>L</code> skips
 5639 the creation of <code>v</code>.
 5640 </p>
 5641 
 5642 <p>
 5643 A "goto" statement outside a <a href="#Blocks">block</a> cannot jump to a label inside that block.
 5644 For instance, this example:
 5645 </p>
 5646 
 5647 <pre>
 5648 if n%2 == 1 {
 5649     goto L1
 5650 }
 5651 for n &gt; 0 {
 5652     f()
 5653     n--
 5654 L1:
 5655     f()
 5656     n--
 5657 }
 5658 </pre>
 5659 
 5660 <p>
 5661 is erroneous because the label <code>L1</code> is inside
 5662 the "for" statement's block but the <code>goto</code> is not.
 5663 </p>
 5664 
 5665 <h3 id="Fallthrough_statements">Fallthrough statements</h3>
 5666 
 5667 <p>
 5668 A "fallthrough" statement transfers control to the first statement of the
 5669 next case clause in an <a href="#Expression_switches">expression "switch" statement</a>.
 5670 It may be used only as the final non-empty statement in such a clause.
 5671 </p>
 5672 
 5673 <pre class="ebnf">
 5674 FallthroughStmt = "fallthrough" .
 5675 </pre>
 5676 
 5677 
 5678 <h3 id="Defer_statements">Defer statements</h3>
 5679 
 5680 <p>
 5681 A "defer" statement invokes a function whose execution is deferred
 5682 to the moment the surrounding function returns, either because the
 5683 surrounding function executed a <a href="#Return_statements">return statement</a>,
 5684 reached the end of its <a href="#Function_declarations">function body</a>,
 5685 or because the corresponding goroutine is <a href="#Handling_panics">panicking</a>.
 5686 </p>
 5687 
 5688 <pre class="ebnf">
 5689 DeferStmt = "defer" Expression .
 5690 </pre>
 5691 
 5692 <p>
 5693 The expression must be a function or method call; it cannot be parenthesized.
 5694 Calls of built-in functions are restricted as for
 5695 <a href="#Expression_statements">expression statements</a>.
 5696 </p>
 5697 
 5698 <p>
 5699 Each time a "defer" statement
 5700 executes, the function value and parameters to the call are
 5701 <a href="#Calls">evaluated as usual</a>
 5702 and saved anew but the actual function is not invoked.
 5703 Instead, deferred functions are invoked immediately before
 5704 the surrounding function returns, in the reverse order
 5705 they were deferred. That is, if the surrounding function
 5706 returns through an explicit <a href="#Return_statements">return statement</a>,
 5707 deferred functions are executed <i>after</i> any result parameters are set
 5708 by that return statement but <i>before</i> the function returns to its caller.
 5709 If a deferred function value evaluates
 5710 to <code>nil</code>, execution <a href="#Handling_panics">panics</a>
 5711 when the function is invoked, not when the "defer" statement is executed.
 5712 </p>
 5713 
 5714 <p>
 5715 For instance, if the deferred function is
 5716 a <a href="#Function_literals">function literal</a> and the surrounding
 5717 function has <a href="#Function_types">named result parameters</a> that
 5718 are in scope within the literal, the deferred function may access and modify
 5719 the result parameters before they are returned.
 5720 If the deferred function has any return values, they are discarded when
 5721 the function completes.
 5722 (See also the section on <a href="#Handling_panics">handling panics</a>.)
 5723 </p>
 5724 
 5725 <pre>
 5726 lock(l)
 5727 defer unlock(l)  // unlocking happens before surrounding function returns
 5728 
 5729 // prints 3 2 1 0 before surrounding function returns
 5730 for i := 0; i &lt;= 3; i++ {
 5731     defer fmt.Print(i)
 5732 }
 5733 
 5734 // f returns 42
 5735 func f() (result int) {
 5736     defer func() {
 5737         // result is accessed after it was set to 6 by the return statement
 5738         result *= 7
 5739     }()
 5740     return 6
 5741 }
 5742 </pre>
 5743 
 5744 <h2 id="Built-in_functions">Built-in functions</h2>
 5745 
 5746 <p>
 5747 Built-in functions are
 5748 <a href="#Predeclared_identifiers">predeclared</a>.
 5749 They are called like any other function but some of them
 5750 accept a type instead of an expression as the first argument.
 5751 </p>
 5752 
 5753 <p>
 5754 The built-in functions do not have standard Go types,
 5755 so they can only appear in <a href="#Calls">call expressions</a>;
 5756 they cannot be used as function values.
 5757 </p>
 5758 
 5759 <h3 id="Close">Close</h3>
 5760 
 5761 <p>
 5762 For a channel <code>c</code>, the built-in function <code>close(c)</code>
 5763 records that no more values will be sent on the channel.
 5764 It is an error if <code>c</code> is a receive-only channel.
 5765 Sending to or closing a closed channel causes a <a href="#Run_time_panics">run-time panic</a>.
 5766 Closing the nil channel also causes a <a href="#Run_time_panics">run-time panic</a>.
 5767 After calling <code>close</code>, and after any previously
 5768 sent values have been received, receive operations will return
 5769 the zero value for the channel's type without blocking.
 5770 The multi-valued <a href="#Receive_operator">receive operation</a>
 5771 returns a received value along with an indication of whether the channel is closed.
 5772 </p>
 5773 
 5774 
 5775 <h3 id="Length_and_capacity">Length and capacity</h3>
 5776 
 5777 <p>
 5778 The built-in functions <code>len</code> and <code>cap</code> take arguments
 5779 of various types and return a result of type <code>int</code>.
 5780 The implementation guarantees that the result always fits into an <code>int</code>.
 5781 </p>
 5782 
 5783 <pre class="grammar">
 5784 Call      Argument type    Result
 5785 
 5786 len(s)    string type      string length in bytes
 5787           [n]T, *[n]T      array length (== n)
 5788           []T              slice length
 5789           map[K]T          map length (number of defined keys)
 5790           chan T           number of elements queued in channel buffer
 5791 
 5792 cap(s)    [n]T, *[n]T      array length (== n)
 5793           []T              slice capacity
 5794           chan T           channel buffer capacity
 5795 </pre>
 5796 
 5797 <p>
 5798 The capacity of a slice is the number of elements for which there is
 5799 space allocated in the underlying array.
 5800 At any time the following relationship holds:
 5801 </p>
 5802 
 5803 <pre>
 5804 0 &lt;= len(s) &lt;= cap(s)
 5805 </pre>
 5806 
 5807 <p>
 5808 The length of a <code>nil</code> slice, map or channel is 0.
 5809 The capacity of a <code>nil</code> slice or channel is 0.
 5810 </p>
 5811 
 5812 <p>
 5813 The expression <code>len(s)</code> is <a href="#Constants">constant</a> if
 5814 <code>s</code> is a string constant. The expressions <code>len(s)</code> and
 5815 <code>cap(s)</code> are constants if the type of <code>s</code> is an array
 5816 or pointer to an array and the expression <code>s</code> does not contain
 5817 <a href="#Receive_operator">channel receives</a> or (non-constant)
 5818 <a href="#Calls">function calls</a>; in this case <code>s</code> is not evaluated.
 5819 Otherwise, invocations of <code>len</code> and <code>cap</code> are not
 5820 constant and <code>s</code> is evaluated.
 5821 </p>
 5822 
 5823 <pre>
 5824 const (
 5825     c1 = imag(2i)                    // imag(2i) = 2.0 is a constant
 5826     c2 = len([10]float64{2})         // [10]float64{2} contains no function calls
 5827     c3 = len([10]float64{c1})        // [10]float64{c1} contains no function calls
 5828     c4 = len([10]float64{imag(2i)})  // imag(2i) is a constant and no function call is issued
 5829     c5 = len([10]float64{imag(z)})   // invalid: imag(z) is a (non-constant) function call
 5830 )
 5831 var z complex128
 5832 </pre>
 5833 
 5834 <h3 id="Allocation">Allocation</h3>
 5835 
 5836 <p>
 5837 The built-in function <code>new</code> takes a type <code>T</code>,
 5838 allocates storage for a <a href="#Variables">variable</a> of that type
 5839 at run time, and returns a value of type <code>*T</code>
 5840 <a href="#Pointer_types">pointing</a> to it.
 5841 The variable is initialized as described in the section on
 5842 <a href="#The_zero_value">initial values</a>.
 5843 </p>
 5844 
 5845 <pre class="grammar">
 5846 new(T)
 5847 </pre>
 5848 
 5849 <p>
 5850 For instance
 5851 </p>
 5852 
 5853 <pre>
 5854 type S struct { a int; b float64 }
 5855 new(S)
 5856 </pre>
 5857 
 5858 <p>
 5859 allocates storage for a variable of type <code>S</code>,
 5860 initializes it (<code>a=0</code>, <code>b=0.0</code>),
 5861 and returns a value of type <code>*S</code> containing the address
 5862 of the location.
 5863 </p>
 5864 
 5865 <h3 id="Making_slices_maps_and_channels">Making slices, maps and channels</h3>
 5866 
 5867 <p>
 5868 The built-in function <code>make</code> takes a type <code>T</code>,
 5869 which must be a slice, map or channel type,
 5870 optionally followed by a type-specific list of expressions.
 5871 It returns a value of type <code>T</code> (not <code>*T</code>).
 5872 The memory is initialized as described in the section on
 5873 <a href="#The_zero_value">initial values</a>.
 5874 </p>
 5875 
 5876 <pre class="grammar">
 5877 Call             Type T     Result
 5878 
 5879 make(T, n)       slice      slice of type T with length n and capacity n
 5880 make(T, n, m)    slice      slice of type T with length n and capacity m
 5881 
 5882 make(T)          map        map of type T
 5883 make(T, n)       map        map of type T with initial space for approximately n elements
 5884 
 5885 make(T)          channel    unbuffered channel of type T
 5886 make(T, n)       channel    buffered channel of type T, buffer size n
 5887 </pre>
 5888 
 5889 
 5890 <p>
 5891 Each of the size arguments <code>n</code> and <code>m</code> must be of integer type
 5892 or an untyped <a href="#Constants">constant</a>.
 5893 A constant size argument must be non-negative and <a href="#Representability">representable</a>
 5894 by a value of type <code>int</code>; if it is an untyped constant it is given type <code>int</code>.
 5895 If both <code>n</code> and <code>m</code> are provided and are constant, then
 5896 <code>n</code> must be no larger than <code>m</code>.
 5897 If <code>n</code> is negative or larger than <code>m</code> at run time,
 5898 a <a href="#Run_time_panics">run-time panic</a> occurs.
 5899 </p>
 5900 
 5901 <pre>
 5902 s := make([]int, 10, 100)       // slice with len(s) == 10, cap(s) == 100
 5903 s := make([]int, 1e3)           // slice with len(s) == cap(s) == 1000
 5904 s := make([]int, 1&lt;&lt;63)         // illegal: len(s) is not representable by a value of type int
 5905 s := make([]int, 10, 0)         // illegal: len(s) > cap(s)
 5906 c := make(chan int, 10)         // channel with a buffer size of 10
 5907 m := make(map[string]int, 100)  // map with initial space for approximately 100 elements
 5908 </pre>
 5909 
 5910 <p>
 5911 Calling <code>make</code> with a map type and size hint <code>n</code> will
 5912 create a map with initial space to hold <code>n</code> map elements.
 5913 The precise behavior is implementation-dependent.
 5914 </p>
 5915 
 5916 
 5917 <h3 id="Appending_and_copying_slices">Appending to and copying slices</h3>
 5918 
 5919 <p>
 5920 The built-in functions <code>append</code> and <code>copy</code> assist in
 5921 common slice operations.
 5922 For both functions, the result is independent of whether the memory referenced
 5923 by the arguments overlaps.
 5924 </p>
 5925 
 5926 <p>
 5927 The <a href="#Function_types">variadic</a> function <code>append</code>
 5928 appends zero or more values <code>x</code>
 5929 to <code>s</code> of type <code>S</code>, which must be a slice type, and
 5930 returns the resulting slice, also of type <code>S</code>.
 5931 The values <code>x</code> are passed to a parameter of type <code>...T</code>
 5932 where <code>T</code> is the <a href="#Slice_types">element type</a> of
 5933 <code>S</code> and the respective
 5934 <a href="#Passing_arguments_to_..._parameters">parameter passing rules</a> apply.
 5935 As a special case, <code>append</code> also accepts a first argument
 5936 assignable to type <code>[]byte</code> with a second argument of
 5937 string type followed by <code>...</code>. This form appends the
 5938 bytes of the string.
 5939 </p>
 5940 
 5941 <pre class="grammar">
 5942 append(s S, x ...T) S  // T is the element type of S
 5943 </pre>
 5944 
 5945 <p>
 5946 If the capacity of <code>s</code> is not large enough to fit the additional
 5947 values, <code>append</code> allocates a new, sufficiently large underlying
 5948 array that fits both the existing slice elements and the additional values.
 5949 Otherwise, <code>append</code> re-uses the underlying array.
 5950 </p>
 5951 
 5952 <pre>
 5953 s0 := []int{0, 0}
 5954 s1 := append(s0, 2)                // append a single element     s1 == []int{0, 0, 2}
 5955 s2 := append(s1, 3, 5, 7)          // append multiple elements    s2 == []int{0, 0, 2, 3, 5, 7}
 5956 s3 := append(s2, s0...)            // append a slice              s3 == []int{0, 0, 2, 3, 5, 7, 0, 0}
 5957 s4 := append(s3[3:6], s3[2:]...)   // append overlapping slice    s4 == []int{3, 5, 7, 2, 3, 5, 7, 0, 0}
 5958 
 5959 var t []interface{}
 5960 t = append(t, 42, 3.1415, "foo")   //                             t == []interface{}{42, 3.1415, "foo"}
 5961 
 5962 var b []byte
 5963 b = append(b, "bar"...)            // append string contents      b == []byte{'b', 'a', 'r' }
 5964 </pre>
 5965 
 5966 <p>
 5967 The function <code>copy</code> copies slice elements from
 5968 a source <code>src</code> to a destination <code>dst</code> and returns the
 5969 number of elements copied.
 5970 Both arguments must have <a href="#Type_identity">identical</a> element type <code>T</code> and must be
 5971 <a href="#Assignability">assignable</a> to a slice of type <code>[]T</code>.
 5972 The number of elements copied is the minimum of
 5973 <code>len(src)</code> and <code>len(dst)</code>.
 5974 As a special case, <code>copy</code> also accepts a destination argument assignable
 5975 to type <code>[]byte</code> with a source argument of a string type.
 5976 This form copies the bytes from the string into the byte slice.
 5977 </p>
 5978 
 5979 <pre class="grammar">
 5980 copy(dst, src []T) int
 5981 copy(dst []byte, src string) int
 5982 </pre>
 5983 
 5984 <p>
 5985 Examples:
 5986 </p>
 5987 
 5988 <pre>
 5989 var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
 5990 var s = make([]int, 6)
 5991 var b = make([]byte, 5)
 5992 n1 := copy(s, a[0:])            // n1 == 6, s == []int{0, 1, 2, 3, 4, 5}
 5993 n2 := copy(s, s[2:])            // n2 == 4, s == []int{2, 3, 4, 5, 4, 5}
 5994 n3 := copy(b, "Hello, World!")  // n3 == 5, b == []byte("Hello")
 5995 </pre>
 5996 
 5997 
 5998 <h3 id="Deletion_of_map_elements">Deletion of map elements</h3>
 5999 
 6000 <p>
 6001 The built-in function <code>delete</code> removes the element with key
 6002 <code>k</code> from a <a href="#Map_types">map</a> <code>m</code>. The
 6003 type of <code>k</code> must be <a href="#Assignability">assignable</a>
 6004 to the key type of <code>m</code>.
 6005 </p>
 6006 
 6007 <pre class="grammar">
 6008 delete(m, k)  // remove element m[k] from map m
 6009 </pre>
 6010 
 6011 <p>
 6012 If the map <code>m</code> is <code>nil</code> or the element <code>m[k]</code>
 6013 does not exist, <code>delete</code> is a no-op.
 6014 </p>
 6015 
 6016 
 6017 <h3 id="Complex_numbers">Manipulating complex numbers</h3>
 6018 
 6019 <p>
 6020 Three functions assemble and disassemble complex numbers.
 6021 The built-in function <code>complex</code> constructs a complex
 6022 value from a floating-point real and imaginary part, while
 6023 <code>real</code> and <code>imag</code>
 6024 extract the real and imaginary parts of a complex value.
 6025 </p>
 6026 
 6027 <pre class="grammar">
 6028 complex(realPart, imaginaryPart floatT) complexT
 6029 real(complexT) floatT
 6030 imag(complexT) floatT
 6031 </pre>
 6032 
 6033 <p>
 6034 The type of the arguments and return value correspond.
 6035 For <code>complex</code>, the two arguments must be of the same
 6036 floating-point type and the return type is the complex type
 6037 with the corresponding floating-point constituents:
 6038 <code>complex64</code> for <code>float32</code> arguments, and
 6039 <code>complex128</code> for <code>float64</code> arguments.
 6040 If one of the arguments evaluates to an untyped constant, it is first implicitly
 6041 <a href="#Conversions">converted</a> to the type of the other argument.
 6042 If both arguments evaluate to untyped constants, they must be non-complex
 6043 numbers or their imaginary parts must be zero, and the return value of
 6044 the function is an untyped complex constant.
 6045 </p>
 6046 
 6047 <p>
 6048 For <code>real</code> and <code>imag</code>, the argument must be
 6049 of complex type, and the return type is the corresponding floating-point
 6050 type: <code>float32</code> for a <code>complex64</code> argument, and
 6051 <code>float64</code> for a <code>complex128</code> argument.
 6052 If the argument evaluates to an untyped constant, it must be a number,
 6053 and the return value of the function is an untyped floating-point constant.
 6054 </p>
 6055 
 6056 <p>
 6057 The <code>real</code> and <code>imag</code> functions together form the inverse of
 6058 <code>complex</code>, so for a value <code>z</code> of a complex type <code>Z</code>,
 6059 <code>z&nbsp;==&nbsp;Z(complex(real(z),&nbsp;imag(z)))</code>.
 6060 </p>
 6061 
 6062 <p>
 6063 If the operands of these functions are all constants, the return
 6064 value is a constant.
 6065 </p>
 6066 
 6067 <pre>
 6068 var a = complex(2, -2)             // complex128
 6069 const b = complex(1.0, -1.4)       // untyped complex constant 1 - 1.4i
 6070 x := float32(math.Cos(math.Pi/2))  // float32
 6071 var c64 = complex(5, -x)           // complex64
 6072 var s int = complex(1, 0)          // untyped complex constant 1 + 0i can be converted to int
 6073 _ = complex(1, 2&lt;&lt;s)               // illegal: 2 assumes floating-point type, cannot shift
 6074 var rl = real(c64)                 // float32
 6075 var im = imag(a)                   // float64
 6076 const c = imag(b)                  // untyped constant -1.4
 6077 _ = imag(3 &lt;&lt; s)                   // illegal: 3 assumes complex type, cannot shift
 6078 </pre>
 6079 
 6080 <h3 id="Handling_panics">Handling panics</h3>
 6081 
 6082 <p> Two built-in functions, <code>panic</code> and <code>recover</code>,
 6083 assist in reporting and handling <a href="#Run_time_panics">run-time panics</a>
 6084 and program-defined error conditions.
 6085 </p>
 6086 
 6087 <pre class="grammar">
 6088 func panic(interface{})
 6089 func recover() interface{}
 6090 </pre>
 6091 
 6092 <p>
 6093 While executing a function <code>F</code>,
 6094 an explicit call to <code>panic</code> or a <a href="#Run_time_panics">run-time panic</a>
 6095 terminates the execution of <code>F</code>.
 6096 Any functions <a href="#Defer_statements">deferred</a> by <code>F</code>
 6097 are then executed as usual.
 6098 Next, any deferred functions run by <code>F's</code> caller are run,
 6099 and so on up to any deferred by the top-level function in the executing goroutine.
 6100 At that point, the program is terminated and the error
 6101 condition is reported, including the value of the argument to <code>panic</code>.
 6102 This termination sequence is called <i>panicking</i>.
 6103 </p>
 6104 
 6105 <pre>
 6106 panic(42)
 6107 panic("unreachable")
 6108 panic(Error("cannot parse"))
 6109 </pre>
 6110 
 6111 <p>
 6112 The <code>recover</code> function allows a program to manage behavior
 6113 of a panicking goroutine.
 6114 Suppose a function <code>G</code> defers a function <code>D</code> that calls
 6115 <code>recover</code> and a panic occurs in a function on the same goroutine in which <code>G</code>
 6116 is executing.
 6117 When the running of deferred functions reaches <code>D</code>,
 6118 the return value of <code>D</code>'s call to <code>recover</code> will be the value passed to the call of <code>panic</code>.
 6119 If <code>D</code> returns normally, without starting a new
 6120 <code>panic</code>, the panicking sequence stops. In that case,
 6121 the state of functions called between <code>G</code> and the call to <code>panic</code>
 6122 is discarded, and normal execution resumes.
 6123 Any functions deferred by <code>G</code> before <code>D</code> are then run and <code>G</code>'s
 6124 execution terminates by returning to its caller.
 6125 </p>
 6126 
 6127 <p>
 6128 The return value of <code>recover</code> is <code>nil</code> if any of the following conditions holds:
 6129 </p>
 6130 <ul>
 6131 <li>
 6132 <code>panic</code>'s argument was <code>nil</code>;
 6133 </li>
 6134 <li>
 6135 the goroutine is not panicking;
 6136 </li>
 6137 <li>
 6138 <code>recover</code> was not called directly by a deferred function.
 6139 </li>
 6140 </ul>
 6141 
 6142 <p>
 6143 The <code>protect</code> function in the example below invokes
 6144 the function argument <code>g</code> and protects callers from
 6145 run-time panics raised by <code>g</code>.
 6146 </p>
 6147 
 6148 <pre>
 6149 func protect(g func()) {
 6150     defer func() {
 6151         log.Println("done")  // Println executes normally even if there is a panic
 6152         if x := recover(); x != nil {
 6153             log.Printf("run time panic: %v", x)
 6154         }
 6155     }()
 6156     log.Println("start")
 6157     g()
 6158 }
 6159 </pre>
 6160 
 6161 
 6162 <h3 id="Bootstrapping">Bootstrapping</h3>
 6163 
 6164 <p>
 6165 Current implementations provide several built-in functions useful during
 6166 bootstrapping. These functions are documented for completeness but are not
 6167 guaranteed to stay in the language. They do not return a result.
 6168 </p>
 6169 
 6170 <pre class="grammar">
 6171 Function   Behavior
 6172 
 6173 print      prints all arguments; formatting of arguments is implementation-specific
 6174 println    like print but prints spaces between arguments and a newline at the end
 6175 </pre>
 6176 
 6177 <p>
 6178 Implementation restriction: <code>print</code> and <code>println</code> need not
 6179 accept arbitrary argument types, but printing of boolean, numeric, and string
 6180 <a href="#Types">types</a> must be supported.
 6181 </p>
 6182 
 6183 <h2 id="Packages">Packages</h2>
 6184 
 6185 <p>
 6186 Go programs are constructed by linking together <i>packages</i>.
 6187 A package in turn is constructed from one or more source files
 6188 that together declare constants, types, variables and functions
 6189 belonging to the package and which are accessible in all files
 6190 of the same package. Those elements may be
 6191 <a href="#Exported_identifiers">exported</a> and used in another package.
 6192 </p>
 6193 
 6194 <h3 id="Source_file_organization">Source file organization</h3>
 6195 
 6196 <p>
 6197 Each source file consists of a package clause defining the package
 6198 to which it belongs, followed by a possibly empty set of import
 6199 declarations that declare packages whose contents it wishes to use,
 6200 followed by a possibly empty set of declarations of functions,
 6201 types, variables, and constants.
 6202 </p>
 6203 
 6204 <pre class="ebnf">
 6205 SourceFile       = PackageClause ";" { ImportDecl ";" } { TopLevelDecl ";" } .
 6206 </pre>
 6207 
 6208 <h3 id="Package_clause">Package clause</h3>
 6209 
 6210 <p>
 6211 A package clause begins each source file and defines the package
 6212 to which the file belongs.
 6213 </p>
 6214 
 6215 <pre class="ebnf">
 6216 PackageClause  = "package" PackageName .
 6217 PackageName    = identifier .
 6218 </pre>
 6219 
 6220 <p>
 6221 The PackageName must not be the <a href="#Blank_identifier">blank identifier</a>.
 6222 </p>
 6223 
 6224 <pre>
 6225 package math
 6226 </pre>
 6227 
 6228 <p>
 6229 A set of files sharing the same PackageName form the implementation of a package.
 6230 An implementation may require that all source files for a package inhabit the same directory.
 6231 </p>
 6232 
 6233 <h3 id="Import_declarations">Import declarations</h3>
 6234 
 6235 <p>
 6236 An import declaration states that the source file containing the declaration
 6237 depends on functionality of the <i>imported</i> package
 6238 (<a href="#Program_initialization_and_execution">§Program initialization and execution</a>)
 6239 and enables access to <a href="#Exported_identifiers">exported</a> identifiers
 6240 of that package.
 6241 The import names an identifier (PackageName) to be used for access and an ImportPath
 6242 that specifies the package to be imported.
 6243 </p>
 6244 
 6245 <pre class="ebnf">
 6246 ImportDecl       = "import" ( ImportSpec | "(" { ImportSpec ";" } ")" ) .
 6247 ImportSpec       = [ "." | PackageName ] ImportPath .
 6248 ImportPath       = string_lit .
 6249 </pre>
 6250 
 6251 <p>
 6252 The PackageName is used in <a href="#Qualified_identifiers">qualified identifiers</a>
 6253 to access exported identifiers of the package within the importing source file.
 6254 It is declared in the <a href="#Blocks">file block</a>.
 6255 If the PackageName is omitted, it defaults to the identifier specified in the
 6256 <a href="#Package_clause">package clause</a> of the imported package.
 6257 If an explicit period (<code>.</code>) appears instead of a name, all the
 6258 package's exported identifiers declared in that package's
 6259 <a href="#Blocks">package block</a> will be declared in the importing source
 6260 file's file block and must be accessed without a qualifier.
 6261 </p>
 6262 
 6263 <p>
 6264 The interpretation of the ImportPath is implementation-dependent but
 6265 it is typically a substring of the full file name of the compiled
 6266 package and may be relative to a repository of installed packages.
 6267 </p>
 6268 
 6269 <p>
 6270 Implementation restriction: A compiler may restrict ImportPaths to
 6271 non-empty strings using only characters belonging to
 6272 <a href="https://www.unicode.org/versions/Unicode6.3.0/">Unicode's</a>
 6273 L, M, N, P, and S general categories (the Graphic characters without
 6274 spaces) and may also exclude the characters
 6275 <code>!"#$%&amp;'()*,:;&lt;=&gt;?[\]^`{|}</code>
 6276 and the Unicode replacement character U+FFFD.
 6277 </p>
 6278 
 6279 <p>
 6280 Assume we have compiled a package containing the package clause
 6281 <code>package math</code>, which exports function <code>Sin</code>, and
 6282 installed the compiled package in the file identified by
 6283 <code>"lib/math"</code>.
 6284 This table illustrates how <code>Sin</code> is accessed in files
 6285 that import the package after the
 6286 various types of import declaration.
 6287 </p>
 6288 
 6289 <pre class="grammar">
 6290 Import declaration          Local name of Sin
 6291 
 6292 import   "lib/math"         math.Sin
 6293 import m "lib/math"         m.Sin
 6294 import . "lib/math"         Sin
 6295 </pre>
 6296 
 6297 <p>
 6298 An import declaration declares a dependency relation between
 6299 the importing and imported package.
 6300 It is illegal for a package to import itself, directly or indirectly,
 6301 or to directly import a package without
 6302 referring to any of its exported identifiers. To import a package solely for
 6303 its side-effects (initialization), use the <a href="#Blank_identifier">blank</a>
 6304 identifier as explicit package name:
 6305 </p>
 6306 
 6307 <pre>
 6308 import _ "lib/math"
 6309 </pre>
 6310 
 6311 
 6312 <h3 id="An_example_package">An example package</h3>
 6313 
 6314 <p>
 6315 Here is a complete Go package that implements a concurrent prime sieve.
 6316 </p>
 6317 
 6318 <pre>
 6319 package main
 6320 
 6321 import "fmt"
 6322 
 6323 // Send the sequence 2, 3, 4, … to channel 'ch'.
 6324 func generate(ch chan&lt;- int) {
 6325     for i := 2; ; i++ {
 6326         ch &lt;- i  // Send 'i' to channel 'ch'.
 6327     }
 6328 }
 6329 
 6330 // Copy the values from channel 'src' to channel 'dst',
 6331 // removing those divisible by 'prime'.
 6332 func filter(src &lt;-chan int, dst chan&lt;- int, prime int) {
 6333     for i := range src {  // Loop over values received from 'src'.
 6334         if i%prime != 0 {
 6335             dst &lt;- i  // Send 'i' to channel 'dst'.
 6336         }
 6337     }
 6338 }
 6339 
 6340 // The prime sieve: Daisy-chain filter processes together.
 6341 func sieve() {
 6342     ch := make(chan int)  // Create a new channel.
 6343     go generate(ch)       // Start generate() as a subprocess.
 6344     for {
 6345         prime := &lt;-ch
 6346         fmt.Print(prime, "\n")
 6347         ch1 := make(chan int)
 6348         go filter(ch, ch1, prime)
 6349         ch = ch1
 6350     }
 6351 }
 6352 
 6353 func main() {
 6354     sieve()
 6355 }
 6356 </pre>
 6357 
 6358 <h2 id="Program_initialization_and_execution">Program initialization and execution</h2>
 6359 
 6360 <h3 id="The_zero_value">The zero value</h3>
 6361 <p>
 6362 When storage is allocated for a <a href="#Variables">variable</a>,
 6363 either through a declaration or a call of <code>new</code>, or when
 6364 a new value is created, either through a composite literal or a call
 6365 of <code>make</code>,
 6366 and no explicit initialization is provided, the variable or value is
 6367 given a default value.  Each element of such a variable or value is
 6368 set to the <i>zero value</i> for its type: <code>false</code> for booleans,
 6369 <code>0</code> for numeric types, <code>""</code>
 6370 for strings, and <code>nil</code> for pointers, functions, interfaces, slices, channels, and maps.
 6371 This initialization is done recursively, so for instance each element of an
 6372 array of structs will have its fields zeroed if no value is specified.
 6373 </p>
 6374 <p>
 6375 These two simple declarations are equivalent:
 6376 </p>
 6377 
 6378 <pre>
 6379 var i int
 6380 var i int = 0
 6381 </pre>
 6382 
 6383 <p>
 6384 After
 6385 </p>
 6386 
 6387 <pre>
 6388 type T struct { i int; f float64; next *T }
 6389 t := new(T)
 6390 </pre>
 6391 
 6392 <p>
 6393 the following holds:
 6394 </p>
 6395 
 6396 <pre>
 6397 t.i == 0
 6398 t.f == 0.0
 6399 t.next == nil
 6400 </pre>
 6401 
 6402 <p>
 6403 The same would also be true after
 6404 </p>
 6405 
 6406 <pre>
 6407 var t T
 6408 </pre>
 6409 
 6410 <h3 id="Package_initialization">Package initialization</h3>
 6411 
 6412 <p>
 6413 Within a package, package-level variable initialization proceeds stepwise,
 6414 with each step selecting the variable earliest in <i>declaration order</i>
 6415 which has no dependencies on uninitialized variables.
 6416 </p>
 6417 
 6418 <p>
 6419 More precisely, a package-level variable is considered <i>ready for
 6420 initialization</i> if it is not yet initialized and either has
 6421 no <a href="#Variable_declarations">initialization expression</a> or
 6422 its initialization expression has no <i>dependencies</i> on uninitialized variables.
 6423 Initialization proceeds by repeatedly initializing the next package-level
 6424 variable that is earliest in declaration order and ready for initialization,
 6425 until there are no variables ready for initialization.
 6426 </p>
 6427 
 6428 <p>
 6429 If any variables are still uninitialized when this
 6430 process ends, those variables are part of one or more initialization cycles,
 6431 and the program is not valid.
 6432 </p>
 6433 
 6434 <p>
 6435 Multiple variables on the left-hand side of a variable declaration initialized
 6436 by single (multi-valued) expression on the right-hand side are initialized
 6437 together: If any of the variables on the left-hand side is initialized, all
 6438 those variables are initialized in the same step.
 6439 </p>
 6440 
 6441 <pre>
 6442 var x = a
 6443 var a, b = f() // a and b are initialized together, before x is initialized
 6444 </pre>
 6445 
 6446 <p>
 6447 For the purpose of package initialization, <a href="#Blank_identifier">blank</a>
 6448 variables are treated like any other variables in declarations.
 6449 </p>
 6450 
 6451 <p>
 6452 The declaration order of variables declared in multiple files is determined
 6453 by the order in which the files are presented to the compiler: Variables
 6454 declared in the first file are declared before any of the variables declared
 6455 in the second file, and so on.
 6456 </p>
 6457 
 6458 <p>
 6459 Dependency analysis does not rely on the actual values of the
 6460 variables, only on lexical <i>references</i> to them in the source,
 6461 analyzed transitively. For instance, if a variable <code>x</code>'s
 6462 initialization expression refers to a function whose body refers to
 6463 variable <code>y</code> then <code>x</code> depends on <code>y</code>.
 6464 Specifically:
 6465 </p>
 6466 
 6467 <ul>
 6468 <li>
 6469 A reference to a variable or function is an identifier denoting that
 6470 variable or function.
 6471 </li>
 6472 
 6473 <li>
 6474 A reference to a method <code>m</code> is a
 6475 <a href="#Method_values">method value</a> or
 6476 <a href="#Method_expressions">method expression</a> of the form
 6477 <code>t.m</code>, where the (static) type of <code>t</code> is
 6478 not an interface type, and the method <code>m</code> is in the
 6479 <a href="#Method_sets">method set</a> of <code>t</code>.
 6480 It is immaterial whether the resulting function value
 6481 <code>t.m</code> is invoked.
 6482 </li>
 6483 
 6484 <li>
 6485 A variable, function, or method <code>x</code> depends on a variable
 6486 <code>y</code> if <code>x</code>'s initialization expression or body
 6487 (for functions and methods) contains a reference to <code>y</code>
 6488 or to a function or method that depends on <code>y</code>.
 6489 </li>
 6490 </ul>
 6491 
 6492 <p>
 6493 For example, given the declarations
 6494 </p>
 6495 
 6496 <pre>
 6497 var (
 6498     a = c + b  // == 9
 6499     b = f()    // == 4
 6500     c = f()    // == 5
 6501     d = 3      // == 5 after initialization has finished
 6502 )
 6503 
 6504 func f() int {
 6505     d++
 6506     return d
 6507 }
 6508 </pre>
 6509 
 6510 <p>
 6511 the initialization order is <code>d</code>, <code>b</code>, <code>c</code>, <code>a</code>.
 6512 Note that the order of subexpressions in initialization expressions is irrelevant:
 6513 <code>a = c + b</code> and <code>a = b + c</code> result in the same initialization
 6514 order in this example.
 6515 </p>
 6516 
 6517 <p>
 6518 Dependency analysis is performed per package; only references referring
 6519 to variables, functions, and (non-interface) methods declared in the current
 6520 package are considered. If other, hidden, data dependencies exists between
 6521 variables, the initialization order between those variables is unspecified.
 6522 </p>
 6523 
 6524 <p>
 6525 For instance, given the declarations
 6526 </p>
 6527 
 6528 <pre>
 6529 var x = I(T{}).ab()   // x has an undetected, hidden dependency on a and b
 6530 var _ = sideEffect()  // unrelated to x, a, or b
 6531 var a = b
 6532 var b = 42
 6533 
 6534 type I interface      { ab() []int }
 6535 type T struct{}
 6536 func (T) ab() []int   { return []int{a, b} }
 6537 </pre>
 6538 
 6539 <p>
 6540 the variable <code>a</code> will be initialized after <code>b</code> but
 6541 whether <code>x</code> is initialized before <code>b</code>, between
 6542 <code>b</code> and <code>a</code>, or after <code>a</code>, and
 6543 thus also the moment at which <code>sideEffect()</code> is called (before
 6544 or after <code>x</code> is initialized) is not specified.
 6545 </p>
 6546 
 6547 <p>
 6548 Variables may also be initialized using functions named <code>init</code>
 6549 declared in the package block, with no arguments and no result parameters.
 6550 </p>
 6551 
 6552 <pre>
 6553 func init() { … }
 6554 </pre>
 6555 
 6556 <p>
 6557 Multiple such functions may be defined per package, even within a single
 6558 source file. In the package block, the <code>init</code> identifier can
 6559 be used only to declare <code>init</code> functions, yet the identifier
 6560 itself is not <a href="#Declarations_and_scope">declared</a>. Thus
 6561 <code>init</code> functions cannot be referred to from anywhere
 6562 in a program.
 6563 </p>
 6564 
 6565 <p>
 6566 A package with no imports is initialized by assigning initial values
 6567 to all its package-level variables followed by calling all <code>init</code>
 6568 functions in the order they appear in the source, possibly in multiple files,
 6569 as presented to the compiler.
 6570 If a package has imports, the imported packages are initialized
 6571 before initializing the package itself. If multiple packages import
 6572 a package, the imported package will be initialized only once.
 6573 The importing of packages, by construction, guarantees that there
 6574 can be no cyclic initialization dependencies.
 6575 </p>
 6576 
 6577 <p>
 6578 Package initialization&mdash;variable initialization and the invocation of
 6579 <code>init</code> functions&mdash;happens in a single goroutine,
 6580 sequentially, one package at a time.
 6581 An <code>init</code> function may launch other goroutines, which can run
 6582 concurrently with the initialization code. However, initialization
 6583 always sequences
 6584 the <code>init</code> functions: it will not invoke the next one
 6585 until the previous one has returned.
 6586 </p>
 6587 
 6588 <p>
 6589 To ensure reproducible initialization behavior, build systems are encouraged
 6590 to present multiple files belonging to the same package in lexical file name
 6591 order to a compiler.
 6592 </p>
 6593 
 6594 
 6595 <h3 id="Program_execution">Program execution</h3>
 6596 <p>
 6597 A complete program is created by linking a single, unimported package
 6598 called the <i>main package</i> with all the packages it imports, transitively.
 6599 The main package must
 6600 have package name <code>main</code> and
 6601 declare a function <code>main</code> that takes no
 6602 arguments and returns no value.
 6603 </p>
 6604 
 6605 <pre>
 6606 func main() { … }
 6607 </pre>
 6608 
 6609 <p>
 6610 Program execution begins by initializing the main package and then
 6611 invoking the function <code>main</code>.
 6612 When that function invocation returns, the program exits.
 6613 It does not wait for other (non-<code>main</code>) goroutines to complete.
 6614 </p>
 6615 
 6616 <h2 id="Errors">Errors</h2>
 6617 
 6618 <p>
 6619 The predeclared type <code>error</code> is defined as
 6620 </p>
 6621 
 6622 <pre>
 6623 type error interface {
 6624     Error() string
 6625 }
 6626 </pre>
 6627 
 6628 <p>
 6629 It is the conventional interface for representing an error condition,
 6630 with the nil value representing no error.
 6631 For instance, a function to read data from a file might be defined:
 6632 </p>
 6633 
 6634 <pre>
 6635 func Read(f *File, b []byte) (n int, err error)
 6636 </pre>
 6637 
 6638 <h2 id="Run_time_panics">Run-time panics</h2>
 6639 
 6640 <p>
 6641 Execution errors such as attempting to index an array out
 6642 of bounds trigger a <i>run-time panic</i> equivalent to a call of
 6643 the built-in function <a href="#Handling_panics"><code>panic</code></a>
 6644 with a value of the implementation-defined interface type <code>runtime.Error</code>.
 6645 That type satisfies the predeclared interface type
 6646 <a href="#Errors"><code>error</code></a>.
 6647 The exact error values that
 6648 represent distinct run-time error conditions are unspecified.
 6649 </p>
 6650 
 6651 <pre>
 6652 package runtime
 6653 
 6654 type Error interface {
 6655     error
 6656     // and perhaps other methods
 6657 }
 6658 </pre>
 6659 
 6660 <h2 id="System_considerations">System considerations</h2>
 6661 
 6662 <h3 id="Package_unsafe">Package <code>unsafe</code></h3>
 6663 
 6664 <p>
 6665 The built-in package <code>unsafe</code>, known to the compiler
 6666 and accessible through the <a href="#Import_declarations">import path</a> <code>"unsafe"</code>,
 6667 provides facilities for low-level programming including operations
 6668 that violate the type system. A package using <code>unsafe</code>
 6669 must be vetted manually for type safety and may not be portable.
 6670 The package provides the following interface:
 6671 </p>
 6672 
 6673 <pre class="grammar">
 6674 package unsafe
 6675 
 6676 type ArbitraryType int  // shorthand for an arbitrary Go type; it is not a real type
 6677 type Pointer *ArbitraryType
 6678 
 6679 func Alignof(variable ArbitraryType) uintptr
 6680 func Offsetof(selector ArbitraryType) uintptr
 6681 func Sizeof(variable ArbitraryType) uintptr
 6682 </pre>
 6683 
 6684 <p>
 6685 A <code>Pointer</code> is a <a href="#Pointer_types">pointer type</a> but a <code>Pointer</code>
 6686 value may not be <a href="#Address_operators">dereferenced</a>.
 6687 Any pointer or value of <a href="#Types">underlying type</a> <code>uintptr</code> can be converted to
 6688 a type of underlying type <code>Pointer</code> and vice versa.
 6689 The effect of converting between <code>Pointer</code> and <code>uintptr</code> is implementation-defined.
 6690 </p>
 6691 
 6692 <pre>
 6693 var f float64
 6694 bits = *(*uint64)(unsafe.Pointer(&amp;f))
 6695 
 6696 type ptr unsafe.Pointer
 6697 bits = *(*uint64)(ptr(&amp;f))
 6698 
 6699 var p ptr = nil
 6700 </pre>
 6701 
 6702 <p>
 6703 The functions <code>Alignof</code> and <code>Sizeof</code> take an expression <code>x</code>
 6704 of any type and return the alignment or size, respectively, of a hypothetical variable <code>v</code>
 6705 as if <code>v</code> was declared via <code>var v = x</code>.
 6706 </p>
 6707 <p>
 6708 The function <code>Offsetof</code> takes a (possibly parenthesized) <a href="#Selectors">selector</a>
 6709 <code>s.f</code>, denoting a field <code>f</code> of the struct denoted by <code>s</code>
 6710 or <code>*s</code>, and returns the field offset in bytes relative to the struct's address.
 6711 If <code>f</code> is an <a href="#Struct_types">embedded field</a>, it must be reachable
 6712 without pointer indirections through fields of the struct.
 6713 For a struct <code>s</code> with field <code>f</code>:
 6714 </p>
 6715 
 6716 <pre>
 6717 uintptr(unsafe.Pointer(&amp;s)) + unsafe.Offsetof(s.f) == uintptr(unsafe.Pointer(&amp;s.f))
 6718 </pre>
 6719 
 6720 <p>
 6721 Computer architectures may require memory addresses to be <i>aligned</i>;
 6722 that is, for addresses of a variable to be a multiple of a factor,
 6723 the variable's type's <i>alignment</i>.  The function <code>Alignof</code>
 6724 takes an expression denoting a variable of any type and returns the
 6725 alignment of the (type of the) variable in bytes.  For a variable
 6726 <code>x</code>:
 6727 </p>
 6728 
 6729 <pre>
 6730 uintptr(unsafe.Pointer(&amp;x)) % unsafe.Alignof(x) == 0
 6731 </pre>
 6732 
 6733 <p>
 6734 Calls to <code>Alignof</code>, <code>Offsetof</code>, and
 6735 <code>Sizeof</code> are compile-time constant expressions of type <code>uintptr</code>.
 6736 </p>
 6737 
 6738 <h3 id="Size_and_alignment_guarantees">Size and alignment guarantees</h3>
 6739 
 6740 <p>
 6741 For the <a href="#Numeric_types">numeric types</a>, the following sizes are guaranteed:
 6742 </p>
 6743 
 6744 <pre class="grammar">
 6745 type                                 size in bytes
 6746 
 6747 byte, uint8, int8                     1
 6748 uint16, int16                         2
 6749 uint32, int32, float32                4
 6750 uint64, int64, float64, complex64     8
 6751 complex128                           16
 6752 </pre>
 6753 
 6754 <p>
 6755 The following minimal alignment properties are guaranteed:
 6756 </p>
 6757 <ol>
 6758 <li>For a variable <code>x</code> of any type: <code>unsafe.Alignof(x)</code> is at least 1.
 6759 </li>
 6760 
 6761 <li>For a variable <code>x</code> of struct type: <code>unsafe.Alignof(x)</code> is the largest of
 6762    all the values <code>unsafe.Alignof(x.f)</code> for each field <code>f</code> of <code>x</code>, but at least 1.
 6763 </li>
 6764 
 6765 <li>For a variable <code>x</code> of array type: <code>unsafe.Alignof(x)</code> is the same as
 6766     the alignment of a variable of the array's element type.
 6767 </li>
 6768 </ol>
 6769 
 6770 <p>
 6771 A struct or array type has size zero if it contains no fields (or elements, respectively) that have a size greater than zero. Two distinct zero-size variables may have the same address in memory.
 6772 </p>