Go言語入門：言語仕様 -Vol.52-

本日は、Go言語の言語仕様について解説しています。

背景

Go言語を学び始めて、公式の「The Go Programming Language Specification(言語仕様書)」を開いてみたものの、「英語で書かれていて読むのが大変…」「専門用語ばかりで何を言っているのかわからない…」と感じたことはありませんか? 実は、多くのGo初心者が同じ壁にぶつかっています。

言語仕様書は、Go言語の「正式な取扱説明書」のような存在です。プログラミング言語がどのように動くのか、どんなルールで書くべきなのかが詳しく書かれていますが、その分、初めて読む人には難しく感じられるのも事実です。

そこでこの記事では、言語仕様書の導入部分を丁寧な日本語訳とともに、初心者の方でも理解しやすい補足説明を加えてお届けします。「強く型付けされている」「ガベージコレクション」「並行プログラミング」といった専門用語も、具体例を交えながらわかりやすく解説していきます。

言語仕様書は難しそうに見えますが、一つひとつの概念を丁寧に読み解いていけば、必ず理解できます。一緒に、Go言語の基礎をしっかり学んでいきましょう!

型パラメータ宣言（Type parameter declarations）

型パラメータリストは、ジェネリック関数またはジェネリック型宣言の型パラメータを宣言します。型パラメータリストは通常の関数パラメータリストに似ていますが、型パラメータ名はすべて記述されていなければならず、リストは丸括弧ではなく角括弧で囲まれます [Go 1.18]。

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

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

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

通常の関数パラメータがそれぞれパラメータ型を持つように、各型パラメータには対応する（メタ）型があり、それは型制約（type constraint）と呼ばれます。

ジェネリック型の型パラメータリストが、制約 C を持つ単一の型パラメータ P を宣言し、テキスト P C が有効な式を構成する場合に、構文解析上の曖昧さが生じます。

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

これらのまれなケースでは、型パラメータリストが式と区別できず、型宣言は配列型の宣言として解析されてしまいます。この曖昧さを解決するには、制約をインターフェースに埋め込むか、末尾にカンマを付けます。

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

型パラメータは、ジェネリック型に関連付けられたメソッド宣言のレシーバ指定によっても宣言されることがあります。

---

解説

たとえ話

型パラメータを注文用紙のテンプレートに例えてみましょう。

レストランの注文用紙に「ドリンク：＿＿＿＿」という空欄があるとします。この空欄が型パラメータです。注文用紙そのもの（ジェネリック関数や型）は事前に作っておけますが、実際に使うときに「コーヒー」「紅茶」など具体的なものを記入します。この記入が**インスタンス化（型引数による置き換え）**です。

そして、空欄に書けるものには制限があります。「ドリンクメニューに載っているもの限定」のように、書ける範囲を決めるのが**型制約（type constraint）**です。any は「なんでもOK」、comparable は「比較できるもの限定」といった具合です。

コード例

package main

import "fmt"

// ══════════════════════════════════════
// 基本的な型パラメータ宣言
// ══════════════════════════════════════

// [T any] → 型パラメータ T を宣言。制約は any（すべての型を受け入れる）
func Print[T any](value T) {
	fmt.Println(value)
}

// [T comparable] → 比較可能な型のみ受け入れる
func Contains[T comparable](slice []T, target T) bool {
	for _, v := range slice {
		if v == target {
			return true
		}
	}
	return false
}

func main() {
	// インスタンス化：型引数を明示的に指定
	Print[int](42)       // → 42
	Print[string]("Go!") // → Go!

	// 型推論：コンパイラが型引数を自動的に推定
	Print(3.14) // → 3.14（float64 と推論される）

	fmt.Println(Contains([]int{1, 2, 3}, 2))      // → true
	fmt.Println(Contains([]string{"a", "b"}, "c")) // → false
}

package main

import "fmt"

// ══════════════════════════════════════
// 複数の型パラメータ
// ══════════════════════════════════════

// 2つの型パラメータ K と V を宣言
// K は comparable（マップのキーに使うため比較可能でなければならない）
func MapKeys[K comparable, V any](m map[K]V) []K {
	keys := make([]K, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}
	return keys
}

func main() {
	scores := map[string]int{
		"Alice": 90,
		"Bob":   85,
	}
	fmt.Println(MapKeys(scores)) // → [Alice Bob]（順序は不定）
}

package main

import "fmt"

// ══════════════════════════════════════
// 型制約の様々な書き方
// ══════════════════════════════════════

// --- [P any]: すべての型を許可 ---
func identity[P any](v P) P {
	return v
}

// --- [S interface{ ~[]byte | string }]: 基底型が []byte または string ---
func ToBytes[S interface{ ~[]byte | string }](s S) []byte {
	return []byte(s)
}

// --- [S ~[]E, E any]: S は E のスライス型、E は任意の型 ---
// 型パラメータ同士が参照し合える
func First[S ~[]E, E any](s S) E {
	return s[0]
}

// --- [_ any]: ブランク識別子も使える（使わないが宣言は必要な場合） ---
type Placeholder[_ any] struct {
	Data string
}

func main() {
	fmt.Println(identity(42))         // → 42
	fmt.Println(identity("hello"))    // → hello

	fmt.Println(ToBytes("Go言語"))     // → [71 111 ...]

	nums := []int{10, 20, 30}
	fmt.Println(First(nums))          // → 10

	p := Placeholder[int]{Data: "test"}
	fmt.Println(p.Data)               // → test
}

package main

import "fmt"

// ══════════════════════════════════════
// ジェネリック型と型パラメータ
// ══════════════════════════════════════

// 型パラメータ付きの型定義
type Pair[A, B any] struct {
	First  A
	Second B
}

// メソッドのレシーバでも型パラメータを宣言する
func (p Pair[A, B]) String() string {
	return fmt.Sprintf("(%v, %v)", p.First, p.Second)
}

func main() {
	// 異なる型引数でインスタンス化
	p1 := Pair[string, int]{First: "年齢", Second: 25}
	p2 := Pair[float64, float64]{First: 35.6, Second: 139.7}

	fmt.Println(p1) // → (年齢, 25)
	fmt.Println(p2) // → (35.6, 139.7)
}

package main

// ══════════════════════════════════════
// 構文解析の曖昧さとその回避方法
// ══════════════════════════════════════

type C struct{}

// ❌ 曖昧：型パラメータリストか配列型か区別できない
// type T1[P *C] struct{}    // P は型パラメータ？それとも配列のサイズ式？

// ✅ 解決法1：interface{} で囲む
type T2[P interface{ *C }] struct{}

// ✅ 解決法2：末尾にカンマを付ける
type T3[P *C,] struct{}

func main() {}

よくある間違い・注意点

1. 型パラメータ名はすべて記述する必要がある

通常の関数パラメータでは同じ型のパラメータをまとめて書けますが（func f(a, b int)）、型パラメータでは名前の省略ができません。

// 通常の関数パラメータ：型をまとめられる
func add(a, b int) int { return a + b }

// 型パラメータ：各名前に制約が必要
func process[T any, U comparable](t T, u U) { }
// ただし同じ制約なら名前をまとめられる
func process2[T, U any](t T, u U) { }

2. 型パラメータ名の一意性

// ❌ 同じ名前は使えない
// func bad[T any, T comparable]() {}

// ✅ 異なる名前を使う
func good[T any, U comparable]() {}

3. 制約が *C のような形だと構文が曖昧になる

この問題はまれですが、知っておくと構文エラーに遭遇したときに対処できます。interface{} で囲むか、末尾カンマを付けるのが定番の解決策です。

4. 型パラメータの命名規約

Go のコミュニティでは、型パラメータには短い大文字の名前を使う慣習があります。

// ✅ 一般的な命名
[T any]               // T = Type（汎用）
[K comparable, V any]  // K = Key, V = Value
[E any]               // E = Element
[S ~[]E, E any]       // S = Slice

// ❌ 冗長すぎる（動作はするが慣習に反する）
[ElementType any]

まとめ

• 型パラメータリストは角括弧 [] で囲み、各型パラメータには型制約を指定する。Go 1.18 で導入された。
• 型パラメータは未知の型のプレースホルダーであり、インスタンス化時に具体的な型引数に置き換えられる。
• すべての型パラメータ名は一意でなければならず、省略はできない（ブランク識別子 _ は可）。
• 型制約はインターフェースで表現され、any（すべての型）や comparable（比較可能な型）が代表例。
• [P *C] のような記述は構文解析上の曖昧さを生むため、interface{} で囲むか末尾カンマで回避する。
• 型パラメータは短い大文字1文字（T、K、V、E など）で命名するのが慣例。

型パラメータ宣言は、Go のジェネリクスを支える基盤です。「角括弧で型の空欄を作り、制約で空欄に入れられる型を制限し、使うときに具体的な型を埋める」という3ステップを理解しておけば、ジェネリクスの仕組みが明快になりますよ！

おわりに 

本日は、Go言語の言語仕様について解説しました。