宣言とスコープ

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

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

定数:
	true false iota

ゼロ値:
	nil

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

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

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

const Pi float64 = 3.14159265358979323846
const zero = 0.0         // 型付けされていない浮動小数点定数
const (
	size int64 = 1024
	eof        = -1  // 型付けされていない整数定数
)
const a, b, c = 3, 4, "foo"  // a = 3, b = 4, c = "foo", 型付けされていない整数と文字列定数
const u, v float32 = 0, 3    // u = 0.0, v = 3.0

const (
	Sunday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Partyday
	numberOfDays  // この定数はエクスポートされません
)

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, 未使用)
	d = 1 << iota  // d == 8  (iota == 3)
)

const (
	u         = iota * 42  // u == 0     (型付けされていない整数定数)
	v float64 = iota * 42  // v == 42.0  (float64定数)
	w         = iota * 42  // w == 84    (型付けされていない整数定数)
)

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

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

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

AliasDecl = identifier [ TypeParameters ] "=" Type .

type (
	nodeList = []*Node  // nodeListと[]*Nodeは同一の型です
	Polar    = polar    // PolarとpolarはPolarは同じ型を表します
)

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

type A[P any] = P    // 不正: Pは型パラメータです

TypeDef = identifier [ TypeParameters ] Type .

type (
	Point struct{ x, y float64 }  // PointとPとstruct{ x, y float64 }は異なる型です
	polar Point                   // polarとPointは異なる型を表します
)

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

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

// Mutexは2つのメソッド、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のメソッドセットには、埋め込みフィールドMutexに結び付けられた
// メソッドLockとUnlockが含まれます。
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  { … }

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

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

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

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

type T1[P T1[P]] …                    // 不正: T1は自身を参照します
type T2[P interface{ T2[int] }] …     // 不正: T2は自身を参照します
type T3[P interface{ m(T3[int])}] …   // 不正: T3は自身を参照します
type T4[P T5[P]] …                    // 不正: T4はT5を参照し、
type T5[P T4[P]] …                    //        T5はT4を参照します

type T6[P int] struct{ f *T6[P] }     // 正常: T6への参照は型パラメータリスト内にありません

TypeConstraint = TypeElem .

[T []P]                      // = [T interface{[]P}]
[T ~int]                     // = [T interface{~int}]
[T int|string]               // = [T interface{int|string}]
type Constraint ~int         // 不正: ~intは型パラメータリスト内にありません

int                          // comparableを実装します（intは厳密に比較可能です）
[]byte                       // comparableを実装しません（スライスは比較できません）
interface{}                  // comparableを実装しません（上記参照）
interface{ ~int | ~string }  // 型パラメータのみ: comparableを実装します（int、string型は厳密に比較可能です）
interface{ comparable }      // 型パラメータのみ: comparableを実装します（comparableは自身を実装します）
interface{ ~int | ~[]byte }  // 型パラメータのみ: comparableを実装しません（スライスは比較できません）
interface{ ~struct{ any } }  // 型パラメータのみ: comparableを実装しません（フィールドanyは厳密に比較可能ではありません）

型引数        型制約                      // 制約満足

int          interface{ ~int }          // 満足: intはinterface{ ~int }を実装します
string       comparable                 // 満足: stringはcomparableを実装します（stringは厳密に比較可能です）
[]byte       comparable                 // 満足しない: スライスは比較できません
any          interface{ comparable; int } // 満足しない: anyはinterface{ int }を実装しません
any          comparable                 // 満足: anyは比較可能で基本インタフェースanyを実装します
struct{f any} comparable                // 満足: struct{f any}は比較可能で基本インタフェースanyを実装します
any          interface{ comparable; m() } // 満足しない: anyは基本インタフェースinterface{ m() }を実装しません
interface{ m() } interface{ comparable; m() } // 満足: interface{ m() }は比較可能で基本インタフェースinterface{ m() }を実装します

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]  // マップ検索; "found"にのみ興味がある

var d = math.Sin(0.5)  // dはfloat64です
var i = 42             // iはintです
var t, ok = x.(T)      // tはT、okはboolです
var n = nil            // 不正

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()は接続されたFileのペアとエラー（あれば）を返します
_, y, _ := coord(p)   // coord()は3つの値を返します; y座標にのみ興味があります

field1, offset := nextField(str, 0)
field2, offset := nextField(str, offset)  // offsetを再宣言します
x, y, x := 1, 2, 3                        // 不正: :=の左側でxが繰り返されています

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
}

func flushICache(begin, end uintptr)  // 外部で実装

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

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
}

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を宣言し、PairのAに対応します

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

func (*GPoint[P]) Draw(P)   { … }  // 不正: エイリアスはジェネリックであってはなりません
func (HPoint) Draw(P)       { … }  // 不正: エイリアスはインスタンス化された型GPoint[int]を表してはなりません
func (*IPair) Second() int  { … }  // 不正: エイリアスはインスタンス化された型Pair[int, int]を表してはなりません