Generics ב-Golang: פרמטרי טיפוס, אילוצים ודוגמאות

פונקציה גנרית

פרמטרי טיפוס נכתבים בסוגריים מרובעים לפני הפרמטרים הרגילים. לכל אחד מהם יש אילוץ שאומר אילו טיפוסים מותרים.

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 ו-U מוסקים מהארגומנטים, כך שכמעט אף פעם לא כותבים Map[int, string](...). ההסקה עובדת מתוך הארגומנטים של הפונקציה; היא לא יכולה להסיק טיפוס שמופיע רק בתוצאה. עבור func Zero[T any]() T צריך לכתוב Zero[int]().

לפני Go 1.18 היה צריך לכתוב את הפונקציה הזאת פעם אחת לכל טיפוס, או לקבל []interface{} ולאבד את בטיחות הטיפוסים.

אילוצים

אילוץ הוא interface. הוא מגביל אילו טיפוסים אפשר להשתמש בהם, ובתמורה אומר לקומפיילר אילו פעולות מותרות על ערכים מהטיפוס הזה.

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

עם any במקום comparable, v == target לא מתקמפל: invalid operation: v == target (incomparable types in type set). האילוץ הוא מה שהופך את האופרטור לחוקי.

שתי פונקציות העזר האלה כבר קיימות: slices.Index ו-slices.Max. החבילות הסטנדרטיות slices, maps ו-cmp מכסות את רוב הצרכים הגנריים היומיומיים, אז בדקו אותן לפני שאתם כותבים משלכם.

אילוצים מותאמים עם איחודי טיפוסים ו-~

אילוץ יכול לפרט טיפוסים עם |. האופרטורים המותרים הם אלה שכל הטיפוסים ברשימה תומכים בהם.

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
}

הטילדה חשובה. ~int64 פירושו "כל טיפוס שטיפוס הבסיס שלו הוא int64", ולכן הטיפוס בעל השם Cents מתקבל. אם כותבים int64 רגיל, Sum([]Cents{...}) נכשל עם Cents does not satisfy Number (possibly missing ~ for int64 in Number).

interfaces שמכילים איחודי טיפוסים יכולים לשמש רק כאילוצים, אף פעם לא כטיפוסים של משתנים רגילים. var n Number לא מתקמפל.

בחבילה golang.org/x/exp/constraints יש אילוצים מוכנים Integer, Float ו-Signed. היא מחוץ לספרייה הסטנדרטית, ולכן סביבת ההרצה כאן לא יכולה לייבא אותה; cmp.Ordered הוא האילוץ הסטנדרטי.

טיפוסים גנריים

גם ל-structs, slices, maps וטיפוסים אחרים יכולים להיות פרמטרי טיפוס. מתודות על טיפוס גנרי משתמשות בפרמטרים של ה-receiver.

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

שני פרטים בדוגמה הזאת עולים כל הזמן:

• ערך האפס של T. var zero T היא הדרך להחזיר "כלום" מקוד גנרי. אין T{} או nil שעובדים לכל טיפוס.
• יצירת מופע (instantiation). צריך ליצור מופע של טיפוס גנרי לפני השימוש: Stack[string], לא Stack. בתוך המתודות שלו, ה-receiver נכתב Stack[T].

Go 1.24 הוסיפה type aliases גנריים: type Set[T comparable] = map[T]struct{} מתקמפל עכשיו.

מגבלות שתיתקלו בהן

• אין פרמטרי טיפוס במתודות. func (s *Stack[T]) Map[U any](...) אסור. השתמשו בפונקציה ברמה העליונה.
• אין התמחות (specialization). אי אפשר לכתוב מימוש נפרד עבור T = string. type switch על any(v) בתוך הפונקציה הוא הפתרון העוקף, ובדרך כלל רמז לכך ש-generics הם הכלי הלא נכון.
• אין אילוצי אופרטורים לפי שם. אי אפשר לומר "כל טיפוס עם מתודת +"; מפרטים את הטיפוסים באיחוד.
• גישה לשדות דרך אילוץ לא עובדת. גם אם לכל טיפוס באיחוד יש שדה ID, v.ID אסור. השתמשו במקום זאת במתודה באילוץ.

מתי לא להשתמש ב-generics

generics מתאימים לטיפוסי מכולה (מחסניות, קבוצות, caches, עצים) ולאלגוריתמים על slices ו-maps שעושים אותו דבר לכל טיפוס איבר. הם לא מתאימים לכל מקום.

• טיפוס קונקרטי אחד. אם קוראים לפונקציה תמיד רק עם []User, גרסה גנרית מוסיפה עלות קריאה ותו לא.
• התנהגות ששונה לפי טיפוס. בשביל זה יש interfaces. פונקציה שמקבלת io.Writer פשוטה יותר מפונקציה שמקבלת [T io.Writer], ועובדת אותו דבר.
• החלפת פרמטרים מסוג interface. func Print[T fmt.Stringer](v T) לא טובה יותר מ-func Print(v fmt.Stringer).

ההנחיה של צוות Go עצמו: כתבו קודם את הקוד לטיפוס מסוים, ופנו לפרמטרי טיפוס כשאתם שמים לב שאתם כותבים את אותו קוד בפעם השנייה ורק הטיפוסים השתנו.

טעויות נפוצות

• שימוש ב-any במקום שבו נדרש comparable או cmp.Ordered. הקומפיילר דוחה == או < על פרמטר טיפוס מסוג any.
• שכחת ~. טיפוסים שהמשתמש הגדיר כמו type ID int נכשלים באילוץ int רגיל.
• החזרת nil עבור פרמטר טיפוס. אסור, אלא אם האילוץ מגביל את T לטיפוסים דמויי מצביע. החזירו ערך אפס.
• כתיבת פונקציית עזר גנרית שכבר קיימת. בדקו קודם את slices, maps ו-cmp.