第24章ジェネリクス

ジェネリクスの基本
ジェネリクスの実践例
ジェネリクスとエラーハンドリング
ジェネリクスとパフォーマンス
ジェネリクスと互換性
ジェネリクスの制約と限界
練習問題1.
練習問題2.
練習問題3.

ジェネリクスの基本

ジェネリクスは、関数やデータ構造が特定の型に依存せずに動作することを可能にする機能です。これにより、同じロジックを複数の型に対して再利用することができます。

ジェネリック関数

ジェネリック関数は、型パラメータを受け取ることで、異なる型に対して同じロジックを適用できます。

package main

import "fmt"

// Numberは、intやfloat64などの数値型を表す制約
type Number interface {
    int | float64
}

// Sumは、ジェネリック関数
func Sum[T Number](slice []T) T {
    var total T
    for _, v := range slice {
        total += v
    }
    return total
}

func main() {
    ints := []int{1, 2, 3, 4, 5}
    floats := []float64{1.1, 2.2, 3.3, 4.4, 5.5}
    
    fmt.Println("Sum of ints:", Sum(ints))     // Output: Sum of ints: 15
    fmt.Println("Sum of floats:", Sum(floats)) // Output: Sum of floats: 16.5
}

ジェネリック型の定義

ジェネリック型を定義することで、データ構造を汎用的に使用できます。

package main

import "fmt"

// Stackはジェネリック型のスタックを定義
type Stack[T any] struct {
    elements []T
}

// Pushはスタックに要素を追加
func (s *Stack[T]) Push(element T) {
    s.elements = append(s.elements, element)
}

// Popはスタックから要素を削除して返す
func (s *Stack[T]) Pop() (T, bool) {
    if len(s.elements) == 0 {
        var zero T
        return zero, false
    }
    element := s.elements[len(s.elements)-1]
    s.elements = s.elements[:len(s.elements)-1]
    return element, true
}

func main() {
    intStack := Stack[int]{}
    intStack.Push(1)
    intStack.Push(2)
    fmt.Println("Popped from intStack:", intStack.Pop()) // Output: Popped from intStack: 2, true

    stringStack := Stack[string]{}
    stringStack.Push("hello")
    stringStack.Push("world")
    fmt.Println("Popped from stringStack:", stringStack.Pop()) // Output: Popped from stringStack: world, true
}

制約

制約は、ジェネリックな型パラメータに対して許可される型を限定するために使用されます。これにより、特定の操作が保証されるようになります。

package main

import "fmt"

// Orderedは、比較可能な型を表す制約
type Ordered interface {
    int | float64 | string
}

// Maxは、ジェネリック関数であり、制約Orderedを使用して比較可能な型に対して動作
func Max[T Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}

func main() {
    fmt.Println("Max of 1 and 2:", Max(1, 2))            // Output: Max of 1 and 2: 2
    fmt.Println("Max of 1.1 and 2.2:", Max(1.1, 2.2))    // Output: Max of 1.1 and 2.2: 2.2
    fmt.Println("Max of 'a' and 'b':", Max("a", "b"))    // Output: Max of 'a' and 'b': b
}

ジェネリクスの実践例

ジェネリクスは、Go言語で汎用的なコードを記述するための強力なツールです。ここでは、ジェネリクスの実践例を具体的な事例とともに説明します。これにより、ジェネリクスの実用性を理解し、効果的に活用できるようになります。

ジェネリックなスライス操作

ジェネリクスを使って、任意の型のスライスに対して共通の操作を行う関数を作成できます。例えば、スライスの最大値を求める関数を作成します。

package main

import (
    "fmt"
)

// Orderedは比較可能な型を表す制約
type Ordered interface {
    int | float64 | string
}

// Maxはスライス内の最大値を返すジェネリック関数
func Max[T Ordered](slice []T) T {
    if len(slice) == 0 {
        var zero T
        return zero
    }
    max := slice[0]
    for _, v := range slice[1:] {
        if v > max {
            max = v
        }
    }
    return max
}

func main() {
    ints := []int{1, 2, 3, 4, 5}
    floats := []float64{1.1, 2.2, 3.3, 4.4, 5.5}
    strings := []string{"apple", "orange", "banana"}

    fmt.Println("Max of ints:", Max(ints))       // Output: Max of ints: 5
    fmt.Println("Max of floats:", Max(floats))   // Output: Max of floats: 5.5
    fmt.Println("Max of strings:", Max(strings)) // Output: Max of strings: orange
}

ジェネリックなマップ操作

ジェネリクスを使って、任意の型のキーと値を持つマップを操作する関数を作成できます。例えば、マップのキーのリストを取得する関数を作成します。

package main

import (
    "fmt"
)

// Keysはマップのキーをスライスとして返すジェネリック関数
func Keys[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() {
    intMap := map[int]string{1: "one", 2: "two", 3: "three"}
    stringMap := map[string]int{"apple": 1, "banana": 2, "cherry": 3}

    fmt.Println("Keys of intMap:", Keys(intMap))       // Output: Keys of intMap: [1 2 3]
    fmt.Println("Keys of stringMap:", Keys(stringMap)) // Output: Keys of stringMap: [apple banana cherry]
}

ジェネリックな構造体

ジェネリクスを使って、任意の型のフィールドを持つ構造体を作成できます。例えば、ジェネリックなペア型を作成します。

package main

import (
    "fmt"
)

// Pairはジェネリックなペア型を定義
type Pair[T any, U any] struct {
    First  T
    Second U
}

func main() {
    intPair := Pair[int, int]{First: 1, Second: 2}
    stringIntPair := Pair[string, int]{First: "one", Second: 1}

    fmt.Println("intPair:", intPair)                // Output: intPair: {1 2}
    fmt.Println("stringIntPair:", stringIntPair)    // Output: stringIntPair: {one 1}
}

ジェネリックなフィルタ関数

ジェネリクスを使って、任意の型のスライスに対して条件を満たす要素を抽出するフィルタ関数を作成します。

package main

import (
    "fmt"
)

// Filterはスライスの要素をフィルタリングするジェネリック関数
func Filter[T any](slice []T, predicate func(T) bool) []T {
    var result []T
    for _, v := range slice {
        if predicate(v) {
            result = append(result, v)
        }
    }
    return result
}

func main() {
    ints := []int{1, 2, 3, 4, 5}
    isEven := func(n int) bool {
        return n%2 == 0
    }

    evenInts := Filter(ints, isEven)
    fmt.Println("Even ints:", evenInts) // Output: Even ints: [2 4]
}

ジェネリクスとエラーハンドリング

ジェネリクスを用いることで、エラーハンドリングも柔軟に行うことができます。ジェネリクスは型に依存しない関数や構造体を作成できるため、エラーハンドリングにおいても再利用性の高いコードを書くことが可能です。ここでは、ジェネリクスとエラーハンドリングについて具体的事例を交えて説明します。

ジェネリックなエラーハンドリング関数

ジェネリクスを用いて、汎用的なエラーチェック関数を作成します。この関数は、任意の型の結果とエラーを受け取り、エラーが存在する場合に適切な処理を行います。

package main

import (
    "errors"
    "fmt"
)

// CheckErrorは任意の型の結果とエラーを受け取り、エラーが存在する場合に適切な処理を行うジェネリック関数
func CheckError[T any](result T, err error) T {
    if err != nil {
        fmt.Println("Error occurred:", err)
        var zero T
        return zero
    }
    return result
}

func mayFail(success bool) (string, error) {
    if success {
        return "Operation successful", nil
    }
    return "", errors.New("operation failed")
}

func main() {
    result := CheckError(mayFail(true))
    fmt.Println("Result:", result) // Output: Result: Operation successful

    result = CheckError(mayFail(false))
    fmt.Println("Result:", result) // Output: Error occurred: operation failed
                                    //          Result:
}

この例では、CheckError関数が任意の型Tの結果とエラーを受け取り、エラーが存在する場合にはエラーメッセージを表示し、ゼロ値を返しています。

ジェネリックなリソース管理

ジェネリクスを用いて、リソースの開放を自動的に行う汎用的な関数を作成します。これは、ファイルやデータベース接続など、リソースの管理とエラーハンドリングを一貫して行うために有用です。

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "log"
)

// UseResourceは任意の型のリソースを受け取り、そのリソースを使用する関数を実行し、最後にリソースをクリーンアップするジェネリック関数
func UseResource[T any](resource T, fn func(T) error, cleanup func(T) error) error {
    if err := fn(resource); err != nil {
        return err
    }
    return cleanup(resource)
}

func main() {
    db, err := sql.Open("mysql", "user:password@/dbname")
    if err != nil {
        log.Fatal(err)
    }
    
    useDB := func(db *sql.DB) error {
        // データベース操作を実行
        _, err := db.Exec("INSERT INTO users(name) VALUES('Alice')")
        return err
    }

    cleanupDB := func(db *sql.DB) error {
        return db.Close()
    }

    err = UseResource(db, useDB, cleanupDB)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Database operation completed successfully")
    }
}

この例では、UseResource関数が任意のリソースを受け取り、そのリソースを使用する関数とクリーンアップ関数を実行します。リソースの使用中にエラーが発生した場合は、適切にエラーハンドリングが行われます。

ジェネリックなリトライロジック

ジェネリクスを使って、任意の操作をリトライする汎用的な関数を作成します。これは、ネットワーク操作や外部サービスとの通信などで一時的なエラーが発生する可能性がある場合に便利です。

package main

import (
    "errors"
    "fmt"
    "math/rand"
    "time"
)

// Retryは任意の操作を最大n回リトライするジェネリック関数
func Retry[T any](n int, fn func() (T, error)) (T, error) {
    var result T
    var err error
    for i := 0; i < n; i++ {
        result, err = fn()
        if err == nil {
            return result, nil
        }
        time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)
    }
    return result, err
}

func unreliableOperation() (string, error) {
    if rand.Float32() < 0.5 {
        return "Success", nil
    }
    return "", errors.New("temporary error")
}

func main() {
    rand.Seed(time.Now().UnixNano())
    result, err := Retry(5, unreliableOperation)
    if err != nil {
        fmt.Println("Operation failed after retries:", err)
    } else {
        fmt.Println("Operation succeeded:", result)
    }
}

この例では、Retry関数が任意の操作を最大n回リトライします。操作が成功するか、指定された回数のリトライが終わるまでリトライを続けます。

ジェネリクスとパフォーマンス

ジェネリクスとコンパイル時の最適化

Goコンパイラは、ジェネリクスを使用する際に具体的な型ごとにコードを生成します。これにより、ジェネリックなコードは実行時に特定の型に最適化されます。これは、ランタイムのオーバーヘッドを減少させるため、パフォーマンスに対して有利に働きます。

package main

import (
    "fmt"
)

// Sumは、任意の数値型のスライスの合計を求めるジェネリック関数
func Sum[T int | float64](slice []T) T {
    var total T
    for _, v := range slice {
        total += v
    }
    return total
}

func main() {
    ints := []int{1, 2, 3, 4, 5}
    floats := []float64{1.1, 2.2, 3.3, 4.4, 5.5}

    fmt.Println("Sum of ints:", Sum(ints))       // Output: Sum of ints: 15
    fmt.Println("Sum of floats:", Sum(floats))   // Output: Sum of floats: 16.5
}

この例では、ジェネリック関数Sumが具体的な型（intやfloat64）ごとに最適化されます。これにより、パフォーマンスは通常の関数とほぼ同等になります。

ジェネリクスの使用によるオーバーヘッド

ジェネリクスを使用すると、型のチェックや変換に伴う若干のオーバーヘッドが発生することがあります。ただし、これらのオーバーヘッドは通常非常に小さく、一般的な使用ケースでは無視できるレベルです。

package main

import (
    "fmt"
    "time"
)

// ジェネリック関数
func GenericSum[T int | float64](slice []T) T {
    var total T
    for _, v := range slice {
        total += v
    }
    return total
}

// 具体的な関数
func IntSum(slice []int) int {
    var total int
    for _, v := range slice {
        total += v
    }
    return total
}

func main() {
    ints := make([]int, 1000000)
    for i := range ints {
        ints[i] = i + 1
    }

    // ジェネリック関数のパフォーマンス測定
    start := time.Now()
    _ = GenericSum(ints)
    fmt.Println("GenericSum took:", time.Since(start))

    // 具体的な関数のパフォーマンス測定
    start = time.Now()
    _ = IntSum(ints)
    fmt.Println("IntSum took:", time.Since(start))
}

この例では、ジェネリック関数と具体的な関数のパフォーマンスを比較しています。通常、ジェネリック関数のパフォーマンスは具体的な関数と同等か、わずかに劣る程度です。

ベストプラクティス

必要な場合のみジェネリクスを使用する: ジェネリクスは強力ですが、すべての場面で使用する必要はありません。特定の型に対して高いパフォーマンスが要求される場合は、具体的な型の関数や構造体を使用することが推奨されます。
型の制約を適切に使用する: 型の制約を適切に使用することで、コンパイラが最適なコードを生成しやすくなります。
パフォーマンス測定を行う: ジェネリクスを使用したコードのパフォーマンスを測定し、必要に応じて最適化を行います。特に、頻繁に呼び出される関数や、パフォーマンスクリティカルなコードに対しては注意が必要です。

ジェネリクスと互換性

Go言語におけるジェネリクスは、コードの再利用性を向上させる強力な機能ですが、既存の非ジェネリックなコードとの互換性を保つことも重要です。ここでは、ジェネリクスと互換性について具体的な事例を交えながら説明します。

非ジェネリック関数との互換性

既存の非ジェネリックな関数とジェネリックな関数をどのように組み合わせて使用するかを示します。

package main

import (
    "fmt"
)

// 既存の非ジェネリックな関数
func IntSum(slice []int) int {
    var total int
    for _, v := range slice {
        total += v
    }
    return total
}

// ジェネリック関数
func GenericSum[T int | float64](slice []T) T {
    var total T
    for _, v := range slice {
        total += v
    }
    return total
}

func main() {
    ints := []int{1, 2, 3, 4, 5}
    floats := []float64{1.1, 2.2, 3.3, 4.4, 5.5}

    // 非ジェネリック関数の使用
    fmt.Println("IntSum:", IntSum(ints)) // Output: IntSum: 15

    // ジェネリック関数の使用
    fmt.Println("GenericSum[int]:", GenericSum(ints))       // Output: GenericSum[int]: 15
    fmt.Println("GenericSum[float64]:", GenericSum(floats)) // Output: GenericSum[float64]: 16.5
}

この例では、既存の非ジェネリックな関数IntSumとジェネリック関数GenericSumが共存しています。これにより、徐々にジェネリクスへの移行を行うことができます。

ジェネリック型と非ジェネリック型の互換性

ジェネリック型と非ジェネリック型をどのように組み合わせて使用するかを示します。

package main

import (
    "fmt"
)

// 非ジェネリック型
type IntStack struct {
    elements []int
}

func (s *IntStack) Push(element int) {
    s.elements = append(s.elements, element)
}

func (s *IntStack) Pop() (int, bool) {
    if len(s.elements) == 0 {
        return 0, false
    }
    element := s.elements[len(s.elements)-1]
    s.elements = s.elements[:len(s.elements)-1]
    return element, true
}

// ジェネリック型
type Stack[T any] struct {
    elements []T
}

func (s *Stack[T]) Push(element T) {
    s.elements = append(s.elements, element)
}

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.elements) == 0 {
        var zero T
        return zero, false
    }
    element := s.elements[len(s.elements)-1]
    s.elements = s.elements[:len(s.elements)-1]
    return element, true
}

func main() {
    // 非ジェネリック型の使用
    intStack := &IntStack{}
    intStack.Push(1)
    intStack.Push(2)
    fmt.Println("IntStack Pop:", intStack.Pop()) // Output: IntStack Pop: 2, true

    // ジェネリック型の使用
    genericIntStack := &Stack[int]{}
    genericIntStack.Push(1)
    genericIntStack.Push(2)
    fmt.Println("Generic Stack[int] Pop:", genericIntStack.Pop()) // Output: Generic Stack[int] Pop: 2, true

    genericStringStack := &Stack[string]{}
    genericStringStack.Push("hello")
    genericStringStack.Push("world")
    fmt.Println("Generic Stack[string] Pop:", genericStringStack.Pop()) // Output: Generic Stack[string] Pop: world, true
}

この例では、非ジェネリックなスタック型IntStackとジェネリックなスタック型Stack[T]が共存しています。新しいコードではジェネリック型を使用しつつ、既存のコードを変更せずに利用できます。

ジェネリックと非ジェネリックなインターフェースの組み合わせ

ジェネリックな型と非ジェネリックなインターフェースを組み合わせる方法を示します。

package main

import (
    "fmt"
)

// 非ジェネリックなインターフェース
type StackInterface interface {
    Push(interface{})
    Pop() (interface{}, bool)
}

// ジェネリックな型
type Stack[T any] struct {
    elements []T
}

func (s *Stack[T]) Push(element T) {
    s.elements = append(s.elements, element)
}

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.elements) == 0 {
        var zero T
        return zero, false
    }
    element := s.elements[len(s.elements)-1]
    s.elements = s.elements[:len(s.elements)-1]
    return element, true
}

func main() {
    var stack StackInterface = &Stack[int]{}
    stack.Push(10)
    stack.Push(20)
    fmt.Println("Stack Pop:", stack.Pop()) // Output: Stack Pop: 20, true
}

この例では、ジェネリック型Stack[T]が非ジェネリックなインターフェースStackInterfaceを実装しています。これにより、既存のインターフェースを利用しつつ、ジェネリック型の利点を活かすことができます。

ジェネリクスの制約と限界

Go言語におけるジェネリクスは非常に強力なツールですが、いくつかの制約と限界があります。これらを理解することで、ジェネリクスを適切に利用し、予期しない問題を避けることができます。ここでは、ジェネリクスの制約と限界について、具体的な事例を交えて説明します。

制約の基本

ジェネリクスの型パラメータには制約を設けることができます。制約は、ジェネリックなコードで使用できる操作やメソッドを限定するために使用されます。

package main

import (
    "fmt"
)

// Orderedは比較可能な型を表す制約
type Ordered interface {
    int | float64 | string
}

// Maxはスライス内の最大値を返すジェネリック関数
func Max[T Ordered](slice []T) T {
    if len(slice) == 0 {
        var zero T
        return zero
    }
    max := slice[0]
    for _, v := range slice[1:] {
        if v > max {
            max = v
        }
    }
    return max
}

func main() {
    ints := []int{1, 2, 3, 4, 5}
    floats := []float64{1.1, 2.2, 3.3, 4.4, 5.5}
    strings := []string{"apple", "orange", "banana"}

    fmt.Println("Max of ints:", Max(ints))       // Output: Max of ints: 5
    fmt.Println("Max of floats:", Max(floats))   // Output: Max of floats: 5.5
    fmt.Println("Max of strings:", Max(strings)) // Output: Max of strings: orange
}

この例では、Ordered制約を使用して、Max関数がint、float64、string型に対してのみ動作するようにしています。

制約の限界

Goのジェネリクスでは、型パラメータに対して一部の操作のみが許可されます。たとえば、ジェネリクスで任意の型に対する四則演算や比較演算を直接サポートしているわけではありません。

package main

import (
    "fmt"
)

// Numberは加算可能な型を表す制約
type Number interface {
    int | float64
}

// Addは2つの数値を加算するジェネリック関数
func Add[T Number](a, b T) T {
    return a + b
}

func main() {
    fmt.Println("Add ints:", Add(1, 2))         // Output: Add ints: 3
    fmt.Println("Add floats:", Add(1.1, 2.2))   // Output: Add floats: 3.3
}

この例では、Number制約を使用して、intとfloat64型に対して加算操作を許可しています。

インターフェースの制約とメソッドセット

ジェネリクスでインターフェースを使用する場合、型パラメータのメソッドセットにも注意が必要です。インターフェースのメソッドセットに含まれていないメソッドを呼び出そうとすると、コンパイルエラーが発生します。

package main

import (
    "fmt"
)

// Stringerは文字列に変換可能な型を表すインターフェース
type Stringer interface {
    String() string
}

// PrintStringは任意のStringerを受け取り、その文字列を出力するジェネリック関数
func PrintString[T Stringer](s T) {
    fmt.Println(s.String())
}

// MyStringはStringerインターフェースを実装
type MyString string

func (ms MyString) String() string {
    return string(ms)
}

func main() {
    var s MyString = "Hello, Go!"
    PrintString(s) // Output: Hello, Go!
}

この例では、Stringerインターフェースを実装する型に対してのみPrintString関数が動作します。これにより、型の安全性が確保されます。

ジェネリクスの型推論の限界

Goのジェネリクスでは、型推論が可能ですが、すべてのケースで自動的に型を推論できるわけではありません。特に複雑な型や関数のネストが深い場合、明示的に型を指定する必要があります。

package main

import (
    "fmt"
)

// Pairは2つの値を保持するジェネリック型
type Pair[T any, U any] struct {
    First  T
    Second U
}

// NewPairは2つの値からPairを作成するジェネリック関数
func NewPair[T any, U any](first T, second U) Pair[T, U] {
    return Pair[T, U]{First: first, Second: second}
}

func main() {
    p1 := NewPair(1, "one")
    fmt.Printf("Pair 1: %+v\n", p1)

    // 複雑な場合、型推論が難しいため明示的に指定
    p2 := NewPair[int, string](2, "two")
    fmt.Printf("Pair 2: %+v\n", p2)
}

この例では、NewPair関数の型推論が可能な場合と、明示的に型を指定する必要がある場合を示しています。

練習問題1.

任意の型のスライスの要素を逆順にするジェネリック関数Reverseを作成してください。この関数は、スライスを受け取り、その要素を逆順にしたスライスを返します。

package main

import (
    "fmt"
)

// ここにジェネリック関数Reverseを定義

func main() {
    ints := []int{1, 2, 3, 4, 5}
    reversedInts := Reverse(ints)
    fmt.Println("Reversed ints:", reversedInts) // Output: Reversed ints: [5 4 3 2 1]

    strings := []string{"apple", "banana", "cherry"}
    reversedStrings := Reverse(strings)
    fmt.Println("Reversed strings:", reversedStrings) // Output: Reversed strings: [cherry banana apple]
}

練習問題2.

任意の型を保持するジェネリックなスタックを実装してください。スタックには、要素を追加するPushメソッドと、要素を取り出すPopメソッドを実装します。

package main

import (
    "fmt"
)

// ここにジェネリック型Stackを定義

func main() {
    intStack := &Stack[int]{}
    intStack.Push(1)
    intStack.Push(2)
    fmt.Println("IntStack Pop:", intStack.Pop()) // Output: IntStack Pop: 2, true

    stringStack := &Stack[string]{}
    stringStack.Push("hello")
    stringStack.Push("world")
    fmt.Println("StringStack Pop:", stringStack.Pop()) // Output: StringStack Pop: world, true
}

練習問題3.

任意の数値型のスライスの平均を計算するジェネリック関数Averageを作成してください。数値型としてintとfloat64をサポートします。

package main

import (
    "fmt"
)

// Number制約の定義
type Number interface {
    int | float64
}

// ここにジェネリック関数Averageを定義

func main() {
    ints := []int{1, 2, 3, 4, 5}
    fmt.Println("Average of ints:", Average(ints)) // Output: Average of ints: 3

    floats := []float64{1.1, 2.2, 3.3, 4.4, 5.5}
    fmt.Println("Average of floats:", Average(floats)) // Output: Average of floats: 3.3
}

第24章 ジェネリクス