言語仕様（Language Specification）

言語バージョン go1.23 (2024年6月13日)

はじめに

これはGoプログラミング言語のリファレンスマニュアルです。ジェネリクスのないGo1.18以前のバージョンはこちらで見つけることができます。詳細や他の文書についてはgo.devを参照してください。

Goはシステムプログラミングを念頭に置いて設計された汎用言語です。強い型付けがされており、ガベージコレクションが行われ、並行プログラミングに対する明示的なサポートがあります。プログラムはパッケージから構成されており、その特性により依存関係の効率的な管理が可能です。

構文はコンパクトで解析が簡単であり、統合開発環境などの自動ツールによる簡単な分析が可能です。

表記法

構文は拡張バックナウア形式（EBNF）の変種を使用して指定されています：

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

生成物は、項と次の演算子から構成される式であり、優先順位が高い順に並んでいます：

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

小文字の生成物名は、字句（終端）トークンを識別するために使用されます。非終端はキャメルケースで表記されます。字句トークンは二重引用符""またはバッククォート`` で囲まれています。

形式a … bは、aからbまでの文字の集合を代替として表します。水平省略記号…は、仕様の他の場所でも使用され、さらに指定されていないさまざまな列挙やコードスニペットを非公式に示します。文字…（...の3文字とは異なる）は、Go言語のトークンではありません。

[Go 1.xx]の形式のリンクは、記述された言語機能（またはその一部）が言語バージョン1.xxで変更または追加されたことを示し、したがって、その言語バージョンをビルドするためには最低限そのバージョンが必要です。詳細については、付録のリンクされたセクションを参照してください。

ソースコードの表現

ソースコードはUTF-8でエンコードされたUnicodeテキストです。テキストは正規化されていないため、単一のアクセント付きコードポイントは、アクセントと文字を組み合わせて構成された同じ文字とは異なります。これらは2つのコードポイントとして扱われます。簡単のため、この文書ではソーステキスト内のUnicodeコードポイントを指すために、無条件の用語文字を使用します。

各コードポイントは異なります。たとえば、大文字と小文字の文字は異なる文字です。

実装制限：他のツールとの互換性のために、コンパイラはソーステキスト内のNUL文字（U+0000）を許可しない場合があります。

実装制限：他のツールとの互換性のために、コンパイラはソーステキスト内の最初のUnicodeコードポイントがUTF-8エンコードされたバイトオーダーマーク（U+FEFF）である場合、これを無視することがあります。ソース内の他の場所でバイトオーダーマークが許可されない場合があります。

文字

次の用語は特定のUnicode文字カテゴリを示すために使用されます：

= /* the Unicode code point U+000A */ .
   = /* an arbitrary Unicode code point except newline */ .
 = /* a Unicode code point categorized as "Letter" */ .
  = /* a Unicode code point categorized as "Number, decimal digit" */ .

Unicode標準8.0のセクション4.5「一般カテゴリ」では、文字カテゴリのセットが定義されています。Goは、文字カテゴリLu、Ll、Lt、Lm、またはLoのすべての文字をUnicode文字として扱い、数字カテゴリNdの文字をUnicode数字として扱います。

文字と数字

アンダースコア文字_（U+005F）は小文字の文字と見なされます。

=  | "_" .
 = "0" … "9" .
  = "0" | "1" .
   = "0" … "7" .
   = "0" … "9" | "A" … "F" | "a" … "f" .

字句要素

コメント

コメントはプログラムのドキュメントとして機能します。2つの形式があります：

• 1. 行コメントは文字列//で始まり、行の終わりで終了します。
• 2. 一般コメントは文字列/*で始まり、最初の次の文字列*/で終了します。

コメントはruneやstring literalの内部、またはコメントの内部で開始することはできません。改行を含まない一般コメントはスペースのように機能します。他のコメントは改行のように機能します。

トークン

トークンはGo言語の語彙を形成します。4つのクラスがあります：識別子、キーワード、演算子と句読点、およびリテラル。ホワイトスペースは、スペース（U+0020）、水平タブ（U+0009）、キャリッジリターン（U+000D）、および改行（U+000A）から構成され、トークンが結合されるのを防ぐために無視されます。また、改行またはファイルの終わりはセミコロンの挿入を引き起こす場合があります。入力をトークンに分割する際、次のトークンは有効なトークンを形成する最長の文字列のシーケンスです。

セミコロン

正式な構文では、セミコロン";"がいくつかの生成物の終端子として使用されます。Goプログラムは、次の2つのルールを使用して、これらのセミコロンのほとんどを省略できます：

• 1. 入力がトークンに分割されると、行の最後のトークンの直後にトークンストリームに自動的にセミコロンが挿入されます。
  • 識別子
  • 整数、浮動小数点、虚数、rune、またはstringリテラル
  • キーワード break、continue、fallthrough、またはreturnのいずれか
  • 演算子と句読点 ++、--、)、]、または}のいずれか
• 2. 複雑な文が1行に収まるようにするために、閉じる")"または"}"の前にセミコロンを省略できます。

この文書のコード例は、これらのルールを使用してセミコロンを省略しています。

識別子

識別子は変数や型などのプログラムエンティティに名前を付けます。識別子は1つ以上の文字と数字のシーケンスです。識別子の最初の文字は文字でなければなりません。

=  {  |  } .

a
_x9
ThisVariableIsExported
αβ

一部の識別子は事前宣言済みです。

キーワード

次のキーワードは予約されており、識別子として使用することはできません。

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

演算子と句読点

次の文字列は演算子（代入演算子を含む）および句読点[Go 1.18]を表します：

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

整数リテラル

整数リテラルは、整数定数を表す数字のシーケンスです。オプションの接頭辞は非10進数の基数を設定します：0bまたは0Bは2進数、0、0o、または0Oは8進数、0xまたは0Xは16進数[Go 1.13]です。単一の0は10進数のゼロと見なされます。16進数リテラルでは、文字aからfおよびAからFは値10から15を表します。

可読性のために、アンダースコア文字_は基数接頭辞の後または連続する数字の間に現れることがあります。このようなアンダースコアはリテラルの値を変更しません。

=  |  |  |  .
   = "0" | ( "1" … "9" ) [ [ "_" ]  ] .
   = "0" ( "b" | "B" ) [ "_" ]  .
   = "0" [ "o" | "O" ] [ "_" ]  .
   = "0" ( "x" | "X" ) [ "_" ]  .
 =  { [ "_" ]  } .
  =  { [ "_" ]  } .
   =  { [ "_" ]  } .
   =  { [ "_" ]  } .

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

浮動小数点リテラル

浮動小数点リテラルは、浮動小数点定数の10進数または16進数の表現です。

10進浮動小数点リテラルは、整数部（10進数の数字）、小数点、分数部（10進数の数字）、および指数部（eまたはEの後にオプションの符号と10進数の数字が続く）で構成されます。整数部または分数部のいずれかが省略される場合があります。小数点または指数部のいずれかが省略される場合があります。指数値expは、仮数（整数部と分数部）を10^expでスケーリングします。

16進浮動小数点リテラルは、0xまたは0Xの接頭辞、整数部（16進数の数字）、基数点、分数部（16進数の数字）、および指数部（pまたはPの後にオプションの符号と10進数の数字が続く）で構成されます。整数部または分数部のいずれかが省略される場合があります。基数点も省略可能ですが、指数部は必須です。（この構文はIEEE 754-2008 §5.12.3で示されたものと一致します。）指数値expは、仮数（整数部と分数部）を2^expでスケーリングします[Go 1.13]。

可読性のために、アンダースコア文字_は基数接頭辞の後または連続する数字の間に現れることがあります。このようなアンダースコアはリテラルの値を変更しません。

=  |  .
 =  "." [  ] [  ] |
   |
   "."  [  ] .
  = ( "e" | "E" ) [ "+" | "-" ]  .
   = "0" ( "x" | "X" )   .
   = [ "_" ]  "." [  ] |
   [ "_" ]  |
   "."  .
   = ( "p" | "P" ) [ "+" | "-" ]  .

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

虚数リテラル

虚数リテラルは、複素定数の虚数部分を表します。整数（#Integer_literals）または浮動小数点（#Floating-point_literals）リテラルの後に小文字のiが続きます。虚数リテラルの値は、対応する整数または浮動小数点リテラルの値に虚数単位iを掛けたものです[Go 1.13]。

= ( |  | ) "i" .

後方互換性のために、虚数リテラルの整数部分がすべて10進数の数字（および可能なアンダースコア）で構成されている場合、先頭の0があっても10進数の整数と見なされます。

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

runeリテラル

runeリテラルは、rune定数を表し、Unicodeコードポイントを識別する整数値です。runeリテラルは、'x'または'\n'のように、単一引用符で囲まれた1つ以上の文字として表現されます。引用符内では、改行とエスケープされていない単一引用符以外の任意の文字が現れることができます。単一引用符で囲まれた文字は、その文字自体のUnicode値を表し、バックスラッシュで始まる複数の文字列はさまざまな形式で値をエンコードします。

最も単純な形式は、引用符内の単一の文字を表します。GoのソーステキストはUTF-8でエンコードされたUnicode文字であるため、複数のUTF-8エンコードされたバイトが単一の整数値を表すことがあります。たとえば、リテラル'a'は、リテラルa、Unicode U+0061、値0x61を表す単一バイトを保持し、'ä'はリテラルa-ダイエレシス、U+00E4、値0xe4を表す2バイトを保持します。

いくつかのバックスラッシュエスケープにより、任意の値をASCIIテキストとしてエンコードできます。整数値を数値定数として表現する方法は4つあります：\xの後に正確に2つの16進数の数字、\uの後に正確に4つの16進数の数字、\Uの後に正確に8つの16進数の数字、そして単純なバックスラッシュ\の後に正確に3つの8進数の数字です。各ケースで、リテラルの値は対応する基数の数字によって表される値です。

これらの表現はすべて整数を生成しますが、有効範囲は異なります。8進数のエスケープは、0から255の範囲の値を表す必要があります。16進数のエスケープは、構造上この条件を満たします。エスケープ\uおよび\UはUnicodeコードポイントを表すため、その中にはいくつかの値が不正であり、特に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リテラル内のバックスラッシュの後に認識されない文字があると、不正です。

= "'" (  |  ) "'" .
   =  |  |  |  .
   =  |  .
 = `\`    .
   = `\` "x"   .
   = `\` "u"     .
   = `\` "U"
   .
   = `\` ( "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

文字列リテラル

文字列リテラルは、文字のシーケンスを連結して得られるstring constantを表します。2つの形式があります：生文字列リテラルと解釈された文字列リテラル。

生文字列リテラルは、`foo` のようにバッククォートで囲まれた文字列のシーケンスです。引用符内では、バッククォート以外の任意の文字が現れることができます。生文字列リテラルの値は、引用符の間にある解釈されていない（暗黙的にUTF-8でエンコードされた）文字から構成される文字列です。特に、バックスラッシュには特別な意味はなく、文字列には改行を含めることができます。生文字列リテラル内のキャリッジリターン文字（’\r’）は、生文字列の値から削除されます。

解釈された文字列リテラルは、"bar"のように二重引用符で囲まれた文字列のシーケンスです。引用符内では、改行とエスケープされていない二重引用符以外の任意の文字が現れることができます。引用符の間のテキストはリテラルの値を形成し、バックスラッシュエスケープはruneリテラル内でのように解釈されます（\'は不正で\"は合法です）、同じ制限があります。3桁の8進数（\nnn）および2桁の16進数（\xnn）のエスケープは、結果の文字列の個々のバイトを表します。他のすべてのエスケープは、個々の文字の（おそらく複数バイトの）UTF-8エンコーディングを表します。したがって、文字列リテラル内の\377および\xFFは、値0xFF=255の単一バイトを表し、ÿ、\u00FF、\U000000FFおよび\xc3\xbfは、文字U+00FFのUTF-8エンコーディングの2バイト0xc3 0xbfを表します。

=  |  .
   = "`" {  |  } "`" .
 = `"` {  |  } `"` .

\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
"\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

ソースコードが文字を2つのコードポイントとして表す場合、たとえばアクセントと文字を組み合わせた形の場合、runeリテラルに配置するとエラーが発生し（単一のコードポイントではないため）、文字列リテラルに配置すると2つのコードポイントとして表示されます。

定数

定数にはブール定数、rune定数、整数定数、浮動小数点定数、複素定数、および文字列定数があります。rune、整数、浮動小数点、および複素定数は総称して数値定数と呼ばれます。

定数値はrune、整数、浮動小数点、虚数、またはstringリテラル、定数を示す識別子、定数式、定数の結果を持つ変換、またはminやmaxのような定数引数に適用されるいくつかの組み込み関数の結果値、unsafe.Sizeofのような特定の値に適用される、capやlenのようないくつかの式に適用される、realおよびimagのような複素定数に適用される、または数値定数に適用されるcomplexの結果値で表されます。ブールの真理値は、事前宣言された定数trueおよびfalseで表されます。事前宣言された識別子iotaは整数定数を示します。

一般に、複素定数は定数式の一形態であり、そのセクションで議論されます。

数値定数は任意の精度の正確な値を表し、オーバーフローしません。したがって、IEEE 754の負のゼロ、無限大、非数値を示す定数は存在しません。

定数は型を持つか無型である可能性があります。リテラル定数、true、false、iota、および無型の定数オペランドのみを含む特定の定数式は無型です。

定数は、定数宣言または変換によって明示的に型を与えられるか、変数宣言や代入文で使用されるとき、または式のオペランドとして使用されるときに暗黙的に型を与えられます。定数値がそれぞれの型の値として表現できない場合、エラーが発生します。型が型パラメータである場合、定数は型パラメータの非定数値に変換されます。

無型定数にはデフォルト型があり、これは定数が型付き値が必要なコンテキストで暗黙的に変換される型です。たとえば、i := 0のような短い変数宣言では、明示的な型がありません。無型定数のデフォルト型はbool、rune、int、float64、complex128、またはstringであり、それぞれブール、rune、整数、浮動小数点、複素、または文字列定数に応じて異なります。

実装制限：数値定数は言語内で任意の精度を持ちますが、コンパイラは内部表現を使用して制限された精度で実装する場合があります。とはいえ、すべての実装は次のことを行わなければなりません：

• 整数定数を少なくとも256ビットで表現する。
• 浮動小数点定数、複素定数の部分を含む、少なくとも256ビットの仮数と少なくとも16ビットの符号付き2進数指数で表現する。
• 整数定数を正確に表現できない場合はエラーを出す。
• 浮動小数点または複素定数をオーバーフローのために表現できない場合はエラーを出す。
• 精度の制限により浮動小数点または複素定数を表現できない場合は、最も近い表現可能な定数に丸める。

これらの要件は、リテラル定数と定数式の評価結果の両方に適用されます。

変数

変数は値を保持するためのストレージ位置です。許可される値のセットは、変数の型によって決まります。

変数宣言または、関数のパラメータと結果の場合、関数宣言または関数リテラルのシグネチャは、名前付き変数のストレージを予約します。組み込み関数newを呼び出すか、複合リテラルのアドレスを取得すると、実行時に変数のストレージが割り当てられます。このような匿名変数は、（おそらく暗黙的な）ポインタ間接参照を介して参照されます。

構造化変数の配列、スライス、および構造体型には、個別にアドレス指定できる要素とフィールドがあります。各要素は変数のように機能します。

変数の静的型（または単に型）は、その宣言で与えられた型、new呼び出しまたは複合リテラルで提供された型、または構造化変数の要素の型です。インターフェース型の変数は、実行時に変数に割り当てられた値の（非インターフェース）型である異なる動的型も持ちます（値が事前宣言された識別子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

変数の値は、式内で変数を参照することによって取得されます。これは、変数に代入された最も最近の値です。変数にまだ値が割り当てられていない場合、その値はその型のゼロ値です。

型

型は、特定の値に固有の操作とメソッドを持つ値のセットを決定します。型には型名が付けられる場合があり、型がジェネリックである場合は型引数が続かなければなりません。型は、既存の型から型を構成する型リテラルを使用して指定することもできます。

=  [  ] |  | "("  ")" .
  =  |  .
  = "["  [ "," ] "]" .
  =  { ","  } .
   =  |  |  |  |  |
   |  |  .

言語は特定の型名を事前宣言します。他の型名は、型宣言や型パラメータリストで導入されます。複合型—配列、構造体、ポインタ、関数、インターフェース、スライス、マップ、およびチャネル型—は、型リテラルを使用して構築できます。

事前宣言された型、定義された型、および型パラメータは名前付き型と呼ばれます。エイリアスは、エイリアス宣言で与えられた型が名前付き型である場合、名前付き型を示します。

ブール型

ブール型は、事前宣言された定数trueおよびfalseによって示されるブール真理値のセットを表します。事前宣言されたブール型はboolであり、これは定義された型です。

数値型

整数、浮動小数点、または複素型は、それぞれ整数、浮動小数点、または複素値のセットを表します。これらは総称して数値型と呼ばれます。事前宣言されたアーキテクチャ非依存の数値型は：

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     either 32 or 64 bits
int      same size as uint
uintptr  an unsigned integer large enough to store the uninterpreted bits of a pointer value

ポータビリティの問題を避けるために、すべての数値型は定義された型であり、したがってbyteを除いて異なります。byteはuint8のエイリアスであり、runeはint32のエイリアスです。異なる数値型が式や代入で混在する場合、明示的な変換が必要です。たとえば、int32とintは、特定のアーキテクチャで同じサイズを持っている場合でも、同じ型ではありません。

文字列型

文字列型は、文字列値のセットを表します。文字列値は（空である可能性のある）バイトのシーケンスです。バイトの数は文字列の長さと呼ばれ、決して負にはなりません。文字列は不変です：一度作成されると、文字列の内容を変更することは不可能です。事前宣言された文字列型はstringであり、これは定義された型です。

文字列sの長さは、組み込み関数lenを使用して発見できます。文字列が定数である場合、長さはコンパイル時定数です。文字列のバイトには、整数インデックス0からlen(s)-1までアクセスできます。そのような要素のアドレスを取得することは不正です。s[i]が文字列のi番目のバイトである場合、&s[i]は無効です。

配列型

配列は、単一の型の要素の番号付きシーケンスであり、要素型と呼ばれます。要素の数は配列の長さと呼ばれ、決して負にはなりません。

= "["  "]"  .
 =  .
 =  .

長さは配列の型の一部であり、非負の定数として評価されなければなりません。配列aの長さは、組み込み関数lenを使用して発見できます。要素には、整数インデックス0からlen(a)-1までアクセスできます。配列型は常に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をコンポーネントとして含む型を持つこともできません。これらの含まれる型が配列または構造体型のみである場合、直接的または間接的に。

// invalid array types
type (
    T1 [10]T1                 // element type of T1 is T1
    T2 [10]struct{ f T2 }     // T2 contains T2 as component of a struct
    T3 [10]T4                 // T3 contains T3 as component of a struct in T4
    T4 struct{ f T3 }         // T4 contains T4 as component of array T3 in a struct
)
// valid array types
type (
    T5 [10]*T5                // T5 contains T5 as component of a pointer
    T6 [10]func() T6          // T6 contains T6 as component of a function type
    T7 [10]struct{ f []T7 }   // T7 contains T7 as component of a slice in a struct
)

スライス型

スライスは、基になる配列の連続したセグメントの記述子であり、その配列からの要素の番号付きシーケンスへのアクセスを提供します。スライスタイプは、その要素型の配列のすべてのスライスのセットを示します。要素の数はスライスの長さと呼ばれ、決して負にはなりません。初期化されていないスライスの値はnilです。

= "[" "]"  .

スライスsの長さは、組み込み関数lenを使用して発見できます。配列とは異なり、実行中に変更される可能性があります。要素には、整数インデックス0からlen(s)-1までアクセスできます。特定の要素のスライスインデックスは、基になる配列の同じ要素のインデックスよりも小さい場合があります。

スライスは、一度初期化されると、その要素を保持する基になる配列に常に関連付けられます。したがって、スライスはその配列および同じ配列の他のスライスとストレージを共有します。対照的に、異なる配列は常に異なるストレージを表します。

スライスの基になる配列は、スライスの終わりを超えて拡張される場合があります。容量は、その範囲の測定値です：スライスの長さとスライスを超えた配列の長さの合計です。その容量までの長さのスライスは、元のスライスからスライスを作成することによって作成できます。スライスaの容量は、組み込み関数cap(a)を使用して発見できます。

特定の要素型Tの新しい初期化されたスライス値は、組み込み関数makeを使用して作成できます。この関数は、スライスタイプと長さおよびオプションで容量を指定するパラメータを受け取ります。makeで作成されたスライスは、常に新しい隠れた配列を割り当て、その返されたスライス値が参照します。つまり、実行すると

make([]T, length, capacity)

は、配列を割り当ててスライスするのと同じスライスを生成します。したがって、これらの2つの式は等価です：

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

配列と同様に、スライスは常に1次元ですが、高次元オブジェクトを構成するために構成されることがあります。配列の配列では、内部配列は構造上常に同じ長さですが、スライスのスライス（または配列のスライス）では、内部の長さは動的に変化する可能性があります。さらに、内部スライスは個別に初期化する必要があります。

Struct types

A struct is a sequence of named elements, called fields, each of which has a name and a type. Field names may be specified explicitly (IdentifierList) or implicitly (EmbeddedField). Within a struct, non-blank field names must be unique.

= "struct" "{" {  ";" } "}" .
   = (  | ) [  ] .
 = [ "*" ]  [  ] .
   =  .

// An empty struct.
struct {}
// A struct with 6 fields.
struct {
    x, y int
    u float32
    _ float32  // padding
    A *[]int
    F func()
}

A field declared with a type but no explicit field name is called an embedded field. An embedded field must be specified as a type name T or as a pointer to a non-interface type name *T, and T itself may not be a pointer type. The unqualified type name acts as the field name.

// A struct with four embedded fields of types T1, *T2, P.T3 and *P.T4
struct {
    T1        // field name is T1
    *T2       // field name is T2
    P.T3      // field name is T3
    *P.T4     // field name is T4
    x, y int  // field names are x and y
}

The following declaration is illegal because field names must be unique in a struct type:

struct {
    T     // conflicts with embedded field *T and *P.T
    *T    // conflicts with embedded field T and *P.T
    *P.T  // conflicts with embedded field T and *T
}

A field or method f of an embedded field in a struct x is called promoted if x.f is a legal selector that denotes that field or method f.

Promoted fields act like ordinary fields of a struct except that they cannot be used as field names in composite literals of the struct.

Given a struct type S and a named type T, promoted methods are included in the method set of the struct as follows:

• If S contains an embedded field T, the method sets of S and *S both include promoted methods with receiver T. The method set of *S also includes promoted methods with receiver *T.

• If S contains an embedded field *T, the method sets of S and *S both include promoted methods with receiver T or *T.

  A field declaration may be followed by an optional string literal tag, which becomes an attribute for all the fields in the corresponding field declaration. An empty tag string is equivalent to an absent tag. The tags are made visible through a reflection interface and take part in type identity for structs but are otherwise ignored.

struct {
    x, y float64 ""  // an empty tag string is like an absent tag
    name string  "any string is permitted as a tag"
    _    [4]byte "ceci n'est pas un champ de structure"
}
// A struct corresponding to a TimeStamp protocol buffer.
// The tag strings define the protocol buffer field numbers;
// they follow the convention outlined by the reflect package.
struct {
    microsec  uint64 `protobuf:"1"`
    serverIP6 uint64 `protobuf:"2"`
}

A struct type T may not contain a field of type T, or of a type containing T as a component, directly or indirectly, if those containing types are only array or struct types.

// invalid struct types
type (
    T1 struct{ T1 }            // T1 contains a field of T1
    T2 struct{ f [10]T2 }      // T2 contains T2 as component of an array
    T3 struct{ T4 }            // T3 contains T3 as component of an array in struct T4
    T4 struct{ f [10]T3 }      // T4 contains T4 as component of struct T3 in an array
)
// valid struct types
type (
    T5 struct{ f *T5 }         // T5 contains T5 as component of a pointer
    T6 struct{ f func() T6 }   // T6 contains T6 as component of a function type
    T7 struct{ f [10][]T7 }    // T7 contains T7 as component of a slice in an array
)

ポインタ型

ポインタ型は、特定の型のすべての変数へのポインタの集合を示し、その型をポインタの基本型と呼びます。初期化されていないポインタの値はnilです。

= "*"  .
   =  .

*Point
*[4]int

関数型

関数型は、同じパラメータ型と結果型を持つすべての関数の集合を示します。関数型の初期化されていない変数の値はnilです。

= "func"  .
   =  [  ] .
   =  |  .
   = "(" [  [ "," ] ] ")" .
  =  { ","  } .
  = [  ] [ "..." ]  .

パラメータまたは結果のリスト内では、名前（IdentifierList）はすべて存在するか、すべて存在しない必要があります。存在する場合、各名前は指定された型の1つの項目（パラメータまたは結果）を表し、署名内のすべての非空白の名前は一意でなければなりません。存在しない場合、各型はその型の1つの項目を表します。パラメータおよび結果リストは常に括弧で囲まれますが、名前のない結果が正確に1つだけある場合は、括弧なしの型として書くことができます。

関数シグネチャの最後の受け入れパラメータは、...で接頭辞が付けられた型を持つことがあります。そのようなパラメータを持つ関数は可変引数と呼ばれ、そのパラメータに対してゼロまたはそれ以上の引数で呼び出すことができます。

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)

インターフェース型

インターフェース型は型集合を定義します。インターフェース型の変数は、インターフェースの型集合にある任意の型の値を格納できます。そのような型はインターフェースを実装すると言います。インターフェース型の初期化されていない変数の値はnilです。

= "interface" "{" {  ";" } "}" .
  =  |  .
   =   .
   =  .
   =  { "|"  } .
   =  |  .
 = "~"  .

インターフェース型はインターフェース要素のリストによって指定されます。インターフェース要素はメソッドまたは型要素のいずれかであり、型要素は1つ以上の型項目の和集合です。型項目は単一の型または単一の基礎型です。

基本インターフェース

最も基本的な形のインターフェースは、（空である可能性のある）メソッドのリストを指定します。そのようなインターフェースによって定義される型集合は、すべてのメソッドを実装する型の集合であり、対応するメソッド集合はインターフェースによって指定されたメソッドで構成されます。メソッドのリストによって完全に定義できる型集合を持つインターフェースは基本インターフェースと呼ばれます。

// A simple File interface.
interface {
    Read([]byte) (int, error)
    Write([]byte) (int, error)
    Close() error
}

明示的に指定された各メソッドの名前は一意であり、空白であってはなりません。

interface {
    String() string
    String() string  // illegal: String not unique
    _(x int)         // illegal: method must have non-blank name
}

複数の型がインターフェースを実装することができます。たとえば、2つの型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 declaration内に現れます：

type Locker interface {
    Lock()
    Unlock()
}

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

 <a name="Embedded_interfaces"></a>
#### 埋め込みインターフェース
やや一般的な形で、インターフェース`````T`````は、（資格のある）インターフェース型名`````E`````をインターフェース要素として使用することができます。これは、`````E`````を`````T`````に*埋め込む*と呼ばれます[[Go 1.14](#Go_1.14)]。`````T`````の型集合は、`````T`````の明示的に宣言されたメソッドによって定義された型集合と、`````T`````の埋め込まれたインターフェースの型集合の*交差*です。言い換えれば、`````T`````の型集合は、`````T`````の明示的に宣言されたすべてのメソッドと、`````E`````のすべてのメソッドを実装するすべての型の集合です[[Go 1.18](#Go_1.18)]。   
``````bash
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's methods are Read, Write, and 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()  // illegal: signatures of Reader.Close and Close are different
}

一般インターフェース

最も一般的な形では、インターフェース要素は任意の型項目T、または基礎型Tを指定する~Tの形式の項目、または項目の和t1|t2|…|tnのいずれかである可能性があります[Go 1.18]。メソッド仕様とともに、これらの要素はインターフェースの型集合を次のように正確に定義することを可能にします：

• 空のインターフェースの型集合は、すべての非インターフェース型の集合です。
• 非空インターフェースの型集合は、そのインターフェース要素の型集合の交差です。
• メソッド仕様の型集合は、そのメソッドを含むすべての非インターフェース型の集合です。
• 非インターフェース型項目の型集合は、その型のみを含む集合です。
• ~Tの形式の項目の型集合は、基礎型がTであるすべての型の集合です。
• 項目の和t1|t2|…|tnの型集合は、項目の型集合の和です。

「すべての非インターフェース型の集合」という定義は、現在のプログラムで宣言されたすべての（非インターフェース）型だけでなく、すべての可能なプログラムのすべての可能な型を指し、したがって無限です。同様に、特定のメソッドを実装するすべての非インターフェース型の集合が与えられた場合、それらの型のメソッド集合の交差は、たとえ現在のプログラム内のすべての型がそのメソッドを別のメソッドとペアにする場合でも、正確にそのメソッドを含みます。

構造上、インターフェースの型集合には決してインターフェース型が含まれません。

// An interface representing only the type int.
interface {
    int
}
// An interface representing all types with underlying type int.
interface {
    ~int
}
// An interface representing all types with underlying type int that implement the String method.
interface {
    ~int
    String() string
}
// An interface representing an empty type set: there is no type that is both an int and a string.
interface {
    int
    string
}

``````bash
type MyInt int
interface {
    ~[]byte  // the underlying type of []byte is itself
    ~MyInt   // illegal: the underlying type of MyInt is not MyInt
    ~error   // illegal: error is an interface
}
`

和の要素は型集合の和を示します：

// The Float interface represents all floating-point types
// (including any named types whose underlying types are
// either float32 or float64).
type Float interface {
    ~float32 | ~float64
}

``````bash
interface {
    P                // illegal: P is a type parameter
    int | ~P         // illegal: P is a type parameter
    ~int | MyInt     // illegal: the type sets for ~int and MyInt are not disjoint (~int includes MyInt)
    float32 | Float  // overlapping type sets but Float is an interface
}
`

実装制限：和（1つ以上の項目を持つ）は、事前に宣言された識別子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を含む、またはTを埋め込む型要素を直接または間接的に埋め込むことはできません。

// illegal: Bad may not embed itself
type Bad interface {
    Bad
}
// illegal: Bad1 may not embed itself using Bad2
type Bad1 interface {
    Bad2
}
type Bad2 interface {
    Bad1
}
// illegal: Bad3 may not embed a union containing Bad3
type Bad3 interface {
    ~int | ~string | Bad3
}
// illegal: Bad4 may not embed an array containing Bad4 as element type
type Bad4 interface {
    [10]Bad4
}

インターフェースの実装

型Tは、インターフェースIを実装します。

• Tはインターフェースでなく、Iの型集合の要素であるか、または

• Tはインターフェースであり、Tの型集合がIの型集合の部分集合である場合。

  型Tの値は、Tがインターフェースを実装している場合、インターフェースを実装します。
  

マップ型

マップは、要素型と呼ばれる1つの型の要素の無秩序なグループであり、キー型と呼ばれる別の型の一意のキーの集合によってインデックス付けされます。初期化されていないマップの値はnilです。

= "map" "["  "]"  .
   =  .

比較演算子==と!=は、キー型のオペランドに対して完全に定義されている必要があります。したがって、キー型は関数、マップ、またはスライスであってはなりません。キー型がインターフェース型である場合、これらの比較演算子は動的キー値に対して定義されている必要があります。失敗すると、ランタイムパニックが発生します。

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マップは、空のマップと同等ですが、要素を追加することはできません。

チャネル型

チャネルは、並行して実行される関数が指定された要素型の値を送信および受信するためのメカニズムを提供します。初期化されていないチャネルの値はnilです。

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

オプションの<-演算子は、チャネルの方向、送信または受信を指定します。方向が指定されている場合、チャネルは方向性であり、そうでない場合は双方向です。チャネルは、代入または明示的な変換によって、送信または受信のみに制約される場合があります。

chan T          // can be used to send and receive values of type T
chan<- float64  // can only be used to send float64s
<-chan int      // can only be used to receive ints

``````bash
chan<- chan int    // same as chan<- (chan int)
chan<- <-chan int  // same as chan<- (<-chan int)
<-chan <-chan int  // same as <-chan (<-chan int)
chan (<-chan int)
`

新しい初期化されたチャネル値は、組み込み関数makeを使用して作成され、チャネル型とオプションの容量を引数として取ります：

make(chan int, 100)

容量は、要素の数で、チャネル内のバッファのサイズを設定します。容量がゼロまたは存在しない場合、チャネルはバッファなしであり、送信者と受信者の両方が準備が整ったときのみ通信が成功します。そうでない場合、チャネルはバッファ付きであり、バッファが満杯でない場合（送信）または空でない場合（受信）にブロックなしで通信が成功します。nilチャネルは、通信の準備ができていないことはありません。

チャネルは、組み込み関数closeを使用して閉じることができます。受信演算子の多値代入形式は、受信した値がチャネルが閉じる前に送信されたかどうかを報告します。

単一のチャネルは、送信文、受信操作、および組み込み関数capおよびlenへの呼び出しで、任意の数のゴルーチンによって使用され、さらなる同期なしに使用されます。チャネルは先入れ先出しのキューとして機能します。たとえば、1つのゴルーチンがチャネルに値を送信し、2つ目のゴルーチンがそれらを受信する場合、値は送信された順序で受信されます。

型と値の特性

基礎型

各型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) { … }

 <a name="Core_types"></a>
### コア型
各非インターフェース型`````T`````には*コア型*があり、これは`````T`````の[基礎型](#Underlying_types)と同じです。   
 インターフェース`````T`````には、次の条件のいずれかが満たされる場合にコア型があります：   
- 1*.*  単一の型`````U`````があり、これは`````T`````の[type set](#Interface_types)内のすべての型の[基礎型](#Underlying_types)です。  
- 2*.*  `````T`````の型集合には、同一の要素型`````E`````を持つ[チャネル型](#Channel_types)のみが含まれ、すべての方向性チャネルが同じ方向を持っています。  
 他のインターフェースにはコア型はありません。   
 インターフェースのコア型は、満たされる条件に応じて、次のいずれかです：   
- 1*.*  型`````U`````; または  
- 2*.*  `````T`````が双方向チャネルのみを含む場合、または方向性チャネルの方向に応じて`````chan<- E`````または`````<-chan E`````の型。  
 定義上、コア型は[定義型](#Type_definitions)、[型パラメータ](#Type_parameter_declarations)、または[インターフェース型](#Interface_types)ではありません。   
 コア型を持つインターフェースの例：   
``````bash
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{}                               // no single underlying type
interface{ Celsius|float64 }              // no single underlying type
interface{ chan int | chan<- string }     // channels have different element types
interface{ <-chan int | chan<- int }      // directional channels have different directions

一部の操作（スライス式、appendおよびcopy）は、バイトスライスや文字列を受け入れるやや緩い形式のコア型に依存しています。具体的には、Tの型集合内のすべての型の基礎型が[]byteとstringの2つの型である場合、Tのコア型はbytestringと呼ばれます。

``````bash
interface{ int }                          // int (same as ordinary core type)
interface{ []byte | string }              // bytestring
interface{ ~[]byte | myString }           // bytestring
`

 <a name="Type_identity"></a>
### 型の同一性
二つの型は、*同一*または*異なる*です。   
 [名前付き型](#Types)は、他のどの型とも常に異なります。そうでない場合、二つの型は、[基礎](#Types)型リテラルが構造的に同等である場合に同一です。つまり、同じリテラル構造を持ち、対応するコンポーネントが同一の型を持つ必要があります。詳細は以下の通りです:   
- 二つの配列型は、要素型が同一であり、配列の長さが同じであれば同一です。 
- 二つのスライスタイプは、要素型が同一であれば同一です。 
- 二つの構造体型は、フィールドの順序が同じであり、対応するフィールドが同じ名前を持ち、同一の型および同一のタグを持つ場合に同一です。[非エクスポート](#Exported_identifiers)フィールド名は、異なるパッケージからは常に異なります。 
- 二つのポインタ型は、基礎型が同一であれば同一です。 
- 二つの関数型は、パラメータと結果の数が同じで、対応するパラメータと結果の型が同一であり、両方の関数が可変長引数であるか、どちらもそうでない場合に同一です。パラメータと結果の名前は一致する必要はありません。 
- 二つのインターフェース型は、同じ型セットを定義している場合に同一です。  
- 二つのマップ型は、キー型と要素型が同一であれば同一です。 
- 二つのチャネル型は、要素型が同一であり、同じ方向を持つ場合に同一です。 
- 二つの[インスタンス化された](#Instantiations)型は、定義された型とすべての型引数が同一であれば同一です。
 宣言が与えられた場合   
``````bash
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 は異なります。なぜなら、異なるtype definitionsによって作成された新しい型だからです。func(int, float64) *B0 と func(x int, y float64) *[]string は異なります。なぜなら B0 が []string と異なるからです。そして P1 と P2 は異なります。なぜなら、異なる型パラメータだからです。D0[int, string] と struct{ x int; y string } は異なります。なぜなら、前者はインスタンス化された定義型であり、後者は型リテラルだからです（しかし、依然として代入可能です）。

代入可能性

型 V の値 x は、型 T の変数に代入可能です（”x は T に代入可能”）場合、次のいずれかの条件が適用されます:

• V と T は同一です。
• V と T は同一の基礎型を持ちますが、型パラメータではなく、V または T のいずれかが名前付き型ではありません。
• V と T は、同一の要素型を持つチャネル型であり、V は双方向チャネルであり、V または T のいずれかが名前付き型ではありません。
• T はインターフェース型ですが、型パラメータではなく、x は T を実装します。
• x は事前宣言された識別子 nil であり、T はポインタ、関数、スライス、マップ、チャネル、またはインターフェース型ですが、型パラメータではありません。

• x は型 T の値によって表現可能な無型定数です。

  さらに、x の型 V または T が型パラメータである場合、x は型 T の変数に代入可能です。次のいずれかの条件が適用されます:

• x は事前宣言された識別子 nil であり、T は型パラメータであり、x は T の型セット内の各型に代入可能です。

• V は名前付き型ではなく、T は型パラメータであり、x は T の型セット内の各型に代入可能です。
• V は型パラメータであり、T は名前付き型ではなく、V の型セット内の各型の値は T に代入可能です。
  

表現可能性

無型定数 x は、型 T の値によって表現可能です。ここで、T は型パラメータではありません。次のいずれかの条件が適用されます:

• x は T によって決定された値のセットに含まれます。
• T は浮動小数点型であり、x は T の精度にオーバーフローなしで丸めることができます。丸めはIEEE 754の偶数丸めルールを使用しますが、IEEEの負のゼロはさらに簡略化されて符号なしゼロになります。定数値は、IEEEの負のゼロ、NaN、または無限大を生成することはありません。

• T は複素型であり、x のコンポーネント real(x) と imag(x) は T のコンポーネント型（float32 または float64）の値によって表現可能です。

  T が型パラメータである場合、x は型 T の値によって表現可能です。x は T の型セット内の各型の値によって表現可能です。

x                   T           x is representable by a value of T because
'a'                 byte        97 is in the set of byte values
97                  rune        rune is an alias for int32, and 97 is in the set of 32-bit integers
"foo"               string      "foo" is in the set of string values
1024                int16       1024 is in the set of 16-bit integers
42.0                byte        42 is in the set of unsigned 8-bit integers
1e10                uint64      10000000000 is in the set of unsigned 64-bit integers
2.718281828459045   float32     2.718281828459045 rounds to 2.7182817 which is in the set of float32 values
-1e-1000            float64     -1e-1000 rounds to IEEE -0.0 which is further simplified to 0.0
0i                  int         0 is an integer value
(42 + 0i)           float32     42.0 (with zero imaginary part) is in the set of float32 values

x                   T           x is not representable by a value of T because
0                   bool        0 is not in the set of boolean values
'a'                 string      'a' is a rune, it is not in the set of string values
1024                byte        1024 is not in the set of unsigned 8-bit integers
-1                  uint16      -1 is not in the set of unsigned 16-bit integers
1.1                 int         1.1 is not an integer value
42i                 float32     (0 + 42i) is not in the set of float32 values
1e1000              float64     1e1000 overflows to IEEE +Inf after rounding

メソッドセット

型のメソッドセットは、その型のオペランドで呼び出すことができるメソッドを決定します。すべての型には、（空である可能性のある）メソッドセットが関連付けられています:

• 定義型のメソッドセット T は、受信者型 T で宣言されたすべてのメソッドで構成されます。
• 定義型 T へのポインタのメソッドセット（T がポインタでもインターフェースでもない場合）は、受信者 *T または T で宣言されたすべてのメソッドのセットです。

• インターフェース型のメソッドセットは、インターフェースの型セット内の各型のメソッドセットの交差点です（結果のメソッドセットは通常、インターフェース内で宣言されたメソッドのセットです）。

  構造体（および構造体へのポインタ）に埋め込まれたフィールドに関しては、構造体型のセクションで説明されている追加のルールが適用されます。他のすべての型は空のメソッドセットを持ちます。

  メソッドセット内の各メソッドは、一意な非空白のメソッド名を持たなければなりません。
  

ブロック

ブロックは、対応する波括弧内の宣言と文の空でないシーケンスです。

= "{"  "}" .
 = {  ";" } .

ソースコード内の明示的なブロックに加えて、暗黙のブロックもあります:

• 1. ユニバースブロックは、すべてのGoソーステキストを含みます。
• 2. 各パッケージには、そのパッケージのすべてのGoソーステキストを含むパッケージブロックがあります。
• 3. 各ファイルには、そのファイル内のすべてのGoソーステキストを含むファイルブロックがあります。
• 4. 各“if”、“for”、および“switch”文は、それぞれ独自の暗黙のブロックに含まれると見なされます。

• 5. 各“switch”または“select”文の各節は、暗黙のブロックとして機能します。

  ブロックはネストされ、スコープに影響を与えます。
  

宣言とスコープ

宣言は、非空白の識別子を定数、型、型パラメータ、変数、関数、ラベル、またはパッケージにバインドします。プログラム内のすべての識別子は宣言されなければなりません。同じブロック内で同じ識別子を二度宣言することはできず、ファイルとパッケージブロックの両方で宣言することはできません。

空白識別子は、宣言内で他の識別子のように使用できますが、バインディングを導入せず、したがって宣言されません。パッケージブロック内では、識別子 init はinit 関数の宣言にのみ使用でき、空白識別子のように新しいバインディングを導入しません。

=  |  |  .
  =  |  |  .

宣言された識別子のスコープは、その識別子が指定された定数、型、変数、関数、ラベル、またはパッケージを示すソーステキストの範囲です。

Goはブロックを使用して字句的にスコープを持ちます:

• 1. 事前宣言された識別子のスコープはユニバースブロックです。
• 2. 定数、型、変数、または関数（ただしメソッドではない）をトップレベル（任意の関数の外）で宣言した場合、そのスコープはパッケージブロックです。
• 3. インポートされたパッケージのパッケージ名のスコープは、インポート宣言を含むファイルのファイルブロックです。
• 4. メソッド受信者、関数パラメータ、または結果変数を示す識別子のスコープは、関数本体です。
• 5. 関数の型パラメータを示す識別子のスコープは、関数名の後から始まり、関数本体の終わりで終了します。
• 6. 型の型パラメータを示す識別子のスコープは、型名の後から始まり、TypeSpecの終わりで終了します。
• 7. 関数内で宣言された定数または変数の識別子のスコープは、ConstSpecまたはVarSpec（短い変数宣言の場合はShortVarDecl）の終わりから始まり、最も内側の含まれるブロックの終わりで終了します。

• 8. 関数内で宣言された型識別子のスコープは、TypeSpec内の識別子から始まり、最も内側の含まれるブロックの終わりで終了します。

  ブロック内で宣言された識別子は、内側のブロックで再宣言できます。内側の宣言の識別子がスコープ内にある間、それは内側の宣言によって宣言されたエンティティを示します。

  パッケージ句は宣言ではありません。パッケージ名はどのスコープにも現れません。その目的は、同じパッケージに属するファイルを識別し、インポート宣言のデフォルトのパッケージ名を指定することです。
  

ラベルスコープ

ラベルはラベル付き文によって宣言され、“break”、“continue”、および“goto”文で使用されます。使用されないラベルを定義することは違法です。他の識別子とは異なり、ラベルはブロックスコープを持たず、ラベルでない識別子と衝突しません。ラベルのスコープは、宣言された関数の本体であり、ネストされた関数の本体は含まれません。

空白識別子

空白識別子は、アンダースコア文字 _ で表されます。これは、通常の（非空白）識別子の代わりに匿名のプレースホルダーとして機能し、宣言、オペランド、および代入文で特別な意味を持ちます。

事前宣言された識別子

次の識別子は、ユニバースブロック内で暗黙的に宣言されます [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. 識別子の名前の最初の文字がUnicodeの大文字（Unicode文字カテゴリLu）である; そして

• 2. 識別子がパッケージブロック内で宣言されているか、フィールド名またはメソッド名である。

  その他のすべての識別子はエクスポートされません。
  

識別子の一意性

識別子のセットが与えられた場合、識別子は一意と呼ばれ、セット内の他のすべての識別子と異なる場合です。二つの識別子は、異なるスペルであるか、異なるパッケージに存在し、エクスポートされていない場合に異なります。そうでなければ、同じです。

定数宣言

定数宣言は、識別子のリスト（定数の名前）を定数式の値にバインドします。識別子の数は式の数と等しくなければならず、左側のn番目の識別子は、右側のn番目の式の値にバインドされます。

= "const" (  | "(" {  ";" } ")" ) .
   =  [ [  ] "="  ] .
 =  { ","  } .
 =  { ","  } .

型が指定されている場合、すべての定数は指定された型を取り、式はその型に代入可能でなければなりません。型は型パラメータであってはなりません。型が省略されている場合、定数は対応する式の個々の型を取ります。式の値が無型定数である場合、宣言された定数は無型のままであり、定数識別子は定数値を示します。たとえば、式が浮動小数点リテラルである場合、定数識別子は浮動小数点定数を示します。たとえリテラルの小数部分がゼロであってもです。

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 は、連続する無型整数定数を表します。その値は、その定数宣言内のそれぞれのConstSpecのインデックスで、ゼロから始まります。関連する定数のセットを構築するために使用できます:

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

定義により、同じConstSpec内でのiotaの複数の使用はすべて同じ値を持ちます:

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)
)

この最後の例は、最後の非空の式リストの暗黙の繰り返しを利用しています。

型宣言

型宣言は、識別子、型名を型にバインドします。型宣言には、エイリアス宣言と型定義の二つの形式があります。

= "type" (  | "(" {  ";" } ")" ) .
 =  |  .

エイリアス宣言

エイリアス宣言は、識別子を指定された型にバインドします [Go 1.9]。

=  "="  .

識別子のスコープ内では、それは型のエイリアスとして機能します。

type (
    nodeList = []*Node  // nodeList and []*Node are identical types
    Polar    = polar    // Polar and polar denote identical types
)

型定義

型定義は、指定された型と同じ基礎型および操作を持つ新しい異なる型を作成し、識別子、型名をそれにバインドします。

=  [  ]  .

新しい型は定義型と呼ばれます。それは、作成元の型を含む他のどの型とも異なるです。

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)
}

定義型には、関連付けられたメソッドを持つことができます。指定された型にバインドされたメソッドを継承することはありませんが、インターフェース型または合成型の要素のメソッドセットは変更されません:

// A Mutex is a data type with two methods, Lock and Unlock.
type Mutex struct         { /* Mutex fields */ }
func (m *Mutex) Lock()    { /* Lock implementation */ }
func (m *Mutex) Unlock()  { /* Unlock implementation */ }
// NewMutex has the same composition as Mutex but its method set is empty.
type NewMutex Mutex
// The method set of PtrMutex's underlying type *Mutex remains unchanged,
// but the method set of PtrMutex is empty.
type PtrMutex *Mutex
// The method set of *PrintableMutex contains the methods
// Lock and Unlock bound to its embedded field Mutex.
type PrintableMutex struct {
    Mutex
}
// MyBlock is an interface type that has the same method set as 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    // illegal: P is a type parameter
func f[T any]() {
    type L T   // illegal: T is a type parameter declared by the enclosing function
}

ジェネリック型にもメソッドが関連付けられる場合があります。この場合、メソッド受信者は、ジェネリック型定義に存在する型パラメータの数と同じ数の型パラメータを宣言しなければなりません。

// The method Len returns the number of elements in the linked list l.
func (l *List[T]) Len() int  { … }

型パラメータ宣言

型パラメータリストは、ジェネリック関数または型宣言の型パラメータを宣言します。型パラメータリストは、通常の関数パラメータリストのように見えますが、型パラメータ名はすべて存在し、リストは括弧ではなく角括弧で囲まれています [Go 1.18]。

= "["  [ "," ] "]" .
   =  { ","  } .
   =   .

リスト内のすべての非空白名は一意でなければなりません。各名前は型パラメータを宣言し、それは宣言内の（まだ）未知の型のプレースホルダーとして機能する新しい異なる名前付き型です。型パラメータは、ジェネリック関数または型のインスタンス化時に型引数に置き換えられます。

[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 refers to itself
type T2[P interface{ T2[int] }] …     // illegal: T2 refers to itself
type T3[P interface{ m(T3[int])}] …   // illegal: T3 refers to itself
type T4[P T5[P]] …                    // illegal: T4 refers to T5 and
type T5[P T4[P]] …                    //          T5 refers to T4
type T6[P int] struct{ f *T6[P] }     // ok: reference to T6 is not in type parameter list

型制約

型制約は、対応する型パラメータの許可される型引数のセットを定義し、その型パラメータの値がサポートする操作を制御するインターフェースです [Go 1.18]。

=  .

制約が interface{E} の形のインターフェースリテラルであり、E が埋め込まれた型要素（メソッドではない）である場合、型パラメータリスト内では、囲む interface{ … } を省略することができます。

[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                          // implements comparable (int is strictly comparable)
[]byte                       // does not implement comparable (slices cannot be compared)
interface{}                  // does not implement comparable (see above)
interface{ ~int | ~string }  // type parameter only: implements comparable (int, string types are strictly comparable)
interface{ comparable }      // type parameter only: implements comparable (comparable implements itself)
interface{ ~int | ~[]byte }  // type parameter only: does not implement comparable (slices are not comparable)
interface{ ~struct{ any } }  // type parameter only: does not implement comparable (field any is not strictly comparable)

comparable インターフェースおよび comparable を（直接的または間接的に）埋め込むインターフェースは、型制約としてのみ使用できます。それらは、値や変数の型、または他の非インターフェース型のコンポーネントにはなれません。

型制約を満たす

型引数 T は、型制約 C を満たす場合、T が C によって定義された型セットの要素である。すなわち、T が C を実装する場合です。例外として、厳密に比較可能な型制約は、比較可能（必ずしも厳密に比較可能でない）型引数によっても満たされる場合があります [Go 1.20]。より正確には:

型 T は、制約 C を満たす場合、

• T が C を実装する; または
• C は interface{ comparable; E } の形で書くことができ、E は基本インターフェースであり、T は比較可能であり、E を実装する。

type argument      type constraint                // constraint satisfaction
int                interface{ ~int }              // satisfied: int implements interface{ ~int }
string             comparable                     // satisfied: string implements comparable (string is strictly comparable)
[]byte             comparable                     // not satisfied: slices are not comparable
any                interface{ comparable; int }   // not satisfied: any does not implement interface{ int }
any                comparable                     // satisfied: any is comparable and implements the basic interface any
struct{f any}      comparable                     // satisfied: struct{f any} is comparable and implements the basic interface any
any                interface{ comparable; m() }   // not satisfied: any does not implement the basic interface interface{ m() }
interface{ m() }   interface{ comparable; m() }   // satisfied: interface{ m() } is comparable and implements the basic interface interface{ m() }

制約満足ルールの例外により、型パラメータ型のオペランドを比較すると、実行時にパニックが発生する可能性があります（比較可能な型パラメータは常に厳密に比較可能です）。

変数宣言

変数宣言は、一つ以上の変数を作成し、それに対応する識別子をバインドし、各変数に型と初期値を与えます。

= "var" (  | "(" {  ";" } ")" ) .
   =  (  [ "="  ] | "="  ) .

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

実装制限: コンパイラは、変数が決して使用されない場合、関数本体内で変数を宣言することを違法にすることがあります。

短い変数宣言

短い変数宣言は、次の構文を使用します:

=  ":="  .

これは、初期化子式を持つ通常の変数宣言の省略形ですが、型はありません:

"var" IdentifierList "=" ExpressionList .

i, j := 0, 10
f := func() int { return 7 }
ch := make(chan int)
r, w, _ := os.Pipe()  // os.Pipe() returns a connected pair of Files and an error, if any
_, y, _ := coord(p)   // coord() returns three values; only interested in y coordinate

通常の変数宣言とは異なり、短い変数宣言は、元々同じブロック内で同じ型で宣言された場合に限り、変数を再宣言することができます。少なくとも一つの非空白変数が新しいものである必要があります。その結果、再宣言は多変数の短い宣言にのみ現れることができます。再宣言は新しい変数を導入するのではなく、元の変数に新しい値を割り当てるだけです。:= の左側の非空白変数名は一意でなければなりません。

field1, offset := nextField(str, 0)
field2, offset := nextField(str, offset)  // redeclares offset
x, y, x := 1, 2, 3                        // illegal: x repeated on left side of :=

短い変数宣言は、関数内でのみ現れることができます。“if”、“for”、または“switch”文の初期化子などのいくつかの文脈では、ローカル一時変数を宣言するために使用できます。

関数宣言

関数宣言は、識別子、関数名を関数にバインドします。

= "func"  [  ]  [  ] .
 =  .
 =  .

関数のシグネチャが結果パラメータを宣言している場合、関数本体の文リストは終了文で終わらなければなりません。

func IndexRune(s string, r rune) int {
    for i, c := range s {
        if c == r {
            return i
        }
    }
    // invalid: missing return statement
}

関数宣言が型パラメータを指定する場合、関数名はジェネリック関数を示します。ジェネリック関数は、呼び出す前にインスタンス化されなければなりません。

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

型パラメータのない関数宣言は、本文を省略できます。このような宣言は、Goの外部で実装された関数のシグネチャを提供します。たとえば、アセンブリルーチンなどです。

func flushICache(begin, end uintptr)  // implemented externally