الأنواع العامة 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{} وتفقد أمان الأنواع.

القيود

القيد واجهة. يحدّد الأنواع الممكن استخدامها، ويخبر المترجم في المقابل بالعمليات المسموحة على قيم ذلك النوع.

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

الواجهات التي تحتوي اتحادات أنواع لا تُستخدم إلا كقيود، ولا تُستخدم أبدًا كأنواع متغيّرات عادية. var n Number لا تُترجم.

في الحزمة golang.org/x/exp/constraints قيود جاهزة Integer وFloat وSigned. لكنها خارج المكتبة القياسية، فلا يستطيع المشغّل هنا استيرادها؛ والقيد القياسي هو cmp.Ordered.

الأنواع العامة

يمكن أن تملك البنى والشرائح والخرائط وغيرها معاملات نوع أيضًا. توابع النوع العام تستخدم معاملات المستقبِل.

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 يعمل مع كل نوع.
• التجسيد. يجب تجسيد النوع العام قبل استخدامه: Stack[string] لا Stack. وداخل توابعه يُكتب المستقبِل بالشكل Stack[T].

أضافت Go 1.24 الأسماء البديلة العامة للأنواع: type Set[T comparable] = map[T]struct{} تُترجم الآن.

حدود ستصطدم بها

• لا معاملات نوع في التوابع. func (s *Stack[T]) Map[U any](...) غير مسموحة. استخدم دالة على المستوى الأعلى.
• لا تخصيص. لا يمكنك كتابة تطبيق منفصل لـ T = string. الحل البديل type switch على any(v) داخل الدالة، وهو عادة إشارة إلى أن الأنواع العامة ليست الأداة المناسبة.
• لا قيود معاملات بالاسم. لا يمكنك قول "أي نوع له تابع +"؛ بل تسرد الأنواع في اتحاد.
• الوصول إلى الحقول عبر قيد لا يعمل. حتى لو كان لكل نوع في الاتحاد حقل ID، فإن v.ID غير مسموحة. استخدم تابعًا في القيد بدلًا من ذلك.

متى لا تستخدم الأنواع العامة

تناسب الأنواع العامة أنواع الحاويات (المكدّسات، المجموعات، الذاكرات المؤقّتة، الأشجار) والخوارزميات على الشرائح والخرائط التي تفعل الشيء نفسه لكل نوع عنصر. ولا تناسب كل مكان.

• نوع محدّد واحد. إذا كانت الدالة لا تُستدعى إلا مع []User، فالنسخة العامة تضيف كلفة قراءة ولا شيء غيرها.
• سلوك يختلف حسب النوع. هذا ما وُجدت الواجهات من أجله. الدالة التي تأخذ io.Writer أبسط من التي تأخذ [T io.Writer]، وتعمل بالطريقة نفسها.
• استبدال معاملات الواجهات. 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 أولًا.