Golang Generics: Tip Parametreleri, Kısıtlar ve Örnekler

Generic bir fonksiyon

Tip parametreleri normal parametrelerden önce köşeli parantez içine yazılır. Her birinin hangi tiplere izin verildiğini söyleyen bir kısıtı vardır.

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 ve U argümanlardan çıkarılır, bu yüzden nadiren Map[int, string](...) yazarsınız. Çıkarım fonksiyon argümanlarından çalışır; yalnızca sonuçta görünen bir tipi çıkaramaz. func Zero[T any]() T için Zero[int]() yazmanız gerekir.

Go 1.18'den önce bu fonksiyonun her tip için bir kez yazılması ya da []interface{} alıp tip güvenliğini kaybetmesi gerekiyordu.

Kısıtlar

Kısıt bir interface'tir. Hangi tiplerin kullanılabileceğini sınırlar ve karşılığında derleyiciye o tipteki değerler üzerinde hangi işlemlere izin verildiğini söyler.

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

comparable yerine any ile v == target derlenmez: invalid operation: v == target (incomparable types in type set). Operatörü geçerli kılan kısıttır.

Bu iki yardımcı zaten var: slices.Index ve slices.Max. Standart slices, maps ve cmp paketleri gündelik generic ihtiyaçların çoğunu karşılar, bu yüzden kendinizinkini yazmadan önce onlara bakın.

Tip birleşimleri ve ~ ile özel kısıtlar

Bir kısıt tipleri | ile listeleyebilir. İzin verilen operatörler, listelenen her tipin desteklediği operatörlerdir.

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 önemlidir. ~int64, "temel tipi int64 olan herhangi bir tip" demektir, bu yüzden adlandırılmış Cents tipi kabul edilir. Düz int64 olarak yazılsaydı Sum([]Cents{...}), Cents does not satisfy Number (possibly missing ~ for int64 in Number) hatasıyla başarısız olurdu.

Tip birleşimi içeren interface'ler yalnızca kısıt olarak kullanılabilir, asla sıradan değişken tipi olarak kullanılamaz. var n Number derlenmez.

golang.org/x/exp/constraints paketinde hazır Integer, Float ve Signed kısıtları vardır. Standart kütüphanenin dışındadır, bu yüzden buradaki çalıştırıcı onu import edemez; standart olan cmp.Ordered'dır.

Generic tipler

Struct'lar, slice'lar, map'ler ve diğer tiplerin de tip parametreleri olabilir. Generic bir tipteki metotlar alıcının parametrelerini kullanır.

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

Bu örnekteki iki ayrıntıyla sürekli karşılaşırsınız:

• T'nin sıfır değeri. Generic koddan "hiçbir şey" döndürmenin yolu var zero T'dir. Her tip için çalışan bir T{} ya da nil yoktur.
• Örnekleme (instantiation). Generic bir tip kullanılmadan önce örneklenmelidir: Stack değil, Stack[string]. Kendi metotlarının içinde alıcı Stack[T] olarak yazılır.

Go 1.24 generic tip takma adlarını ekledi: type Set[T comparable] = map[T]struct{} artık derleniyor.

Karşılaşacağınız sınırlar

• Metotlarda tip parametresi yok. func (s *Stack[T]) Map[U any](...) izinli değildir. Üst seviye bir fonksiyon kullanın.
• Özelleştirme (specialization) yok. T = string için ayrı bir gerçekleştirme yazamazsınız. Fonksiyonun içinde any(v) üzerinde bir type switch geçici çözümdür ve genellikle generics'in yanlış araç olduğunun bir ipucudur.
• Ada göre operatör kısıtı yok. "+ metodu olan herhangi bir tip" diyemezsiniz; tipleri bir birleşimde listelersiniz.
• Bir kısıt üzerinden alan erişimi çalışmaz. Bir birleşimdeki her tipin ID alanı olsa bile v.ID'ye izin verilmez. Bunun yerine kısıtta bir metot kullanın.

Generics ne zaman kullanılmamalı

Generics, container tiplerine (stack'ler, set'ler, önbellekler, ağaçlar) ve her eleman tipi için aynı şeyi yapan slice ve map algoritmalarına uyar. Her yere uymaz.

• Tek bir somut tip. Fonksiyon her zaman yalnızca []User ile çağrılıyorsa, generic bir sürüm okuma maliyetinden başka hiçbir şey eklemez.
• Tipe göre değişen davranış. Interface'ler bunun içindir. Bir io.Writer alan fonksiyon, [T io.Writer] alandan daha basittir ve aynı şekilde çalışır.
• Interface parametrelerinin yerini almak. func Print[T fmt.Stringer](v T), func Print(v fmt.Stringer)'dan daha iyi değildir.

Go ekibinin kendi ilkesi: önce kodu belirli bir tip için yazın ve aynı kodu yalnızca tipleri değiştirerek ikinci kez yazdığınızı fark ettiğinizde tip parametrelerine başvurun.

Sık yapılan hatalar

• comparable ya da cmp.Ordered gereken yerde any kullanmak. Derleyici any bir tip parametresi üzerinde == ya da <'ı reddeder.
• ~'yi unutmak. type ID int gibi kullanıcı tanımlı tipler düz bir int kısıtını karşılamaz.
• Bir tip parametresi için nil döndürmek. Kısıt T'yi pointer benzeri tiplerle sınırlamadıkça izinli değildir. Sıfır değer döndürün.
• Zaten var olan generic bir yardımcıyı yazmak. Önce slices, maps ve cmp'ye bakın.