Generic di Golang: Type Parameter, Constraint, dan Contoh

Fungsi generic

Type parameter ditulis di dalam kurung siku sebelum parameter biasa. Masing-masing punya constraint yang menyatakan tipe apa saja yang diizinkan.

package main

import (
	"fmt"
	"strconv"
)

func Map[T, U any](items []T, f func(T) U) []U {
	out := make([]U, 0, len(items))
	for _, it := range items {
		out = append(out, f(it))
	}
	return out
}

func main() {
	nums := []int{1, 2, 3}

	squares := Map(nums, func(n int) int { return n * n })
	fmt.Println(squares)

	labels := Map(nums, strconv.Itoa)
	fmt.Printf("%q\n", labels)

	lengths := Map([]string{"go", "rust", "c"}, func(s string) int { return len(s) })
	fmt.Println(lengths)
}

T dan U disimpulkan dari argumennya, jadi kamu jarang menulis Map[int, string](...). Inferensi bekerja dari argumen fungsi; Go tidak bisa menyimpulkan tipe yang hanya muncul di hasil. Untuk func Zero[T any]() T, kamu harus menulis Zero[int]().

Sebelum Go 1.18, fungsi ini harus ditulis sekali untuk setiap tipe, atau menerima []interface{} dan kehilangan type safety.

Constraint

Constraint adalah sebuah interface. Constraint membatasi tipe yang bisa dipakai dan, sebagai gantinya, memberi tahu compiler operasi apa saja yang diizinkan pada nilai bertipe itu.

package main

import (
	"cmp"
	"fmt"
)

func Index[T comparable](s []T, target T) int {
	for i, v := range s {
		if v == target { // needs comparable
			return i
		}
	}
	return -1
}

func Largest[T cmp.Ordered](s []T) T {
	m := s[0]
	for _, v := range s[1:] {
		if v > m { // needs cmp.Ordered
			m = v
		}
	}
	return m
}

func main() {
	fmt.Println(Index([]string{"a", "b", "c"}, "c"))
	fmt.Println(Largest([]float64{2.5, 9.1, 4.0}))
	fmt.Println(Largest([]string{"pear", "apple", "zucchini"}))
}

Dengan any alih-alih comparable, v == target gagal dikompilasi: invalid operation: v == target (incomparable types in type set). Constraint-lah yang membuat operator itu sah.

Dua helper ini sebenarnya sudah ada: slices.Index dan slices.Max. Package standar slices, maps, dan cmp sudah mencakup sebagian besar kebutuhan generic sehari-hari, jadi periksa ketiganya sebelum menulis milikmu sendiri.

Constraint kustom dengan type union dan ~

Constraint bisa mendaftar tipe-tipe dengan |. Operator yang diizinkan adalah operator yang didukung oleh setiap tipe dalam daftar itu.

package main

import "fmt"

type Number interface {
	~int | ~int64 | ~float64
}

func Sum[T Number](nums []T) T {
	var total T
	for _, n := range nums {
		total += n
	}
	return total
}

type Cents int64

func main() {
	fmt.Println(Sum([]int{1, 2, 3}))
	fmt.Println(Sum([]float64{0.5, 0.25}))
	fmt.Println(Sum([]Cents{199, 250})) // works because of ~int64
}

Tilde itu penting. ~int64 berarti "tipe apa pun yang tipe dasarnya adalah int64", jadi tipe bernama Cents diterima. Kalau ditulis sebagai int64 biasa, Sum([]Cents{...}) gagal dengan Cents does not satisfy Number (possibly missing ~ for int64 in Number).

Interface yang berisi type union hanya bisa dipakai sebagai constraint, tidak pernah sebagai tipe variabel biasa. var n Number tidak bisa dikompilasi.

Package golang.org/x/exp/constraints punya constraint siap pakai Integer, Float, dan Signed. Package ini berada di luar standard library, jadi runner di sini tidak bisa meng-import-nya; cmp.Ordered adalah yang standar.

Tipe generic

Struct, slice, map, dan tipe lain juga bisa punya type parameter. Method pada tipe generic memakai parameter dari receiver-nya.

package main

import (
	"errors"
	"fmt"
)

type Stack[T any] struct {
	items []T
}

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

func (s *Stack[T]) Pop() (T, error) {
	var zero T
	if len(s.items) == 0 {
		return zero, errors.New("empty stack")
	}
	v := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return v, nil
}

func (s *Stack[T]) Len() int { return len(s.items) }

type Pair[K comparable, V any] struct {
	Key K
	Val V
}

func main() {
	var s Stack[string]
	s.Push("a")
	s.Push("b")
	v, _ := s.Pop()
	fmt.Println(v, s.Len())

	_, err := (&Stack[int]{}).Pop()
	fmt.Println(err)

	p := Pair[string, int]{Key: "age", Val: 31}
	fmt.Printf("%+v\n", p)
}

Dua detail di contoh ini muncul terus-menerus:

• Zero value dari T. var zero T adalah cara mengembalikan "tidak ada apa-apa" dari kode generic. Tidak ada T{} atau nil yang bisa dipakai untuk setiap tipe.
• Instansiasi. Tipe generic harus diinstansiasi sebelum dipakai: Stack[string], bukan Stack. Di dalam method-nya sendiri, receiver-nya ditulis Stack[T].

Go 1.24 menambahkan type alias generic: type Set[T comparable] = map[T]struct{} sekarang bisa dikompilasi.

Batasan yang akan kamu temui

• Tidak ada type parameter pada method. func (s *Stack[T]) Map[U any](...) tidak diizinkan. Pakai fungsi di level atas.
• Tidak ada spesialisasi. Kamu tidak bisa menulis implementasi terpisah untuk T = string. Type switch pada any(v) di dalam fungsi adalah cara mengakalinya, dan biasanya menjadi tanda bahwa generic bukan alat yang tepat.
• Tidak ada constraint operator berdasarkan nama. Kamu tidak bisa mengatakan "tipe apa pun yang punya method +"; kamu mendaftar tipe-tipenya dalam sebuah union.
• Akses field lewat constraint tidak berfungsi. Meskipun setiap tipe dalam union punya field ID, v.ID tidak diizinkan. Pakai method di dalam constraint sebagai gantinya.

Kapan sebaiknya tidak memakai generic

Generic cocok untuk tipe container (stack, set, cache, tree) dan algoritma atas slice dan map yang melakukan hal yang sama untuk setiap tipe elemen. Generic tidak cocok di semua tempat.

• Hanya satu tipe konkret. Kalau fungsinya hanya pernah dipanggil dengan []User, versi generic hanya menambah beban membaca dan tidak memberi apa-apa lagi.
• Perilaku yang berbeda per tipe. Untuk itulah interface ada. Fungsi yang menerima io.Writer lebih sederhana daripada fungsi yang menerima [T io.Writer], dan bekerja sama baiknya.
• Menggantikan parameter interface. func Print[T fmt.Stringer](v T) tidak lebih baik daripada func Print(v fmt.Stringer).

Pedoman dari tim Go sendiri: tulis dulu kodenya untuk tipe tertentu, dan pakai type parameter saat kamu menyadari dirimu menulis kode yang sama untuk kedua kalinya dengan hanya tipenya yang berubah.

Kesalahan umum

• Memakai any di tempat yang butuh comparable atau cmp.Ordered. Compiler menolak == atau < pada type parameter any.
• Lupa ~. Tipe buatan pengguna seperti type ID int gagal memenuhi constraint int biasa.
• Mengembalikan nil untuk type parameter. Tidak diizinkan kecuali constraint-nya membatasi T ke tipe yang mirip pointer. Kembalikan zero value.
• Menulis helper generic yang sudah ada. Periksa slices, maps, dan cmp lebih dulu.