Спецификация языка программирования Go

“The Go Programming Language Specification”

Introduction (Введение)

Это справочное руководство по языку программирования Go. Версию до Go1.18, без дженериков, можно найти здесь. Дополнительную информацию и другие документы можно найти на сайте go.dev

Go - это язык общего назначения, разработанный для системного программирования. Он сильно типизирован, имеет сборщик мусора, а также имеет явную поддержку параллельного программирования. Программы строятся из пакетов, свойства которых позволяют эффективно управлять зависимостями.

Синтаксис компактен и прост в разборе, что позволяет легко анализировать его с помощью автоматических инструментов, таких как интегрированные среды разработки.

Notation (Нотация)

Синтаксис задается с помощью варианта расширенной формы Бэкуса-Наура (EBNF):

Production  = production_name "=" [ Expression ] "." .
Expression  = Alternative { "|" Alternative } .
Alternative = Term { Term } .
Term        = production_name | token [ "…" token ] | Group | Option | Repetition .
Group       = "(" Expression ")" .
Option      = "[" Expression "]" .
Repetition  = "{" Expression "}" .

“Productions” (продукции) — это правила в формальной грамматике, которые описывают синтаксис языка Go.

Productions - это выражения, построенные из терминов и следующих операторов в порядке возрастания старшинства:

|   alternation
()  grouping
[]  option (0 or 1 times)
{}  repetition (0 to n times)

Для обозначения лексических (терминальных) лексем используются строчные имена, написанные строчными буквами. Нетерминалы обозначаются в CamelCase. Лексические лексемы заключаются в двойные кавычки "" или обратные кавычки ``.

Форма a ... b представляет собой набор символов от a до b в качестве альтернатив. Горизонтальное многоточие ... также используется в других местах спецификации для неформального обозначения различных перечислений или фрагментов кода, которые не уточняются далее. Символ ... (в отличие от трех символов …) не является лексемой языка Go.

Ссылка вида [Go 1.xx] указывает на то, что описанная функция языка (или какой-то ее аспект) была изменена или добавлена в версии языка 1.xx и поэтому для сборки требуется как минимум эта версия языка. Подробнее см. раздел со ссылками в приложении.

Source code representation (Представление исходного кода)

Исходный код - это текст Юникода, закодированный в UTF-8. Текст не канонизирован, поэтому одна точка кода с ударением отличается от того же символа, построенного из сочетания ударения и буквы; они рассматриваются как две точки кода. Для простоты в этом документе будет использоваться неквалифицированный термин “символ” для обозначения кодовой точки Юникода в исходном тексте.

Каждая кодовая точка является отдельной; например, прописные и строчные буквы - это разные символы.

Ограничение на реализацию: Для совместимости с другими инструментами компилятор может запретить использование символа NUL (U+0000) в исходном тексте.

Ограничение на реализацию: Для совместимости с другими инструментами компилятор может игнорировать метку порядка байтов в кодировке UTF-8 (U+FEFF), если она является первой точкой кода Юникода в исходном тексте. В любом другом месте исходного текста знак порядка байтов может быть запрещен.

Символы

Следующие термины используются для обозначения определенных категорий символов Unicode:

newline        = /* кодовая позиция Юникода U+000A */ .
unicode_char   = /* произвольная кодовая позиция  Юникода, кроме newline */ .
unicode_letter = /* кодовая позиция Юникода, отнесенная к категории "Буква" */ .
unicode_digit  = /* кодовая позиция Юникода, отнесенная к категории "Число, десятичная цифра" */ .```

В стандарте Юникод 8.0 в разделе 4.5 “Общая категория” определен набор категорий символов. Go рассматривает все символы в любой из буквенных категорий Lu, Ll, Lt, Lm или Lo как буквы Юникода, а символы в числовой категории Nd - как цифры Юникода.

Символы и числа

Символ подчеркивания _ (U+005F) считается строчной буквой.

letter        = unicode_letter | "_" .
decimal_digit = "0" … "9" .
binary_digit  = "0" | "1" .
octal_digit   = "0" … "7" .
hex_digit     = "0" … "9" | "A" … "F" | "a" … "f" .

Лексические элементы

Комментарии

Комментарии служат в качестве программной документации. Существует две формы:

1. Строчные комментарии начинаются с последовательности символов // и останавливаются в конце строки.
2. Общие комментарии начинаются с последовательности символов /* и заканчиваются первой последующей последовательностью символов */.

Комментарий не может начинаться внутри руны или строкового литерала, а также внутри комментария. Общий комментарий, не содержащий новых строк, действует как пробел. Любой другой комментарий действует как новая строка.

Токены

Токены составляют словарный запас языка Go. Существует четыре класса:

• идентификаторы (Identifiers),
• ключевые слова, (Keywords)
• операторы и пунктуация,
• литералы.

Пространство пробелов, образованное символами (U+0020), горизонтальных табуляций (U+0009), возвратов каретки (U+000D) и новых строк (U+000A), игнорируется, за исключением случаев, когда оно разделяет лексемы, которые в противном случае были бы объединены в одну лексему. Кроме того, новая строка или конец файла могут вызвать вставку точки с запятой.

При разбиении вводимого текста на лексемы следующей лексемой является самая длинная последовательность символов, образующая допустимую лексему.

Точки с запятой

Формальный синтаксис использует точки с запятой ";" в качестве терминаторов в ряде последовательности команд. Программы на Go могут опускать большинство этих точек с запятой, используя следующие два правила:

1. Когда ввод разбивается на токены, точка с запятой автоматически вставляется в поток токенов сразу после последнего токена строки, если этот токен

• идентификатор
• целое число, плавающая точка, мнимое число, руна или строковый литерал
• одно из ключевых слов break, continue, fallthrough или return
• один из операторов и пунктуации ++, –, ), ], или }.

2. Чтобы сложные операторы занимали одну строку, перед закрывающим оператором “)” или “}” можно опустить точку с запятой.

Чтобы отразить идиоматическое использование, в примерах кода в этом документе точки с запятой опускаются в соответствии с этими правилами.

(Идентификаторы) Identifiers

Идентификаторы называют программные объекты, такие как переменные и типы. Идентификатор - это последовательность из одной или нескольких букв и цифр. Первый символ в идентификаторе должен быть буквой.

identifier = letter { letter | unicode_digit } .

a
_x9
ThisVariableIsExported
αβ

Ключевые слова (Keywords)

Следующие ключевые слова зарезервированы и не могут быть использованы в качестве идентификаторов.

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

Операторы и пунктуация

Следующие последовательности символов представляют операторы (включая операторы присваивания) и пунктуацию:

+    &     +=    &=     &&    ==    !=    (    )
-    |     -=    |=     ||    <     <=    [    ]
*    ^     *=    ^=     <-    >     >=    {    }
/    <<    /=    <<=    ++    =     :=    ,    ;
%    >>    %=    >>=    --    !     ...   .    :
     &^          &^=

Целочисленные литералы

Целочисленный литерал - это последовательность цифр, представляющая целочисленную константу. Необязательный префикс задает недесятичное основание: 0b или 0B для двоичной системы, 0, 0o или 0O для восьмеричной и 0x или 0X для шестнадцатеричной [Go 1.13]. Одиночный 0 считается десятичным нулем. В шестнадцатеричных литералах буквы от a до f и от A до F обозначают значения от 10 до 15.

Для удобства чтения после базового префикса или между последовательными цифрами может стоять символ подчеркивания _; такое подчеркивание не меняет значения литерала.

int_lit        = decimal_lit | binary_lit | octal_lit | hex_lit .
decimal_lit    = "0" | ( "1" … "9" ) [ [ "_" ] decimal_digits ] .
binary_lit     = "0" ( "b" | "B" ) [ "_" ] binary_digits .
octal_lit      = "0" [ "o" | "O" ] [ "_" ] octal_digits .
hex_lit        = "0" ( "x" | "X" ) [ "_" ] hex_digits .

decimal_digits = decimal_digit { [ "_" ] decimal_digit } .
binary_digits  = binary_digit { [ "_" ] binary_digit } .
octal_digits   = octal_digit { [ "_" ] octal_digit } .
hex_digits     = hex_digit { [ "_" ] hex_digit } .

42
4_2
0600
0_600
0o600
0O600       // second character is capital letter 'O'
0xBadFace
0xBad_Face
0x_67_7a_2f_cc_40_c6
170141183460469231731687303715884105727
170_141183_460469_231731_687303_715884_105727

_42         // an identifier, not an integer literal
42_         // invalid: _ must separate successive digits
4__2        // invalid: only one _ at a time
0_xBadFace  // invalid: _ must separate successive digits

Литералы с плавающей точкой

Литерал с плавающей точкой - это десятичное или шестнадцатеричное представление константы с плавающей точкой.

Десятичный литерал с плавающей точкой состоит из целой части (десятичных цифр), десятичной точки, дробной части (десятичных цифр) и экспоненты (e или E, за которой следует необязательный знак и десятичные цифры). Одна из частей целого числа или дробная часть могут быть опущены; одна из десятичных точек или часть экспоненты могут быть опущены. Значение экспоненты exp увеличивает мантиссу (целую и дробную части) на (10^{exp}).

Шестнадцатеричный литерал с плавающей точкой состоит из префикса 0x или 0X, целой части (шестнадцатеричные цифры), точки радикса, дробной части (шестнадцатеричные цифры) и части экспоненты (p или P, за которой следует необязательный знак и десятичные цифры). Одна из частей целого числа или дробная часть могут быть опущены; точка радикса также может быть опущена, но часть экспоненты обязательна. (Этот синтаксис соответствует синтаксису, приведенному в IEEE 754-2008 §5.12.3.) Значение экспоненты exp увеличивает мантиссу (целую и дробную части) на (2^{exp}) [Go 1.13].

Для удобства чтения после базового префикса или между последовательными цифрами может стоять символ подчеркивания _; такое подчеркивание не меняет буквенного значения.

float_lit         = decimal_float_lit | hex_float_lit .

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

hex_float_lit     = "0" ( "x" | "X" ) hex_mantissa hex_exponent .
hex_mantissa      = [ "_" ] hex_digits "." [ hex_digits ] |
                    [ "_" ] hex_digits |
                    "." hex_digits .
hex_exponent      = ( "p" | "P" ) [ "+" | "-" ] decimal_digits .

0.
72.40
072.40       // == 72.40
2.71828
1.e+0
6.67428e-11
1E6
.25
.12345E+5
1_5.         // == 15.0
0.15e+0_2    // == 15.0

0x1p-2       // == 0.25
0x2.p10      // == 2048.0
0x1.Fp+0     // == 1.9375
0X.8p-0      // == 0.5
0X_1FFFP-16  // == 0.1249847412109375
0x15e-2      // == 0x15e - 2 (integer subtraction)

0x.p1        // invalid: mantissa has no digits
1p-2         // invalid: p exponent requires hexadecimal mantissa
0x1.5e-2     // invalid: hexadecimal mantissa requires p exponent
1_.5         // invalid: _ must separate successive digits
1._5         // invalid: _ must separate successive digits
1.5_e1       // invalid: _ must separate successive digits
1.5e_1       // invalid: _ must separate successive digits
1.5e1_       // invalid: _ must separate successive digits

Мнимые литералы (imaging)

Мнимый литерал представляет собой мнимую часть комплексной константы. Он состоит из целого литерала или литерала с плавающей точкой, за которым следует строчная буква i. Значение мнимого литерала - это значение соответствующего целого литерала или литерала с плавающей точкой, умноженное на мнимую единицу i [Go 1.13].

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

В целях обратной совместимости целая часть мнимого литерала, полностью состоящая из десятичных цифр (и, возможно, знаков подчеркивания), считается десятичным целым числом, даже если оно начинается с ведущего 0.

0i
0123i         // == 123i for backward-compatibility
0o123i        // == 0o123 * 1i == 83i
0xabci        // == 0xabc * 1i == 2748i
0.i
2.71828i
1.e+0i
6.67428e-11i
1E6i
.25i
.12345E+5i
0x1p-2i       // == 0x1p-2 * 1i == 0.25i

Литералы рун

Литерал руны представляет собой константу руны, целочисленное значение, идентифицирующее код Юникода. Рунический литерал выражается в виде одного или нескольких символов, заключенных в одинарные кавычки, как, например, 'x' или '\n'. Внутри кавычек может находиться любой символ, кроме новой строки и неэкранированной одинарной кавычки. Одиночный символ в кавычках представляет собой значение Unicode самого символа, а многосимвольные последовательности, начинающиеся с обратной косой черты, кодируют значения в различных форматах.

Простейшая форма представляет собой одиночный символ внутри кавычек; поскольку исходный текст Go - это символы Юникода, закодированные в UTF-8, несколько байтов в кодировке UTF-8 могут представлять одно целое значение.

Например, литерал 'a' содержит один байт, представляющий литерал a, Unicode U+0061, значение 0x61, а литерал 'ä' содержит два байта (0xc3 0xa4), представляющих литерал a-dieresis, U+00E4, значение 0xe4.

Несколько обратных косых черточек позволяют кодировать произвольные значения как ASCII-текст. Существует четыре способа представления целочисленного значения в виде числовой константы:

• \x с последующими ровно двумя шестнадцатеричными цифрами;
• \u с последующими ровно четырьмя шестнадцатеричными цифрами;
• \U с последующими ровно восемью шестнадцатеричными цифрами,
• и обычный обратный слеш \ с последующими ровно тремя восьмеричными цифрами.

В каждом случае значение литерала - это значение, представленное цифрами в соответствующем базисе.

Хотя все эти представления приводят к целому числу, они имеют разные диапазоны допустимых значений.

Октальные эскейпы должны представлять значение от 0 до 255 включительно. Шестнадцатеричные эскейпы удовлетворяют этому условию по своей конструкции. Эскапады \u и \U представляют кодовые точки Юникода, поэтому в них некоторые значения являются недопустимыми, в частности, значения выше 0x10FFFF и суррогатные половинки.

После обратной косой черты некоторые односимвольные эскейпы представляют специальные значения:

\a   U+0007 alert or bell
\b   U+0008 backspace
\f   U+000C form feed
\n   U+000A line feed or newline
\r   U+000D carriage return
\t   U+0009 horizontal tab
\v   U+000B vertical tab
\\   U+005C backslash
\'   U+0027 single quote  (valid escape only within rune literals)
\"   U+0022 double quote  (valid escape only within string literals)

Нераспознанный символ, следующий за обратной косой чертой в литерале руны, является незаконным.

rune_lit         = "'" ( unicode_value | byte_value ) "'" .
unicode_value    = unicode_char | little_u_value | big_u_value | escaped_char .
byte_value       = octal_byte_value | hex_byte_value .
octal_byte_value = `\` octal_digit octal_digit octal_digit .
hex_byte_value   = `\` "x" hex_digit hex_digit .
little_u_value   = `\` "u" hex_digit hex_digit hex_digit hex_digit .
big_u_value      = `\` "U" hex_digit hex_digit hex_digit hex_digit
                           hex_digit hex_digit hex_digit hex_digit .
escaped_char     = `\` ( "a" | "b" | "f" | "n" | "r" | "t" | "v" | `\` | "'" | `"` ) .

'a'
'ä'
'本'
'\t'
'\000'
'\007'
'\377'
'\x07'
'\xff'
'\u12e4'
'\U00101234'
'\''         // rune literal containing single quote character
'aa'         // illegal: too many characters
'\k'         // illegal: k is not recognized after a backslash
'\xa'        // illegal: too few hexadecimal digits
'\0'         // illegal: too few octal digits
'\400'       // illegal: octal value over 255
'\uDFFF'     // illegal: surrogate half
'\U00110000' // illegal: invalid Unicode code point

Строковые литералы

Строковый литерал представляет собой строковую константу, полученную в результате конкатенации последовательности символов. Существует две формы: необработанные строковые литералы и интерпретированные строковые литералы.

Необработанные строковые литералы - это последовательности символов между обратными кавычками, как в `foo`.

Внутри кавычек может находиться любой символ, кроме обратной кавычки. Значением сырого строкового литерала является строка, состоящая из неинтерпретированных (неявно UTF-8-кодированных) символов между кавычками; в частности, обратные косые черты не имеют специального значения, и строка может содержать новые строки. Символы возврата каретки ('\r') внутри необработанных строковых литералов отбрасываются из значения необработанной строки.

Интерпретируемые строковые литералы - это последовательности символов между двойными кавычками, как в слове “bar”. Внутри кавычек может появиться любой символ, кроме новой строки и двойной кавычки без сопровождения. Текст между кавычками образует значение литерала, при этом обратные косые черты интерпретируются так же, как и в рунных литералах (за исключением того, что \' является незаконным, а \" - законным), с теми же ограничениями. Трехзначные восьмеричные (\nnn) и двузначные шестнадцатеричные (\xnn) эскапады представляют отдельные байты результирующей строки; все остальные эскапады представляют (возможно, многобайтовую) кодировку UTF-8 отдельных символов. Таким образом, внутри строки литералы \377 и \xFF представляют один байт значения 0xFF=255, а ÿ, \u00FF, \U000000FF и \xc3\xbf представляют два байта 0xc3 0xbf кодировки UTF-8 символа U+00FF.

string_lit             = raw_string_lit | interpreted_string_lit .
raw_string_lit         = "`" { unicode_char | newline } "`" .
interpreted_string_lit = `"` { unicode_value | byte_value } `"` .

`abc`                // same as "abc"
`\n
\n`                  // same as "\\n\n\\n"
"\n"
"\""                 // same as `"`
"Hello, world!\n"
"日本語"
"\u65e5本\U00008a9e"
"\xff\u00FF"
"\uD800"             // illegal: surrogate half
"\U00110000"         // illegal: invalid Unicode code point

Все эти примеры представляют одну и ту же строку:

"日本語"                                 // UTF-8 input text
`日本語`                                 // UTF-8 input text as a raw literal
"\u65e5\u672c\u8a9e"                    // the explicit Unicode code points
"\U000065e5\U0000672c\U00008a9e"        // the explicit Unicode code points
"\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"  // the explicit UTF-8 bytes

Если исходный код представляет символ как две кодовые позиции, например, комбинированную форму, включающую ударение и букву, то при помещении в литерал руны результат будет ошибкой (это не одна кодовая позиция), а при помещении в строковый литерал - двумя кодовыми позициями.

Константы

Существуют булевы константы, рунные константы, целочисленные константы, константы с плавающей точкой, комплексные константы и строковые константы.

Руны, целые числа, константы с плавающей точкой и комплексные константы в совокупности называются числовыми константами.

Постоянное значение представлено руной, целым числом, плавающей точкой, мнимым или строковым литералом, идентификатором, обозначающим константу, постоянным выражением, преобразованием с результатом, являющимся константой, или значением результата некоторых встроенных функций, таких как min или max, применяемых к аргументам констант, unsafe.Sizeof, применяемых к определенным значениям, cap или len, применяемых к некоторым выражениям, real и imag, применяемых к комплексной константе, и complex, применяемых к числовым константам. Булевы истинностные значения представлены заранее объявленными константами true и false. Объявленный идентификатор iota обозначает целочисленную константу.

В общем случае комплексные константы являются одной из форм выражения констант и рассматриваются в этом разделе.

Числовые константы представляют собой точные значения произвольной точности и не переполняются. Следовательно, не существует констант, обозначающих отрицательный ноль, бесконечность и не-число по стандарту IEEE 754.

Константы могут быть типизированными или нетипизированными. Буквальные константы, true, false, iota, а также некоторые константные выражения, содержащие только нетипизированные операнды констант, являются нетипизированными.

Тип константы может быть задан явно при объявлении или преобразовании константы, или неявно при использовании в объявлении переменной, операторе присваивания или в качестве операнда в выражении. Если значение константы не может быть представлено как значение соответствующего типа, то это ошибка. Если тип является параметром типа, константа преобразуется в неконстантное значение параметра типа.

Ограничение на реализацию:

Хотя числовые константы имеют произвольную точность в языке, компилятор может реализовать их, используя внутреннее представление с ограниченной точностью. Тем не менее, каждая реализация должна:

• Представлять целочисленные константы не менее чем 256 битами.
• Представлять константы с плавающей точкой, включая части комплексной константы, с мантиссой не менее 256 бит и знаковой двоичной экспонентой не менее 16 бит.
• Указывать ошибку, если не может точно представить целую константу.
• Давать ошибку, если не может представить константу с плавающей точкой или комплексную константу из-за переполнения.
• Округлять до ближайшей представимой константы, если не может представить константу с плавающей точкой или комплексную константу из-за ограничений на точность.

Эти требования относятся как к литеральным константам, так и к результатам вычисления константных выражений.

Переменные

Переменная - это место хранения значения. Набор допустимых значений определяется типом переменной.

Объявление переменной или, для параметров и результатов функций, подпись объявления функции или литерала функции резервирует место для хранения именованной переменной. Вызов встроенной функции new или получение адреса составного литерала выделяет место для хранения переменной во время выполнения. На такую анонимную переменную ссылаются через (возможно, неявный) указатель.

Структурированные переменные типов array, slice и struct имеют элементы и поля, к которым можно обращаться по отдельности. Каждый такой элемент действует как переменная.

Статический тип (или просто тип) переменной - это тип, указанный в ее объявлении, тип, указанный в новом вызове или составном литерале, или тип элемента структурированной переменной. Переменные интерфейсного типа также имеют отдельный динамический тип, который представляет собой (неинтерфейсный) тип значения, присваиваемого переменной во время выполнения (если только это значение не является заранее объявленным идентификатором nil, который не имеет типа). Динамический тип может меняться в процессе выполнения, но значения, хранящиеся в интерфейсных переменных, всегда можно присвоить статическому типу переменной.

var x interface{}  // x is nil and has static type interface{}
var v *T           // v has value nil, static type *T
x = 42             // x has value 42 and dynamic type int
x = v              // x has value (*T)(nil) and dynamic type *T

Значение переменной можно получить, обратившись к ней в выражении; это самое последнее значение, присвоенное переменной. Если переменной еще не присвоено значение, ее значение равно нулю для ее типа.

Типы

Тип определяет набор значений вместе с операциями и методами, характерными для этих значений. Тип может обозначаться именем типа, если оно есть, за которым должны следовать аргументы типа, если тип является общим. Тип также может быть указан с помощью литерала типа, который составляет тип из существующих типов.

Type     = TypeName [ TypeArgs ] | TypeLit | "(" Type ")" .
TypeName = identifier | QualifiedIdent .
TypeArgs = "[" TypeList [ "," ] "]" .
TypeList = Type { "," Type } .
TypeLit  = ArrayType | StructType | PointerType | FunctionType | InterfaceType |
           SliceType | MapType | ChannelType .

Язык заранее объявляет некоторые имена типов. Другие вводятся с помощью деклараций типов или списков параметров типов. Составные типы - массив, структура, указатель, функция, интерфейс, фрагмент, карта и канальный тип - могут быть построены с помощью литералов типов.

Объявленные типы, определенные типы и параметры типов называются именованными типами. Псевдоним обозначает именованный тип, если тип, указанный в объявлении псевдонима, является именованным типом.

Boolean types (Булевы типы)

Булевый тип представляет собой набор булевых истинностных значений, обозначаемых заранее объявленными константами true и false. Предварительно объявленный булевский тип - bool; это определенный тип.

Numeric types (Числовые типы)

Целый, плавающий или комплексный тип представляет собой набор целых, плавающих или комплексных значений, соответственно. Все они называются числовыми типами. К заранее объявленным независимым от архитектуры числовым типам относятся:

uint8       the set of all unsigned  8-bit integers (0 to 255)
uint16      the set of all unsigned 16-bit integers (0 to 65535)
uint32      the set of all unsigned 32-bit integers (0 to 4294967295)
uint64      the set of all unsigned 64-bit integers (0 to 18446744073709551615)

int8        the set of all signed  8-bit integers (-128 to 127)
int16       the set of all signed 16-bit integers (-32768 to 32767)
int32       the set of all signed 32-bit integers (-2147483648 to 2147483647)
int64       the set of all signed 64-bit integers (-9223372036854775808 to 9223372036854775807)

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

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

byte        alias for uint8
rune        alias for int32

Значение n-битного целого числа имеет ширину n бит и представляется с помощью арифметики дополнения двойки.

Существует также набор предопределенных целочисленных типов с размерами, зависящими от реализации:

uint //32 или 64 бита
int //тот же размер, что и uint
uintptr //целое число без знака, достаточно большое для хранения неинтерпретированных битов значения указателя

Чтобы избежать проблем с переносимостью, все числовые типы являются определенными типами и, следовательно, отдельными, за исключением byte, который является псевдонимом для uint8, и rune, который является псевдонимом для int32. Явные преобразования требуются, когда различные числовые типы смешиваются в выражении или присваивании.

Например, int32 и int не являются одним и тем же типом, даже если они могут иметь одинаковый размер на определенной архитектуре.

String types (Строковые типы)

Строковый тип представляет собой набор строковых значений.

Строковое значение - это последовательность байтов (возможно, пустая). Количество байтов называется длиной строки и никогда не бывает отрицательным. Строки неизменяемы: после создания содержимое строки невозможно изменить. Объявленный тип строки - string; это определенный тип.

Длина строки s может быть определена с помощью встроенной функции len. Длина является константой времени компиляции, если строка является константой. Доступ к байтам строки осуществляется по целочисленным индексам от 0 до len(s)-1. Взятие адреса такого элемента недопустимо; если s[i] - это i-й байт строки, то &s[i] недопустимо.

Array types (Типы массивов)

Массив - это пронумерованная последовательность элементов одного типа, называемого типом элемента. Количество элементов называется длиной массива и никогда не бывает отрицательным.

ArrayType   = "[" ArrayLength "]" ElementType .
ArrayLength = Expression .
ElementType = Type .

Длина является частью типа массива; она должна быть оценена неотрицательной константой, представляемой значением типа int. Длину массива a можно узнать с помощью встроенной функции len. Элементы можно адресовать по целочисленным индексам от 0 до len(a)-1. Типы массивов всегда одномерны, но могут образовывать многомерные типы.

[32]byte
[2*N] struct { x, y int32 }
[1000]*float64
[3][5]int
[2][2][2]float64  // same as [2]([2]([2]float64))

Массив типа T не может иметь элемент типа T или типа, содержащего T в качестве компонента, прямо или косвенно, если эти содержащие типы являются только типами array или struct.

// недопустимые типы массивов
type (
T1 [10]T1 // тип элемента T1 - T1
T2 [10]struct{ f T2 }     // T2 содержит T2 как компонент struct
T3 [10]T4 // T3 содержит T3 как компонент struct в T4
T4 struct{ f T3 }         // T4 содержит T4 как компонент массива T3 в struct
)

// допустимые типы массивов
type (
T5 [10]*T5 // T5 содержит T5 как компонент указателя
T6 [10]func() T6 // T6 содержит T6 как компонент функции типа
T7 [10]struct{ f []T7 }   // T7 содержит T7 как компонент фрагмента в структуре
)

Slice types (Типы срезов)

Срез - это дескриптор для непрерывного сегмента нижележащего массива, который обеспечивает доступ к пронумерованной последовательности элементов из этого массива. Тип slice обозначает множество всех срезов массивов его типа элемента. Количество элементов называется длиной среза и никогда не бывает отрицательным. Значение неинициализированного среза равно nil.

SliceType = "[" "]" ElementType .

Длину фрагмента s можно определить с помощью встроенной функции len; в отличие от массивов, она может меняться в процессе выполнения. К элементам можно обращаться по целочисленным индексам от 0 до len(s)-1. Индекс фрагмента данного элемента может быть меньше, чем индекс того же элемента в нижележащем массиве.

Слайс, после инициализации, всегда связан с нижележащим массивом, в котором хранятся его элементы. Таким образом, фрагмент разделяет хранилище со своим массивом и с другими фрагментами того же массива; напротив, отдельные массивы всегда представляют собой отдельные хранилища.

Массив, лежащий в основе фрагмента, может простираться за пределы фрагмента. Емкость - это мера этой протяженности: она равна сумме длины среза и длины массива за пределами среза; срез длиной до этой емкости может быть создан путем нарезки нового среза из исходного среза. Вместимость среза a можно узнать с помощью встроенной функции cap(a).

Новое инициализированное значение среза для заданного типа элемента T можно создать с помощью встроенной функции make, которая принимает тип среза и параметры, указывающие длину и, опционально, емкость. При создании среза с помощью make всегда выделяется новый скрытый массив, на который ссылается возвращаемое значение среза. Иными словами, выполнение функции

make([]T, length, capacity)

дает тот же срез, что и выделение массива и его срез, поэтому эти два выражения эквивалентны:

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

Как и массивы, срезы всегда одномерны, но могут быть скомпонованы для создания объектов более высокой размерности. В массивах массивов внутренние массивы, по конструкции, всегда имеют одинаковую длину; однако в срезах срезов (или массивах срезов) внутренние длины могут динамически изменяться. Более того, внутренние срезы должны инициализироваться по отдельности.

Struct types (Типы структур)

Структура - это последовательность именованных элементов, называемых полями, каждый из которых имеет имя и тип. Имена полей могут быть заданы явно (IdentifierList) или неявно (EmbeddedField). Внутри структуры непустые имена полей должны быть уникальными.

StructType    = "struct" "{" { FieldDecl ";" } "}" .
FieldDecl     = (IdentifierList Type | EmbeddedField) [ Tag ] .
EmbeddedField = [ "*" ] TypeName .
Tag           = string_lit .

// Пустая структура.
struct {}

// Структура с 6 полями.
struct {
x, y int
u float32
_ float32 // подложка (пустышка)
A *[]int
F func()
}

Поле, объявленное с типом, но без явного имени поля, называется встроенным полем. Встроенное поле должно быть указано как имя типа T или как указатель на имя неинтерфейсного типа *T, причем сам T не может быть типом-указателем или параметром типа. Неквалифицированное имя типа выступает в качестве имени поля.

// Структура с четырьмя встроенными полями типов T1, *T2, P.T3 и *P.T4
struct {
	T1 // имя поля - T1
	*T2 // имя поля - T2
	P.T3 // имя поля - T3
	*P.T4 // имя поля - T4
	x, y int // имена полей - x и y
}

Следующее объявление является незаконным, поскольку имена полей должны быть уникальными в типе struct:

struct {
	T // конфликтует со встроенным полем *T и *P.T
	*T // конфликтует со встроенным полем T и *P.T
	*P.T // конфликтует со встроенным полем T и *T
}

Поле или метод f встроенного поля в структуре x называется продвинутым, если x.f является легальным селектором, обозначающим это поле или метод f.

Продвигаемые поля действуют как обычные поля структуры, за исключением того, что они не могут быть использованы в качестве имен полей в составных литералах структуры.

Если задан тип struct S и имя типа T, то продвигаемые методы включаются в набор методов struct следующим образом:

• Если S содержит встроенное поле T, то наборы методов S и *S оба включают продвигаемые методы с приемником T. Набор методов *S также включает продвигаемые методы с приемником *T.
• Если S содержит встроенное поле *T, то наборы методов S и *S оба включают продвигаемые методы с приемником T или *T.

За объявлением поля может следовать необязательный строковый литерал tag, который становится атрибутом для всех полей в соответствующем объявлении поля.

Пустая строка тега эквивалентна отсутствию тега. Теги становятся видимыми через интерфейс отражения и участвуют в идентификации типов для структур, но в остальном игнорируются.

struct {
	x, y float64 "" // пустая строка тега подобна отсутствующему тегу
	name string "в качестве тега допускается любая строка"
	_ [4]byte "Это не структурное поле"
}

// Структура, соответствующая буферу протокола TimeStamp.
// Строки тегов определяют номера полей буфера протокола;
// они следуют соглашению, изложенному в пакете reflect.
struct {
	microsec uint64 `protobuf: "1"`
	serverIP6 uint64 `protobuf: "2"`
}

Тип struct T не может содержать поле типа T или типа, содержащего T в качестве компонента, прямо или косвенно, если эти содержащие типы являются только типами array или struct.

// недопустимые типы структур
type (
	T1 struct{ T1 }            // T1 содержит поле T1
	T2 struct{ f [10]T2 }      // T2 содержит T2 как компонент массива
	T3 struct{ T4 }            // T3 содержит T3 как компонент массива в struct T4
	T4 struct{ f [10]T3 }      // T4 содержит T4 как компонент struct T3 в массиве
)

// допустимые типы struct
type (
	T5 struct{ f *T5 }         // T5 содержит T5 как компонент указателя
	T6 struct{ f func() T6 }   // T6 содержит T6 как компонент функции type
	T7 struct{ f [10][]T7 }    // T7 содержит T7 как компонент фрагмента массива
)

Pointer types (Типы указателей)

Тип указателя обозначает множество всех указателей на переменные данного типа, называемого базовым типом указателя. Значением неинициализированного указателя является nil.

PointerType = "*" BaseType .
BaseType    = Type .

*Point
*[4]int

Function types (Типы функций)

Тип функции обозначает множество всех функций с одинаковыми типами параметров и результатов. Значением неинициализированной переменной типа функции является nil.

FunctionType   = "func" Signature .
Signature      = Parameters [ Result ] .
Result         = Parameters | Type .
Parameters     = "(" [ ParameterList [ "," ] ] ")" .
ParameterList  = ParameterDecl { "," ParameterDecl } .
ParameterDecl  = [ IdentifierList ] [ "..." ] Type .

В списке параметров или результатов имена (IdentifierList) должны либо все присутствовать, либо все отсутствовать. Если они присутствуют, каждое имя обозначает один элемент (параметр или результат) указанного типа, и все непустые имена в сигнатуре должны быть уникальными. Если они отсутствуют, то каждый тип обозначает один элемент этого типа. Списки параметров и результатов всегда заключаются в круглые скобки, за исключением того, что если имеется ровно один безымянный результат, он может быть записан как тип без скобок.

Последний входящий параметр в сигнатуре функции может иметь тип с префиксом .... Функция с таким параметром называется переменной и может быть вызвана с нулем или более аргументов для этого параметра.

func()
func(x int) int
func(a, _ int, z float32) bool
func(a, b int, z float32) (bool)
func(prefix string, values ...int)
func(a, b int, z float64, opt ...interface{}) (success bool)
func(int, int, float64) (float64, *[]int)
func(n int) func(p *T)

Interface types (Типы интерфейсов)

Тип интерфейса определяет набор типов. Переменная интерфейсного типа может хранить значение любого типа, входящего в набор типов интерфейса. Считается, что такой тип реализует интерфейс. Значение неинициализированной переменной интерфейсного типа равно nil.

InterfaceType  = "interface" "{" { InterfaceElem ";" } "}" .
InterfaceElem  = MethodElem | TypeElem .
MethodElem     = MethodName Signature .
MethodName     = identifier .
TypeElem       = TypeTerm { "|" TypeTerm } .
TypeTerm       = Type | UnderlyingType .
UnderlyingType = "~" Type .

Тип интерфейса задается списком элементов интерфейса. Элемент интерфейса - это либо метод, либо элемент типа, где элемент типа - это объединение одного или нескольких терминов типа. Термин типа - это либо один тип, либо один базовый тип.

Основные интерфейсы

В своей самой простой форме интерфейс задает (возможно, пустой) список методов. Набор типов, определяемый таким интерфейсом, - это набор типов, реализующих все эти методы, а соответствующий набор методов состоит именно из методов, указанных интерфейсом. Интерфейсы, чьи наборы типов могут быть полностью определены списком методов, называются базовыми интерфейсами.

// Простой интерфейс File.
interface {
	Read([]byte) (int, error)
	Write([]byte) (int, error)
	Close() error
}

Имя каждого явно указанного метода должно быть уникальным и не пустым.

interface {
	String() string
	String() string  // ошибка: String не уникальна
	_(x int)         // ошибка: метод не должен иметь пустого имени
}

Интерфейс может быть реализован более чем одним типом. Например, если два типа S1 и S2 имеют набор методов

func (p T) Read(p []byte) (n int, err error)
func (p T) Write(p []byte) (n int, err error)
func (p T) Close() error

(где T обозначает S1 или S2), то интерфейс File реализуется как S1, так и S2, независимо от того, какие еще методы могут быть у S1 и S2.

Каждый тип, входящий в набор типов интерфейса, реализует этот интерфейс. Любой тип может реализовывать несколько различных интерфейсов. Например, все типы реализуют пустой интерфейс, который обозначает множество всех (неинтерфейсных) типов:

interface{}

Для удобства предопределенный тип any является псевдонимом для пустого интерфейса. [Go 1.18].

Аналогично, рассмотрим эту спецификацию интерфейса, которая появляется внутри объявления типа для определения интерфейса под названием Locker:

type Locker interface {
	Lock()
	Unlock()
}

Если S1 и S2 также реализуют

func (p T) Lock() { … }
func (p T) Unlock() { … }

они реализуют интерфейс Locker, а также интерфейс File.

Встроенные интерфейсы

В несколько более общей форме интерфейс T может использовать (возможно, квалифицированное) имя типа интерфейса E в качестве элемента интерфейса. Это называется встраиванием интерфейса E в T [Go 1.14]. Набор типов T - это пересечение наборов типов, определяемых явно объявленными методами T, и наборов типов встроенных интерфейсов T. Другими словами, набор типов T - это множество всех типов, реализующих все явно объявленные методы T, а также все методы E [Go 1.18].

type Reader interface {
	Read(p []byte) (n int, err error)
	Close() error
}

type Writer interface {
	Write(p []byte) (n int, err error)
	Close() error
}

// Методы ReadWriter - это Read, Write, и Close.
type ReadWriter interface {
	Reader  // includes methods of Reader in ReadWriter's method set
	Writer  // includes methods of Writer in ReadWriter's method set
}

При встраивании интерфейсов методы с одинаковыми именами должны иметь идентичные сигнатуры.

type ReadCloser interface {
	Reader   // includes methods of Reader in ReadCloser's method set
	Close()  // ошибка: сигнатуры Reader.Close и Close отличаются друг от друга
}

Общие интерфейсы

В самом общем виде элемент интерфейса может быть также термином произвольного типа T, или термином вида ~T, задающим базовый тип T, или объединением терминов t1|t2|...|tn [Go 1.18]. Вместе со спецификациями методов эти элементы позволяют точно определить набор типов интерфейса следующим образом:

• Набор типов пустого интерфейса - это набор всех типов, не входящих в интерфейс.
• Набор типов непустого интерфейса - это пересечение наборов типов его интерфейсных элементов.
• Набор типов спецификации метода - это набор всех неинтерфейсных типов, чьи наборы методов включают этот метод.
• Набор типов термина типа, не являющегося интерфейсом, - это множество, состоящее только из этого типа.
• Множество типов термина вида ~T - это множество всех типов, базовым типом которых является T.
• Множество типов объединения терминов t1|t2|...|tn - это объединение множеств типов этих терминов.

Квантификация “множество всех неинтерфейсных типов” относится не только ко всем (неинтерфейсным) типам, объявленным в рассматриваемой программе, но и ко всем возможным типам во всех возможных программах, и, следовательно, является бесконечной. Аналогично, если задано множество всех неинтерфейсных типов, реализующих определенный метод, то пересечение множеств методов этих типов будет содержать именно этот метод, даже если все типы в рассматриваемой программе всегда используют этот метод в паре с другим методом.

По конструкции, набор типов интерфейса никогда не содержит интерфейсного типа.

// Интерфейс, представляющий только тип int.
interface {
int
}

// Интерфейс, представляющий все типы с базовым типом int.
interface {
~int
}

// Интерфейс, представляющий все типы с базовым типом int, реализующие метод String.
interface {
~int
String() string
}

// Интерфейс, представляющий пустой набор типов: не существует типа, который был бы одновременно и int, и string.
interface {
int
string
}

В термине вида ~T базовым типом T должен быть он сам, и T не может быть интерфейсом.

type MyInt int

interface {
	~[]byte // базовым типом []byte является он сам
	~MyInt // ошибка: базовым типом MyInt не является MyInt
	~error // ошибка: ошибка является интерфейсом
}

Элементы Union обозначают объединения наборов типов:

// Интерфейс Float представляет все типы с плавающей точкой
// (включая любые именованные типы, базовыми типами которых являются
// либо float32, либо float64).
type Float interface {
	~float32 | ~float64
}

Тип T в термине вида T или ~T не может быть параметром типа, а наборы типов всех неинтерфейсных терминов должны быть попарно расходящимися (попарное пересечение наборов типов должно быть пустым). Если задан параметр типа P:

interface {
	P // ошибка: P является параметром типа
	int | ~P // ошибка: P является параметром типа
	~int | MyInt // ошибка: наборы типов для ~int и MyInt не разделяются (~int включает MyInt)
	float32 | Float // пересекающиеся наборы типов, но Float - это интерфейс
}

Ограничение на реализацию: Объединение (с более чем одним членом) не может содержать заранее объявленный идентификатор comparable или интерфейсов, определяющих методы, или встраивать comparable или интерфейсы, определяющие методы.

Интерфейсы, которые не являются базовыми, могут использоваться только как ограничения типов или как элементы других интерфейсов, используемых в качестве ограничений. Они не могут быть типами значений или переменных, или компонентами других, неинтерфейсных типов.

var x Float                     // illegal: Float is not a basic interface

var x interface{} = Float(nil)  // illegal

type Floatish struct {
	f Float                 // illegal
}

Интерфейсный тип T не может встраивать элемент типа, который является, содержит или встраивает T, прямо или косвенно.

// illegal: Bad не может встраивать себя
type Bad interface {
	Bad
}

// illegal: Bad1 не может встраивать себя, используя Bad2
type Bad1 interface {
	Bad2
}
type Bad2 interface {
	Bad1
}

// illegal: Bad3 не может встраивать объединение, содержащее Bad3
type Bad3 interface {
	~int | ~string | Bad3
}

// illegal: Bad4 не может встраивать массив, содержащий Bad4 в качестве элемента type
type Bad4 interface {
	[10]Bad4
}

Реализация интерфейса

Тип T реализует интерфейс I, если

• T не является интерфейсом и является элементом множества типов I; или
• T является интерфейсом и множество типов T является подмножеством множества типов I.

Значение типа T реализует интерфейс, если T реализует интерфейс.

Map types (Типы карт)

Карта - это неупорядоченная группа элементов одного типа, называемого типом элемента, индексируемых набором уникальных ключей другого типа, называемого типом ключа. Значением неинициализированной карты является nil.

MapType = "map" "[" KeyType "]" ElementType .
KeyType = Type .

Операторы сравнения == и != должны быть полностью определены для операндов типа ключа; таким образом, тип ключа не должен быть функцией, картой или срезом. Если тип ключа является типом интерфейса, эти операторы сравнения должны быть определены для динамических значений ключа; в противном случае произойдет паника во время выполнения.

map[string]int
map[*T]struct{ x, y float64 }
map[string]interface{}

Количество элементов карты называется ее длиной. Для карты m она может быть определена с помощью встроенной функции len и может меняться в процессе выполнения. Элементы могут добавляться в процессе выполнения с помощью присваиваний и извлекаться с помощью индексных выражений; они могут быть удалены с помощью встроенных функций delete и clear.

Новое, пустое значение карты создается с помощью встроенной функции make, которая принимает в качестве аргументов тип карты и необязательную подсказку емкости:

make(map[string]int)
make(map[string]int, 100)

Начальная емкость карты не ограничивает ее размер: карты растут по мере увеличения количества хранимых в них элементов, за исключением карт nil. Карта nil эквивалентна пустой карте, за исключением того, что никакие элементы не могут быть добавлены.

Channel types (Типы каналов)

Канал обеспечивает механизм взаимодействия параллельно выполняющихся функций, посылая и принимая значения определенного типа элементов. Значение неинициализированного канала равно nil.

ChannelType = ( "chan" | "chan" "<-" | "<-" "chan" ) ElementType .

Необязательный оператор <- задает направление канала, отправку или прием. Если указано направление, канал является направленным, в противном случае - двунаправленным. Канал может быть ограничен только на отправку или только на прием путем присваивания или явного преобразования.

chan T // может использоваться для отправки и получения значений типа T
chan <- float64 // может использоваться только для отправки float64
<-chan int // может использоваться только для получения ints

Оператор <- ассоциируется с самым левым возможным chan:

chan<- chan int // то же, что chan <- (chan int)
chan<- <-chan int // то же, что chan<- (<-chan int)
<-chan <-chan int // то же, что <-chan (<-chan int)
chan (<-chan int)

Новое инициализированное значение канала может быть создано с помощью встроенной функции make, которая принимает в качестве аргументов тип канала и необязательную емкость:

make(chan int, 100)

Емкость, выраженная в количестве элементов, задает размер буфера в канале. Если емкость равна нулю или отсутствует, канал является небуферизованным, и обмен данными происходит только тогда, когда отправитель и получатель готовы. В противном случае канал является буферизованным, и обмен данными происходит без блокировки, если буфер не заполнен (отправка) или не пуст (прием). Канал с нулевым значением никогда не готов к обмену данными.

Канал может быть закрыт с помощью встроенной функции close. Многозначная форма присваивания оператора receive сообщает, было ли полученное значение отправлено до того, как канал был закрыт.

Один канал может использоваться в операторах send, receive, вызовах встроенных функций cap и len любым количеством горутин без дополнительной синхронизации.

Каналы действуют как очереди “первым пришел - первым ушел”.

Например, если одна горутина отправляет значения по каналу, а вторая получает их, то значения будут получены в порядке отправки.

Свойства типов и значений

Представление значений

Значения предопределенных типов (см. ниже интерфейсы any и error), массивов и структур являются самодостаточными: Каждое такое значение содержит полную копию всех своих данных, а переменные таких типов хранят все значение.

Например, переменная массива обеспечивает хранение (переменных) для всех элементов массива. Соответствующие нулевые значения характерны для типов значений; они никогда не бывают нулевыми.

Ненулевые значения указателей, функций, фрагментов, карт и каналов содержат ссылки на базовые данные, которые могут быть общими для нескольких значений:

• Значение указателя - это ссылка на переменную, содержащую значение базового типа указателя.
• Значение функции содержит ссылки на (возможно, анонимную) функцию и вложенные переменные.
• Значение среза содержит длину среза, емкость и ссылку на его базовый массив.
• Значение карты или канала - это ссылка на специфическую для реализации структуру данных карты или канала.
• Значение интерфейса может быть самостоятельным или содержать ссылки на базовые данные в зависимости от динамического типа интерфейса. Объявленный идентификатор nil является нулевым значением для типов, значения которых могут содержать ссылки.

Когда несколько значений совместно используют базовые данные, изменение одного значения может изменить другое.

Например, изменение элемента среза приводит к изменению этого элемента в базовом массиве для всех срезов, разделяющих этот массив.

Базовые типы

Каждый тип T имеет базовый тип: Если T - один из предопределенных булевых, числовых или строковых типов или литерал типа, то соответствующий базовый тип - это сам T. В противном случае базовый тип T - это базовый тип типа, на который T ссылается в своем объявлении. Для параметра типа это базовый тип его ограничения типа, которое всегда является интерфейсом.

type (
	A1 = string
	A2 = A1
)

type (
	B1 string
	B2 B1
	B3 []B1
	B4 B3
)

func f[P any](x P) { … }

Базовым типом строк A1, A2, B1 и B2 является string. Базовым типом []B1, B3 и B4 является []B1. Базовым типом P является interface{}.

Основные типы

Каждый неинтерфейсный тип T имеет основной тип, который совпадает с базовым типом T.

Интерфейс T имеет основной тип, если выполняется одно из следующих условий:

1. Существует единственный тип U, который является базовым типом всех типов в наборе типов T; или
2. набор типов T содержит только типы каналов с идентичным типом элемента E, и все направленные каналы имеют одинаковое направление.

Никакие другие интерфейсы не имеют базового типа.

Основным типом интерфейса, в зависимости от выполняемого условия, является либо:

1. тип U; либо
2. тип chan E, если T содержит только двунаправленные каналы, либо тип chan<- E или <-chan E в зависимости от направления присутствующих направленных каналов.

По определению, основной тип никогда не является определенным типом, параметром типа или типом интерфейса.

Примеры интерфейсов с основными типами:

type Celsius float32
type Kelvin  float32

interface{ int }                          // int
interface{ Celsius|Kelvin }               // float32
interface{ ~chan int }                    // chan int
interface{ ~chan int|~chan<- int }        // chan<- int
interface{ ~[]*data; String() string }    // []*data

Примеры интерфейсов без основных типов:

interface{}                               // нет ни одного базового типа
interface{ Celsius|float64 }              // нет единого базового типа
interface{ chan int | chan<- string }     // каналы имеют разные типы элементов
interface{ <-chan int | chan<- int }      // направленные каналы имеют разные направления

Некоторые операции (выражения slice, append и copy) опираются на несколько более свободную форму основных типов, которые принимают байтовые фрагменты и строки. В частности, если существует ровно два типа, []byte и string, которые являются базовыми типами всех типов в наборе типов интерфейса T, то основной тип T называется bytestring.

Примеры интерфейсов с базовыми типами bytestring:

interface{ int }                          // int (то же, что и обычный основной тип)
interface{ []byte | string }              // bytestring
interface{ ~[]byte | myString }           // bytestring

Обратите внимание, что bytestring не является реальным типом; его нельзя использовать для объявления переменных или составления других типов. Он существует исключительно для описания поведения некоторых операций чтения из последовательности байтов, которая может быть байтовым фрагментом или строкой.

Идентичность типов

Два типа могут быть либо одинаковыми, либо разными.

Именованный тип всегда отличается от любого другого типа. В противном случае два типа идентичны, если их базовые литералы типов структурно эквивалентны; то есть они имеют одинаковую структуру литералов и соответствующие компоненты имеют одинаковые типы. Подробнее:

• Два типа массивов идентичны, если у них одинаковые типы элементов и одинаковая длина массива.
• Два типа slice идентичны, если у них одинаковые типы элементов.
• Два типа struct идентичны, если у них одинаковая последовательность полей, и если соответствующие пары полей имеют одинаковые имена, одинаковые типы и одинаковые теги, и либо оба встроены, либо оба не встроены. Имена неэкспортируемых полей из разных пакетов всегда различны.
• Два типа указателей идентичны, если у них одинаковые базовые типы.
• Два типа функций идентичны, если у них одинаковое количество параметров и значений результата, соответствующие типы параметров и результатов идентичны, и либо обе функции являются переменными, либо ни одна из них не является таковой. Имена параметров и результатов не обязаны совпадать.
• Два интерфейсных типа идентичны, если они определяют один и тот же набор типов.
• Два типа карт идентичны, если у них одинаковые типы ключей и элементов.
• Два типа каналов идентичны, если у них одинаковые типы элементов и одинаковое направление.
• Два инстанцированных типа идентичны, если их определенные типы и все аргументы типа идентичны.

Учитывая скаазанное:

type (
	A0 = []string
	A1 = A0
	A2 = struct{ a, b int }
	A3 = int
	A4 = func(A3, float64) *A0
	A5 = func(x int, _ float64) *[]string

	B0 A0
	B1 []string
	B2 struct{ a, b int }
	B3 struct{ a, c int }
	B4 func(int, float64) *B0
	B5 func(x int, y float64) *A1

	C0 = B0
	D0[P1, P2 any] struct{ x P1; y P2 }
	E0 = D0[int, string]
)

эти типы идентичны:

A0, A1, and []string
A2 and struct{ a, b int }
A3 and int
A4, func(int, float64) *[]string, and A5

B0 and C0
D0[int, string] and E0
[]int and []int
struct{ a, b *B5 } and struct{ a, b *B5 }
func(x int, y float64) *[]string, func(int, float64) (result *[]string), and A5

B0 и B1 отличаются, потому что это новые типы, созданные разными определениями типов; func(int, float64) *B0 и func(x int, y float64) *[]string отличаются, потому что B0 отличается от []string; а P1 и P2 отличаются, потому что это разные параметры типа. D0[int, string] и struct{ x int; y string } отличаются тем, что первый является инстанцированным определенным типом, а второй - литералом типа (но они все равно присваиваемые).

Назначаемость

Значение x типа V является назначаемым переменной типа T ("x является назначаемым T"), если выполняется одно из следующих условий:

1. V и T идентичны.
2. V и T имеют одинаковые базовые типы, но не являются параметрами типа, и хотя бы один из V или T не является именованным типом.
3. V и T - канальные типы с идентичными типами элементов, V - двунаправленный канал, и хотя бы один из V или T не является именованным типом.
4. T - интерфейсный тип, но не параметр типа, и x реализует T.
5. x - это объявленный идентификатор nil, а T - указатель, функция, фрагмент, карта, канал или интерфейсный тип, но не параметр типа.
6. x - это нетипизированная константа, представляемая значением типа T.

Кроме того, если для x тип V или T является параметром типа, x можно присвоить переменной типа T, если выполняется одно из следующих условий:

• x - предопределенный идентификатор nil, T - параметр типа, и x может быть присвоен каждому типу в наборе типов T.
• V не является именованным типом, T - параметр типа, и x может быть присвоен каждому типу в наборе типов T.
• V - параметр типа, T - не именованный тип, и значения каждого типа в наборе типов V могут быть присвоены T.

Представимость

Константа x представима значением типа T, где T не является параметром типа, если выполняется одно из следующих условий:

1. x находится в множестве значений, определяемых T.
2. T - тип с плавающей точкой, и x может быть округлена до точности T без переполнения. При округлении используются правила округления IEEE 754, но при этом отрицательный ноль IEEE упрощается до беззнакового нуля. Обратите внимание, что постоянные значения никогда не приводят к отрицательному нулю IEEE, NaN или бесконечности.
3. T - комплексный тип, и компоненты x - real(x) и imag(x) - могут быть представлены значениями типа компонента T (float32 или float64).

Если T - параметр типа, то x может быть представлен значением типа T, если x может быть представлен значением каждого типа в наборе типов T.

Наборы методов

Набор методов типа определяет методы, которые могут быть вызваны на операнде этого типа. Каждый тип имеет (или пустой) набор методов, связанный с ним:

1. Набор методов определенного типа T состоит из всех методов, объявленных для типа-приемника T.
2. Набор методов указателя на определенный тип T (где T не является ни указателем, ни интерфейсом) - это набор всех методов, объявленных с приемником *T или T.
3. Набор методов интерфейсного типа - это пересечение наборов методов каждого типа в наборе типов интерфейса (результирующий набор методов обычно представляет собой просто набор объявленных методов в интерфейсе).

К структурам (и указателям на структуры), содержащим встроенные поля, применяются дополнительные правила, описанные в разделе о типах struct. Любой другой тип имеет пустой набор методов.

В наборе методов каждый метод должен иметь уникальное непустое имя метода.

Blocks (Блоки)

Блок - это возможно пустая последовательность деклараций и утверждений, заключенных в соответствующие скобки.

Block = "{" StatementList "}" .
StatementList = { Statement ";" } .

Помимо явных блоков в исходном коде, существуют и неявные блоки:

1. Вселенский блок universe block включает в себя весь исходный текст Go.
2. Каждый пакет имеет package block блок пакета, содержащий весь исходный текст Go для этого пакета.
3. Каждый файл имеет file block блок файла, содержащий весь исходный текст Go в этом файле.
4. Каждый оператор “if”, “for” и “switch” считается находящимся в своем собственном неявном блоке.
5. Каждый пункт в операторе “switch” или “select” действует как неявный блок.

Блоки вложены друг в друга и влияют на область видимости.

Декларации и области видимости

Декларация связывает непустой идентификатор с константой, типом, параметром типа, переменной, функцией, меткой или пакетом. Каждый идентификатор в программе должен быть объявлен. Ни один идентификатор не может быть объявлен дважды в одном и том же блоке, и ни один идентификатор не может быть объявлен как в блоке файла, так и в блоке пакета.

Пустой идентификатор может использоваться как любой другой идентификатор в объявлении, но он не вводит привязку и поэтому не объявляется. В блоке пакетов идентификатор init может использоваться только для объявления функции init, и, как и пустой идентификатор, он не вводит нового связывания.

Declaration  = ConstDecl | TypeDecl | VarDecl .
TopLevelDecl = Declaration | FunctionDecl | MethodDecl .

Область видимости объявленного идентификатора - это часть исходного текста, в которой идентификатор обозначает указанную константу, тип, переменную, функцию, метку или пакет.

В Go лексическая область видимости определяется с помощью блоков:

1. Область видимости заранее объявленного идентификатора - это блок universe (вселенной).
2. Областью видимости идентификатора, обозначающего константу, тип, переменную или функцию (но не метод), объявленную на верхнем уровне (вне любой функции), является блок package.
3. Областью видимости имени импортируемого пакета является блок файла, содержащий объявление импорта.
4. Областью видимости идентификатора, обозначающего приемник метода, параметр функции или переменную результата, является тело функции.
5. Область видимости идентификатора, обозначающего параметр типа функции или объявленный приемником метода, начинается после имени функции и заканчивается в конце тела функции.
6. Область видимости идентификатора, обозначающего параметр типа, начинается после имени типа и заканчивается в конце TypeSpec.
7. Область видимости идентификатора константы или переменной, объявленной внутри функции, начинается в конце ConstSpec или VarSpec (ShortVarDecl для объявлений коротких переменных) и заканчивается в конце самого внутреннего содержащего блока.
8. Область видимости идентификатора типа, объявленного внутри функции, начинается с идентификатора в TypeSpec и заканчивается в конце самого внутреннего содержащего блока.

Идентификатор, объявленный в блоке, может быть повторно объявлен во внутреннем блоке. Пока идентификатор внутреннего объявления находится в области видимости, он обозначает объект, объявленный внутренним объявлением.

Клаузула package не является объявлением; имя пакета не появляется ни в какой области видимости. Его назначение - идентифицировать файлы, принадлежащие одному пакету, и указать имя пакета по умолчанию для объявлений импорта.

Области применения меток

Метки объявляются в операторах с метками и используются в операторах “break”, “continue” и “goto”. Запрещено определять метку, которая никогда не используется. В отличие от других идентификаторов, метки не имеют блочного диапазона и не конфликтуют с идентификаторами, которые не являются метками. Областью действия метки является тело функции, в которой она объявлена, и исключает тело любой вложенной функции.

Пустой идентификатор

Пустой идентификатор обозначается символом подчеркивания _. Он служит анонимным заполнителем вместо обычного (непустого) идентификатора и имеет особое значение в объявлениях, в качестве операнда и в операторах присваивания.

Объявленные идентификаторы

Следующие идентификаторы неявно объявлены в блоке universe [Go 1.18] [Go 1.21]:

Types:
	any bool byte comparable
	complex64 complex128 error float32 float64
	int int8 int16 int32 int64 rune string
	uint uint8 uint16 uint32 uint64 uintptr

Constants:
	true false iota

Zero value:
	nil

Functions:
	append cap clear close complex copy delete imag len
	make max min new panic print println real recover

Экспортируемые идентификаторы

Идентификатор может быть экспортирован, чтобы разрешить доступ к нему из другого пакета. Идентификатор экспортируется, если:

1. первый символ имени идентификатора является заглавной буквой Юникода (категория символов Юникода Lu); и
2. идентификатор объявлен в блоке пакета или является именем поля или метода.

Все остальные идентификаторы не экспортируются.

Уникальность идентификаторов

Если задан набор идентификаторов, то идентификатор называется уникальным, если он отличается от всех остальных в этом наборе. Два идентификатора отличаются друг от друга, если они пишутся по-разному или если они находятся в разных пакетах и не экспортируются. В противном случае они одинаковы.

Объявление констант

Объявление констант связывает список идентификаторов (имена констант) со значениями списка константных выражений. Количество идентификаторов должно быть равно количеству выражений, и n-й идентификатор слева привязывается к значению n-го выражения справа.

ConstDecl      = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
ConstSpec      = IdentifierList [ [ Type ] "=" ExpressionList ] .

IdentifierList = identifier { "," identifier } .
ExpressionList = Expression { "," Expression } .

Если тип присутствует, все константы принимают указанный тип, а выражения должны быть присваиваемыми этому типу, который не должен быть параметром типа.

Если тип опущен, константы принимают индивидуальные типы соответствующих выражений.

Если значения выражений являются нетипизированными константами, объявленные константы остаются нетипизированными, а идентификаторы констант обозначают значения констант.

Например, если выражение представляет собой литерал с плавающей точкой, идентификатор константы обозначает константу с плавающей точкой, даже если дробная часть литерала равна нулю.

const Pi float64 = 3.14159265358979323846
const zero = 0.0         // untyped floating-point constant
const (
	size int64 = 1024
	eof        = -1  // untyped integer constant
)
const a, b, c = 3, 4, "foo"  // a = 3, b = 4, c = "foo", untyped integer and string constants
const u, v float32 = 0, 3    // u = 0.0, v = 3.0

Внутри списка объявлений const с круглыми скобками список выражений может быть опущен в любом ConstSpec, кроме первого. Такой пустой список эквивалентен текстовой подстановке первого предшествующего непустого списка выражений и его типа, если таковой имеется. Поэтому пропуск списка выражений эквивалентен повторению предыдущего списка. Количество идентификаторов должно быть равно количеству выражений в предыдущем списке. Вместе с генератором констант iota этот механизм позволяет легко объявлять последовательные значения:

const (
	Sunday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Partyday
	numberOfDays  // this constant is not exported
)

Iota

В объявлении константы заранее объявленный идентификатор iota представляет последовательные нетипизированные целочисленные константы. Его значение - это индекс соответствующей константы в объявлении константы, начиная с нуля. Его можно использовать для построения набора связанных констант:

const (
	c0 = iota  // c0 == 0
	c1 = iota  // c1 == 1
	c2 = iota  // c2 == 2
)

const (
	a = 1 << iota  // a == 1  (iota == 0)
	b = 1 << iota  // b == 2  (iota == 1)
	c = 3          // c == 3  (iota == 2, unused)
	d = 1 << iota  // d == 8  (iota == 3)
)

const (
	u         = iota * 42  // u == 0     (untyped integer constant)
	v float64 = iota * 42  // v == 42.0  (float64 constant)
	w         = iota * 42  // w == 84    (untyped integer constant)
)

const x = iota  // x == 0
const y = iota  // y == 0

По определению, несколько применений iota в одном и том же ConstSpec имеют одно и то же значение:

const (
	bit0, mask0 = 1 << iota, 1<<iota - 1  // bit0 == 1, mask0 == 0  (iota == 0)
	bit1, mask1                           // bit1 == 2, mask1 == 1  (iota == 1)
	_, _                                  //                        (iota == 2, unused)
	bit3, mask3                           // bit3 == 8, mask3 == 7  (iota == 3)
)

В последнем примере используется неявное повторение последнего непустого списка выражений.

Декларации типов

Декларация типа связывает идентификатор, имени типа, с типом. Декларации типов бывают двух видов: декларации псевдонимов и определения типов.

TypeDecl = "type" ( TypeSpec | "(" { TypeSpec ";" } ")" ) .
TypeSpec = AliasDecl | TypeDef .

Объявление псевдонимов

Объявление псевдонимов связывает идентификатор с заданным типом [Go 1.9].

AliasDecl = identifier [ TypeParameters ] "=" Type .

В пределах области действия идентификатора он служит псевдонимом для данного типа.

type (
	nodeList = []*Node // nodeList и []*Node являются идентичными типами
	Polar = polar // Polar и polar обозначают идентичные типы
)

Если в объявлении псевдонима указаны параметры типа [Go 1.24], то имя типа обозначает общий псевдоним. Общие псевдонимы должны быть инстанцированы при их использовании.

type set[P comparable] = map[P]bool

В объявлении псевдонима заданный тип не может быть параметром типа.

type A[P any] = P // ошибка: P является параметром типа

Определения типов

Определение типа создает новый, отдельный тип с теми же базовыми типами и операциями, что и данный тип, и привязывает к нему идентификатор, имя типа.

TypeDef = identifier [ TypeParameters ] Type .

Новый тип называется определенным типом. Он отличается от любого другого типа, включая тип, на основе которого он создан.

type (
	Point struct{ x, y float64 }  // Point and struct{ x, y float64 } are different types
	polar Point                   // polar and Point denote different types
)

type TreeNode struct {
	left, right *TreeNode
	value any
}

type Block interface {
	BlockSize() int
	Encrypt(src, dst []byte)
	Decrypt(src, dst []byte)
}

Определенный тип может иметь методы, связанные с ним. Он не наследует никаких методов, связанных с данным типом, но набор методов интерфейсного типа или элементов составного типа остается неизменным:

// Mutex - это тип данных с двумя методами, Lock и Unlock.
type Mutex struct { /* Поля Mutex */ }
func (m *Mutex) Lock() { /* Реализация Lock */ }
func (m *Mutex) Unlock() { /* Реализация Unlock */ }

// NewMutex имеет тот же состав, что и Mutex, но его набор методов пуст.
type NewMutex Mutex

// Набор методов PtrMutex, лежащий в основе типа *Mutex, остается неизменным,
// но набор методов PtrMutex пуст.
type PtrMutex *Mutex

// Набор методов *PrintableMutex содержит методы
// Lock и Unlock, привязанные к его встроенному полю Mutex.
type PrintableMutex struct {
Mutex
}

// MyBlock - интерфейсный тип, имеющий тот же набор методов, что и Block.
type MyBlock Block

Определения типов могут использоваться для определения различных булевых, числовых или строковых типов и связывания с ними методов:

type TimeZone int

const (
	EST TimeZone = -(5 + iota)
	CST
	MST
	PST
)

func (tz TimeZone) String() string {
	return fmt.Sprintf("GMT%+dh", tz)
}

Если в определении типа указаны параметры типа, то имя типа обозначает общий тип. Общие типы должны быть инстанцированы при их использовании.

type List[T any] struct {
	next  *List[T]
	value T
}

В определении типа заданный тип не может быть параметром типа.

type T[P any] P // ошибка: P - параметр типа

func f[T any]() {
	type L T // ошибка: T - параметр типа, объявленный в объемлющей функции
}

Родовой тип может также иметь методы, связанные с ним. В этом случае приемники методов должны объявить то же количество параметров типа, что и в определении родового типа.

// Метод Len возвращает количество элементов в связанном списке l.
func (l *List[T]) Len() int { ... }

Объявление параметров типа

Список параметров типа объявляет параметры типа общей функции или объявления типа. Список параметров типа выглядит как обычный список параметров функции, за исключением того, что имена параметров типа должны присутствовать все, и список заключен в квадратные скобки, а не в круглые [Go 1.18].

TypeParameters = "[" TypeParamList [ "," ] "]" .
TypeParamList  = TypeParamDecl { "," TypeParamDecl } .
TypeParamDecl  = IdentifierList TypeConstraint .

Все непустые имена в списке должны быть уникальными. Каждое имя объявляет параметр типа, который представляет собой новый и отличный от других именованный тип, выступающий в качестве заполнителя для (пока) неизвестного типа в объявлении. Параметр типа заменяется аргументом типа при инстанцировании родовой функции или типа.

[P any]
[S interface{ ~[]byte|string }]
[S ~[]E, E any]
[P Constraint[int]]
[_ any]

Подобно тому, как каждый параметр обычной функции имеет тип параметра, каждый параметр типа имеет соответствующий (мета-)тип, который называется ограничением типа.

Неоднозначность при разборе возникает, когда в списке параметров типа для общего типа объявляется единственный параметр типа P с ограничением C таким образом, что текст P C образует допустимое выражение:

type T[P *C] …
type T[P (C)] …
type T[P *C|Q] …
…

В этих редких случаях список параметров типа неотличим от выражения, и объявление типа разбирается как объявление типа массива. Чтобы устранить двусмысленность, включите ограничение в интерфейс или используйте запятую в конце:

type T[P interface{*C}] …
type T[P *C,] …

Параметры типа также могут быть объявлены спецификацией приемника объявления метода, связанного с родовым типом.

В списке параметров типа родового типа T ограничение типа не может (прямо или косвенно через список параметров типа другого родового типа) ссылаться на T.

type T1[P T1[P]] ...                  // illegal: T1 ссылается на себя
type T2[P interface{ T2[int] }] ...   // illegal: T2 ссылается на себя
type T3[P interface{ m(T3[int])}] ... // illegal: T3 ссылается на себя
type T4[P T5[P]] ...                  // illegal: T4 ссылается на T5 и
type T5[P T4[P]] ...                  // T5 ссылается на T4

type T6[P int] struct{ f *T6[P] }     // нормально: ссылка на T6 отсутствует в списке параметров типа

Ограничения типа

Ограничение типа - это интерфейс, определяющий набор допустимых аргументов типа для соответствующего параметра типа и контролирующий операции, поддерживаемые значениями этого параметра типа [Go 1.18].

TypeConstraint = TypeElem .

Если ограничение представляет собой интерфейсный литерал вида interface{E}, где E - элемент встроенного типа (не метод), то в списке параметров типа вложенный интерфейс{ ...} может быть опущен для удобства:

[T []P]                      // = [T interface{[]P}]
[T ~int]                     // = [T interface{~int}]
[T int|string]               // = [T interface{int|string}]
type Constraint ~int         // illegal: ~int is not in a type parameter list

Объявленный тип интерфейса comparable обозначает множество всех неинтерфейсных типов, которые строго сравнимы [Go 1.18].

Даже если интерфейсы, не являющиеся параметрами типов, сравнимы, они не являются строго сравнимыми и поэтому не реализуют comparable. Однако они удовлетворяют требованиям comparable.

int                          // реализует сравнимость (int строго сравнимо)
[]byte                       // не реализует сравнимость (кусочки не могут быть сравнимы)
interface{}                  // не реализует сравнимое (см. выше)
interface{ ~int | ~string }  // только параметр типа: реализует сравнимость (типы int, string строго сравнимы)
interface{ comparable }      // только параметр типа: реализует comparable (comparable реализует сам себя)
interface{ ~int | ~[]byte }  // только параметр типа: не реализует сравнимое (срезы не сравнимы)
interface{ ~struct{ any } }  // только параметр типа: не реализует сравнимое (поле any не является строго сравнимым)

Сопоставимый интерфейс и интерфейсы, которые (прямо или косвенно) встраивают сопоставимый, могут использоваться только в качестве ограничений типа. Они не могут быть типами значений или переменных, или компонентами других, неинтерфейсных типов.

Удовлетворение ограничения типа

Аргумент типа T удовлетворяет ограничению типа C, если T является элементом множества типов, определяемого C; другими словами, если T реализует C. В качестве исключения, строго сравнимое ограничение типа может быть также удовлетворено сравнимым (не обязательно строго сравнимым) аргументом типа [Go 1.20]. Точнее:

Тип T удовлетворяет ограничению C, если

1. T реализует C; или
2. C может быть записан в виде interface{ comparable; E }, где E - базовый интерфейс, а T сопоставим и реализует E.

Из-за исключения в правиле удовлетворения ограничений сравнение операндов типа parameter может вызвать панику во время выполнения (несмотря на то, что параметры сравнимого типа всегда строго сравнимы).

Объявление переменных

Объявление переменной создает одну или несколько переменных, привязывает к ним соответствующие идентификаторы и присваивает каждой из них тип и начальное значение.

VarDecl = "var" ( VarSpec | "(" { VarSpec ";" } ")" ) .
VarSpec = IdentifierList ( Type [ "=" ExpressionList ] | "=" ExpressionList ) .

var i int
var U, V, W float64
var k = 0
var x, y float32 = -1, -2
var (
	i       int
	u, v, s = 2.0, 3.0, "bar"
)
var re, im = complexSqrt(-1)
var _, found = entries[name]  // map lookup; only interested in "found"

Если задан список выражений, переменные инициализируются этими выражениями в соответствии с правилами для операторов присваивания. В противном случае каждая переменная инициализируется нулевым значением.

Если задан тип, то каждой переменной присваивается этот тип. В противном случае каждой переменной присваивается тип соответствующего инициализирующего значения в присваивании. Если это значение является нетипизированной константой, то оно сначала неявно преобразуется к типу по умолчанию; если это нетипизированное булево значение, то оно сначала неявно преобразуется к типу bool. Объявленный идентификатор nil не может использоваться для инициализации переменной без явного типа.

var d = math.Sin(0.5)  // d is float64
var i = 42             // i is int
var t, ok = x.(T)      // t is T, ok is bool
var n = nil            // illegal

Ограничение реализации: Компилятор может сделать незаконным объявление переменной внутри тела функции, если переменная никогда не будет использоваться.

Объявление коротких переменных

Объявление короткой переменной использует синтаксис:

ShortVarDecl = IdentifierList ":=" ExpressionList .

Это сокращение для обычного объявления переменной с выражениями-инициализаторами, но без типов:

"var" IdentifierList "=" ExpressionList .
i, j := 0, 10
f := func() int { return 7 }
ch := make(chan int)
r, w, _ := os.Pipe() // os. Pipe() возвращает соединенную пару Files и ошибку, если таковая имеется
_, y, _ := coord(p)  // coord() возвращает три значения; интересует только координата y

В отличие от обычных объявлений переменных, короткое объявление переменных может повторно объявлять переменные, если они были первоначально объявлены ранее в том же блоке (или в списках параметров, если блок является телом функции) с тем же типом, и хотя бы одна из непустых переменных является новой. Как следствие, повторное объявление может появиться только в коротком объявлении с несколькими переменными. Повторное объявление не вводит новую переменную; оно просто присваивает новое значение исходной. Непустые имена переменных в левой части := должны быть уникальными.

field1, offset := nextField(str, 0)
field2, offset := nextField(str, offset) // повторно объявляет смещение
x, y, x := 1, 2, 3 // незаконно: x повторяется в левой части :=

Короткие объявления переменных могут появляться только внутри функций. В некоторых контекстах, например в инициализаторах операторов “if”, “for” или “switch”, они могут использоваться для объявления локальных временных переменных.

Объявление функций

Объявление функции связывает идентификатор, имя функции, с функцией.

FunctionDecl = "func" FunctionName [ TypeParameters ] Signature [ FunctionBody ] .
FunctionName = identifier .
FunctionBody = Block .

Если в сигнатуре функции объявлены параметры результата, то список утверждений тела функции должен заканчиваться завершающим утверждением.

func IndexRune(s string, r rune) int {
for i, c := range s {
if c == r {
return i
}
	}
	// недопустимо: отсутствует оператор return
}

Если в объявлении функции указаны параметры типа, то имя функции обозначает родовую функцию. Родовая функция должна быть инстанцирована, прежде чем ее можно будет вызвать или использовать в качестве значения.

func min[T ~int|~float64](x, y T) T {
if x < y {
return x
}
return y
}

Объявление функции без параметров типа может не содержать тела. Такое объявление представляет собой сигнатуру для функции, реализованной вне Go, например, в ассемблере.

func flushICache(begin, end uintptr) // реализовано извне

Объявление методов

Метод - это функция с приемником. Объявление метода привязывает к методу идентификатор, имя метода, и связывает метод с базовым типом приемника.

MethodDecl = "func" Receiver MethodName Signature [ FunctionBody ] .
Receiver   = Parameters .

Приемник указывается в дополнительной секции параметров, предшествующей имени метода. В этой секции параметров должен быть объявлен единственный невариативный параметр - приемник. Его тип должен быть определенным типом T или указателем на определенный тип T, за которым, возможно, следует список имен параметров типа [P1, P2, ...], заключенных в квадратные скобки. T называется базовым типом приемника. Базовый тип-приемник не может быть указателем или интерфейсным типом и должен быть определен в том же пакете, что и метод. Считается, что метод привязан к базовому типу-приемнику, и имя метода видно только в селекторах для типа T или *T.

Непустой идентификатор приемника должен быть уникальным в сигнатуре метода. Если на значение приемника не ссылаются в теле метода, его идентификатор можно не указывать в объявлении. То же самое относится и к параметрам функций и методов.

Для базового типа непустые имена методов, связанных с ним, должны быть уникальными. Если базовым типом является тип struct, то непустые имена методов и полей должны быть разными.

Заданный определенный тип Point

func (p *Point) Length() float64 {
	return math.Sqrt(p.x * p.x + p.y * p.y)
}

func (p *Point) Scale(factor float64) {
	p.x *= factor
	p.y *= factor
}

привязать методы Length и Scale, с типом приемника *Point, к базовому типу Point.

Если базовый тип приемника является общим типом, спецификация приемника должна объявить соответствующие параметры типа для используемого метода. Это делает параметры типа-приемника доступными для метода.

Синтаксически объявление параметров типа выглядит как инстанцирование базового типа-приемника: аргументы типа должны быть идентификаторами, обозначающими объявляемые параметры типа, по одному на каждый параметр типа базового типа-приемника. Имена параметров типа не обязательно должны совпадать с соответствующими именами параметров в определении базового типа-приемника, а все непустые имена параметров должны быть уникальными в секции параметров приемника и в сигнатуре метода.

Ограничения параметров типа-приемника подразумеваются определением базового типа-приемника: соответствующие параметры типа имеют соответствующие ограничения.

type Pair[A, B any] struct {
	a A
	b B
}

func (p Pair[A, B]) Swap() Pair[B, A] { ... }  // приемник объявляет A, B
func (p Pair[First, _]) First() First { ... }  // получатель объявляет First, соответствует A в Pair

Если тип-приемник обозначается псевдонимом (указателем на него), то этот псевдоним не должен быть общим и не должен обозначать инстанцированный общий тип, ни прямо, ни косвенно через другой псевдоним, и независимо от перенаправления указателей.

type GPoint[P any] = Point
type HPoint = *GPoint[int]
type IPair = Pair[int, int]

func (*GPoint[P]) Draw(P) { ... }   // illegal: alias не должен быть общим
func (HPPoint) Draw(P) { ... }      // illegal: alias не должен обозначать инстанцированный тип GPoint[int]
func (*IPair) Second() int { ... }  // illegal: псевдоним не должен обозначать инстанцированный тип Pair[int, int]

Выражения

Выражение задает вычисление значения путем применения операторов и функций к операндам.

Операнды

Операнды обозначают элементарные значения в выражении. Операнд может быть литералом, (возможно, квалифицированным) непустым идентификатором, обозначающим константу, переменную или функцию, или выражением в круглых скобках.

Operand     = Literal | OperandName [ TypeArgs ] | "(" Expression ")" .
Literal     = BasicLit | CompositeLit | FunctionLit .
BasicLit    = int_lit | float_lit | imaginary_lit | rune_lit | string_lit .
OperandName = identifier | QualifiedIdent .

За именем операнда, обозначающего общую функцию, может следовать список аргументов типа; результирующий операнд является инстанцированной функцией.

Пустой идентификатор может появляться в качестве операнда только в левой части оператора присваивания.

Ограничение на реализацию: Компилятор не должен сообщать об ошибке, если тип операнда является параметром типа с пустым набором типов. Функции с такими параметрами типа не могут быть инстанцированы; любая попытка приведет к ошибке в месте инстанцирования.

Квалифицированные идентификаторы

Квалифицированный идентификатор - это идентификатор, снабженный префиксом имени пакета. И имя пакета, и идентификатор не должны быть пустыми.

QualifiedIdent = PackageName "." identifier .

Квалифицированный идентификатор обращается к идентификатору в другом пакете, который должен быть импортирован. Идентификатор должен быть экспортирован и объявлен в блоке пакета этого пакета.

math.Sin // обозначает функцию Sin в пакете math

Составные литералы

Составные литералы создают новые составные значения каждый раз, когда их объявляют. Они состоят из типа литерала, за которым следует ограниченный скобками список элементов. Каждому элементу может предшествовать соответствующий ключ.

CompositeLit = LiteralType LiteralValue .
LiteralType  = StructType | ArrayType | "[" "..." "]" ElementType |
               SliceType | MapType | TypeName [ TypeArgs ] .
LiteralValue = "{" [ ElementList [ "," ] ] "}" .
ElementList  = KeyedElement { "," KeyedElement } .
KeyedElement = [ Key ":" ] Element .
Key          = FieldName | Expression | LiteralValue .
FieldName    = identifier .
Element      = Expression | LiteralValue .

Основной тип LiteralType T должен быть типом struct, array, slice или map (в синтаксисе это ограничение соблюдается, за исключением случаев, когда тип задан как TypeName). Типы элементов и ключей должны быть присваиваемыми соответствующим типам поля, элемента и ключа типа T; дополнительное преобразование не требуется.

Ключ интерпретируется как имя поля для литералов struct, индекс для литералов array и slice и ключ для литералов map. Для литералов map все элементы должны иметь ключ. Ошибкой является указание нескольких элементов с одним и тем же именем поля или постоянным значением ключа. О непостоянных ключах map см. раздел о порядке объявлений.

Для литералов struct действуют следующие правила:

1. Ключ должен быть именем поля, объявленного в типе struct.
2. Список элементов, не содержащий ключей, должен содержать элемент для каждого поля struct в том порядке, в котором эти поля объявлены.
3. Если любой элемент имеет ключ, то каждый элемент должен иметь ключ.
4. Список элементов, содержащий ключи, не обязательно должен содержать элемент для каждого поля struct. Опущенные поля получают нулевое значение для этого поля.
5. Литерал может не содержать список элементов; такой литерал оценивается в нулевое значение для своего типа.
6. Ошибкой является указание элемента для неэкспортируемого поля структуры, принадлежащей другому пакету.

Учитывая сказанное

type Point3D struct { x, y, z float64 }
type Line struct { p, q Point3D }

и теперь можно написать

origin := Point3D{}                            // zero value for Point3D
line := Line{origin, Point3D{y: -4, z: 12.3}}  // zero value for line.q.x

Для литералов массивов и фрагментов действуют следующие правила:

1. Каждый элемент имеет связанный с ним целочисленный индекс, отмечающий его положение в массиве.
2. Элемент с ключом использует ключ в качестве своего индекса. Ключ должен быть неотрицательной константой, представляемой значением типа int; а если он типизирован, то должен быть целочисленного типа.
3. Элемент без ключа использует индекс предыдущего элемента плюс один. Если первый элемент не имеет ключа, его индекс равен нулю.

При получении адреса составного литерала генерируется указатель на уникальную переменную, инициализированную значением литерала.

var pointer *Point3D = &Point3D{y: 1000}

Обратите внимание, что нулевое значение для типа slice или map - это не то же самое, что инициализированное, но пустое значение того же типа. Следовательно, получение адреса пустого составного литерала slice или map не имеет того же эффекта, что и выделение нового значения slice или map с помощью new.

p1 := &[]int{}    // p1 указывает на инициализированный, пустой фрагмент со значением []int{} и длиной 0
p2 := new([]int) // p2 указывает на неинициализированный фрагмент со значением nil и длиной 0

Длина литерала массива равна длине, указанной в типе литерала. Если в литерале указано меньше элементов, чем длина, то недостающие элементы устанавливаются в нулевое значение для типа элемента массива. Предоставление элементов со значениями индексов вне диапазона индексов массива является ошибкой. Обозначение ... задает длину массива, равную максимальному индексу элемента плюс один.

buffer := [10]string{}             // len(buffer) == 10
intSet := [6]int{1, 2, 3, 5}       // len(intSet) == 6
days := [...]string{"Sat", "Sun"}  // len(days) == 2

Литерал slice описывает весь лежащий в его основе литерал массива. Таким образом, длина и емкость литерала slice равны максимальному индексу элемента плюс единица.

Литерал среза имеет вид

[]T{x1, x2, ... xn}

и является сокращением для операции slice, применяемой к массиву:

tmp := [n]T{x1, x2, ... xn}
tmp[0 : n]

Внутри составного литерала массива, среза или карты типа T элементы или ключи карты, которые сами являются составными литералами, могут элиминировать соответствующий тип литерала, если он идентичен типу элемента или ключа T. Аналогично, элементы или ключи, которые являются адресами составных литералов, могут элиминировать &T, если тип элемента или ключа *T.

[...]Point{{1.5, -3.5}, {0, 0}}     // аналогично [...]Point{Point{1.5, -3.5}, Point{0, 0}}
[][]int{{1, 2, 3}, {4, 5}}          // аналогично [][]int{[]int{1, 2, 3}, []int{4, 5}}
[][]Point{{{0, 1}, {1, 2}}}         // аналогично map[string]Point{"orig": Point{0, 0}}
map[Point]string{{0, 0}: "orig"}    // аналогично map[Point]string{Point{0, 0}: "orig"}

type PPoint *Point
[2]*Point{{1.5, -3.5}, {}}          // аналогично [2]*Point{&Point{1.5, -3.5}, &Point{}}
[2]PPoint{{1.5, -3.5}, {}}          // аналогично [2]PPoint{PPoint(&Point{1.5, -3.5}), PPoint(&Point{})}

Неоднозначность разбора возникает, когда составной литерал, использующий форму TypeName типа LiteralType, появляется в качестве операнда между ключевым словом и открывающей скобкой блока оператора “if”, “for” или “switch”, а составной литерал не заключен в круглые скобки, квадратные скобки или фигурные скобки. В этом редком случае открывающая скобка литерала ошибочно воспринимается как скобка, вводящая блок операторов. Чтобы устранить двусмысленность, составной литерал должен быть заключен в круглые скобки.

if x == (T{a,b,c}[i]) { … }
if (x == T{a,b,c}[i]) { … }

Примеры допустимых литералов массивов, фрагментов и карт:

// список простых чисел
primes := []int{2, 3, 5, 7, 9, 2147483647}

// vowels[ch] - true, если ch - гласная
vowels := [128]bool{'a': true, 'e': true, 'i': true, 'o': true, 'u': true, 'y': true}

// массив [10]float32{-1, 0, 0, 0, -0.1, -0.1, 0, 0, 0, -1}
filter := [10]float32{-1, 4: -0.1, -0.1, 9: -1}

// частоты в Гц для равнотемперированной шкалы (A4 = 440 Гц)
noteFrequency := map[string]float32{
"C0": 16.35, "D0": 18.35, "E0": 20.60, "F0": 21.83,
"G0": 24.50, "A0": 27.50, "B0": 30.87,
}

Литералы функций

Литерал функции представляет собой анонимную функцию. Функциональные литералы не могут объявлять параметры типа.

FunctionLit = "func" Signature FunctionBody .

func(a, b int, z float64) bool { return a*b < int(z) }

Литерал функции может быть присвоен переменной или вызван напрямую.

f := func(x, y int) int { return x + y }
func(ch chan int) { ch <- ACK }(replyChan)

Функциональные литералы являются закрывающими: они могут ссылаться на переменные, определенные в окружающей функции. Эти переменные затем разделяются между окружающей функцией и литералом функции, и они сохраняются до тех пор, пока доступны.

Первичные выражения

Первичные выражения - это операнды для унарных и бинарных выражений.

PrimaryExpr   = Operand |
                Conversion |
                MethodExpr |
                PrimaryExpr Selector |
                PrimaryExpr Index |
                PrimaryExpr Slice |
                PrimaryExpr TypeAssertion |
                PrimaryExpr Arguments .

Selector      = "." identifier .
Index         = "[" Expression [ "," ] "]" .
Slice         = "[" [ Expression ] ":" [ Expression ] "]" |
                "[" [ Expression ] ":" Expression ":" Expression "]" .
TypeAssertion = "." "(" Type ")" .
Arguments     = "(" [ ( ExpressionList | Type [ "," ExpressionList ] ) [ "..." ] [ "," ] ] ")" .

x
2
(s + ".txt")
f(3.1415, true)
Point{1, 2}
m["foo"]
s[i : j + 1]
obj.color
f.p[i].x()

Selectors (Селекторы)

Для первичного выражения x, не являющегося именем пакета, селекторное выражение

x.f

обозначает поле или метод f значения x (или иногда *x; см. ниже). Идентификатор f называется селектором (поля или метода); он не должен быть пустым идентификатором. Тип выражения селектора равен типу f. Если x - это имя пакета, см. раздел о квалифицированных идентификаторах.

Селектор f может обозначать поле или метод f типа T, либо ссылаться на поле или метод f вложенного в него вложенного поля T. Количество вложенных полей, пройденных для достижения f, называется его глубиной в T. Глубина поля или метода f, объявленного в T, равна нулю. Глубина поля или метода f, объявленного во вложенном поле A в T, равна глубине f в A плюс один.

К селекторам применяются следующие правила:

1. Для значения x типа T или *T, где T не является указателем или интерфейсным типом, x.f обозначает поле или метод на самой малой глубине в T, где есть такой f. Если не существует ровно одного f с самой малой глубиной, то выражение селектора является незаконным.
2. Для значения x типа I, где I - интерфейсный тип, x.f обозначает фактический метод с именем f динамического значения x. Если в наборе методов I нет метода с именем f, то селекторное выражение незаконно.
3. В качестве исключения, если тип x является определенным типом указателя и (*x).f является допустимым селекторным выражением, обозначающим поле (но не метод), x.f является сокращением для (*x).f.
4. Во всех остальных случаях x.f является незаконным.
5. Если x имеет тип указателя и значение nil, а x.f обозначает поле struct, присваивание или вычисление x.f вызовет панику во время выполнения.
6. Если x имеет тип интерфейса и значение nil, вызов или оценка метода x.f приводит к панике во время выполнения.

Например, учитывая сказанное:

type T0 struct {
	x int
}

func (*T0) M0()

type T1 struct {
	y int
}

func (T1) M1()

type T2 struct {
	z int
	T1
	*T0
}

func (*T2) M2()

type Q *T2

var t T2     // with t.T0 != nil
var p *T2    // with p != nil and (*p).T0 != nil
var q Q = p

можно написать:

t.z // t.z
t.y // t.T1.y
t.x // (*t.T0).x

p.z // (*p).z
p.y // (*p).T1.y
p.x // (*(*p).T0).x

q.x // (*(*q).T0).x (*q).x является допустимым селектором поля

p.M0() // ((*p).T0).M0() M0 ожидает приемник *T0
p.M1() // ((*p).T1).M1() M1 ожидает приемник T1
p.M2() // p.M2() M2 ожидает приемник *T2
t.M2() // (&t).M2() M2 ожидает *T2-приемник, см. раздел Calls (Вызовы)

но следующее недействительно:

q.M0() // (*q).M0 действителен, но не является селектором поля

Выражения в методах

Если M находится в наборе методов типа T, то T.M - это функция, которая может быть вызвана как обычная функция с теми же аргументами, что и M, с префиксом в виде дополнительного аргумента, который является приемником метода.

MethodExpr = ReceiverType "." MethodName .
ReceiverType = Type .

Рассмотрим структуру типа T с двумя методами, Mv, приемник который имеет тип T, и Mp, приемник который имеет тип *T.

type T struct {
a int
}
func (tv T) Mv(a int) int { return 0 }  // приемник значений
func (tp *T) Mp(f float32) float32 { return 1 }  // приемник указателей

var t T

Выражение

T.Mv

дает функцию, эквивалентную Mv, но с явным приемником в качестве первого аргумента; она имеет сигнатуру

func(tv T, a int) int

Эта функция может быть вызвана обычным образом с явным приемником, так что эти пять вызовов эквивалентны:

t.Mv(7)
T.Mv(t, 7)
(T).Mv(t, 7)
f1 := T.Mv; f1(t, 7)
f2 := (T).Mv; f2(t, 7)

Аналогично, выражение

(*T).Mp

дает функцию, представляющую значение Mp с сигнатурой

func(tp *T, f float32) float32

Для метода с приемником значений можно вывести функцию с явным приемником указателей, так что

(*T).Mv

дает функцию, представляющую значение Mv с сигнатурой

func(tv *T, a int) int

Такая функция косвенно через приемник создает значение для передачи в качестве приемника базовому методу; при этом метод не перезаписывает значение, адрес которого передается в вызове функции.

Последний случай, функция-приемник значения для метода-приемника указателя, является незаконным, поскольку методы-приемники указателей не входят в набор методов типа значения.

Функции-значения, получаемые из методов, вызываются с помощью синтаксиса вызова функции; приемник предоставляется в качестве первого аргумента вызова. То есть, если дано f := T.Mv, то f вызывается как f(t, 7), а не t.f(7). Чтобы сконструировать функцию, связывающую приемник, используйте литерал функции или значение метода.

Законно выводить значение функции из метода интерфейсного типа. Результирующая функция принимает явный приемник этого интерфейсного типа.

Значения метода

Если выражение x имеет статический тип T, а M находится в наборе методов типа T, то x.M называется значением метода. Значение метода x.M - это значение функции, которое можно вызвать с теми же аргументами, что и вызов метода x.M. Выражение x рассчитывается и сохраняется во время вычислений значения метода; сохраненная копия затем используется в качестве приемника в любых вызовах, которые могут быть выполнены позже.

type S struct { *T }
type T int
func (t T) M() { print(t) }

t := new(T)
s := S{T: t}
f := t.M // приемник *t рассчитывается и хранится в f
g := s.M // приемник *(s.T) рассчитывается и хранится в g
*t = 42 // не влияет на сохраненные приемники в f и g