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

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

قبل Go 1.18، إذا أردت دالة تعمل مع أنواع مختلفة كنت تحتاج إما interface{} (تفقد أمان الأنواع) أو كتابة نفس الدالة لكل نوع. الأنواع المعممة (Generics) تحل هذه المشكلة بأناقة.

المشكلة بدون Generics

main.go

package main

import "fmt"

// بدون generics — نحتاج دالة لكل نوع!
// Without generics — need a function per type!
func MaxInt(a, b int) int {
    if a > b { return a }
    return b
}

func MaxFloat(a, b float64) float64 {
    if a > b { return a }
    return b
}

func MaxString(a, b string) string {
    if a > b { return a }
    return b
}

func main() {
    fmt.Println("أكبر int:", MaxInt(3, 7))
    fmt.Println("أكبر float:", MaxFloat(3.14, 2.71))
    fmt.Println("أكبر string:", MaxString("أحمد", "زيد"))
    fmt.Println("\n😤 ثلاث دوال لنفس المنطق!")
}

Output:

الحل مع Generics

main.go

package main

import (
    "cmp"
    "fmt"
)

// دالة معممة واحدة تعمل مع كل الأنواع القابلة للترتيب!
// One generic function works with all ordered types!
func Max[T cmp.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}

// دالة معممة أخرى — Another generic function
func Contains[T comparable](slice []T, target T) bool {
    for _, v := range slice {
        if v == target {
            return true
        }
    }
    return false
}

func main() {
    // نفس الدالة مع أنواع مختلفة — Same function, different types
    fmt.Println("أكبر int:", Max(3, 7))
    fmt.Println("أكبر float:", Max(3.14, 2.71))
    fmt.Println("أكبر string:", Max("أحمد", "زيد"))

    fmt.Println()

    // Contains مع أنواع مختلفة — Contains with different types
    nums := []int{1, 2, 3, 4, 5}
    fmt.Println("يحتوي 3؟", Contains(nums, 3))
    fmt.Println("يحتوي 9؟", Contains(nums, 9))

    names := []string{"أحمد", "فاطمة", "عمر"}
    fmt.Println("يحتوي فاطمة؟", Contains(names, "فاطمة"))
}

Output:

القيود — Constraints

القيود تُحدد ما يمكن أن يكون عليه النوع المعمم:

main.go

package main

import (
    "cmp"
    "fmt"
)

// any — أي نوع (بدون قيود) — Any type
func PrintSlice[T any](s []T) {
    fmt.Print("[")
    for i, v := range s {
        if i > 0 {
            fmt.Print(", ")
        }
        fmt.Print(v)
    }
    fmt.Println("]")
}

// comparable — أنواع قابلة للمقارنة بـ == — Types that support ==
func Unique[T comparable](s []T) []T {
    seen := make(map[T]bool)
    result := []T{}
    for _, v := range s {
        if !seen[v] {
            seen[v] = true
            result = append(result, v)
        }
    }
    return result
}

// cmp.Ordered — أنواع قابلة للترتيب (<, >, <=, >=)
func Min[T cmp.Ordered](s []T) T {
    min := s[0]
    for _, v := range s[1:] {
        if v < min {
            min = v
        }
    }
    return min
}

func main() {
    // PrintSlice — أي نوع
    PrintSlice([]int{1, 2, 3})
    PrintSlice([]string{"أ", "ب", "ج"})

    // Unique — قابل للمقارنة
    fmt.Println("فريدة:", Unique([]int{1, 2, 2, 3, 3, 3}))
    fmt.Println("فريدة:", Unique([]string{"أ", "ب", "أ", "ج"}))

    // Min — قابل للترتيب
    fmt.Println("أصغر:", Min([]int{5, 2, 8, 1, 9}))
    fmt.Println("أصغر:", Min([]float64{3.14, 1.41, 2.71}))
}

Output:

قيود مخصصة — Custom Constraints

main.go

package main

import "fmt"

// قيد مخصص — Custom constraint
type Number interface {
    ~int | ~int32 | ~int64 | ~float32 | ~float64
}

// ~ تعني "أو أي نوع مبني عليه"
// ~ means "or any type based on it"

// دالة مجموع — Sum function
func Sum[T Number](nums []T) T {
    var total T
    for _, n := range nums {
        total += n
    }
    return total
}

// نوع مبني على int — Type based on int
type Score int

func main() {
    ints := []int{1, 2, 3, 4, 5}
    fmt.Println("مجموع ints:", Sum(ints))

    floats := []float64{1.5, 2.5, 3.5}
    fmt.Println("مجموع floats:", Sum(floats))

    // يعمل مع أنواع مبنية أيضاً — Works with derived types too
    scores := []Score{90, 85, 95}
    fmt.Println("مجموع scores:", Sum(scores))
}

Output:

أنواع معممة — Generic Types

ليس فقط الدوال — يمكنك إنشاء أنواع معممة:

main.go

package main

import "fmt"

// مكدس معمم — Generic stack
type Stack[T any] struct {
    items []T
}

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

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

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

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

func main() {
    // مكدس أعداد — Integer stack
    nums := &Stack[int]{}
    nums.Push(10)
    nums.Push(20)
    nums.Push(30)

    fmt.Printf("الحجم: %d\n", nums.Size())
    if v, ok := nums.Pop(); ok {
        fmt.Printf("Pop: %d\n", v)
    }
    if v, ok := nums.Peek(); ok {
        fmt.Printf("Peek: %d\n", v)
    }

    // مكدس نصوص — String stack
    names := &Stack[string]{}
    names.Push("أحمد")
    names.Push("فاطمة")
    if v, ok := names.Pop(); ok {
        fmt.Printf("Pop: %s\n", v)
    }
}

Output:

Map, Filter, Reduce

main.go

package main

import "fmt"

// Map — تحويل كل عنصر
func Map[T any, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

// Filter — تصفية العناصر
func Filter[T any](s []T, f func(T) bool) []T {
    var result []T
    for _, v := range s {
        if f(v) {
            result = append(result, v)
        }
    }
    return result
}

// Reduce — تجميع القيم
func Reduce[T any, U any](s []T, initial U, f func(U, T) U) U {
    acc := initial
    for _, v := range s {
        acc = f(acc, v)
    }
    return acc
}

func main() {
    nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    // Map: تربيع — Square each
    squares := Map(nums, func(n int) int { return n * n })
    fmt.Println("المربعات:", squares)

    // Filter: الزوجية فقط — Even only
    evens := Filter(nums, func(n int) bool { return n%2 == 0 })
    fmt.Println("الزوجية:", evens)

    // Reduce: المجموع — Sum
    sum := Reduce(nums, 0, func(acc, n int) int { return acc + n })
    fmt.Println("المجموع:", sum)

    // Map: أرقام → نصوص — Numbers to strings
    strs := Map(nums, func(n int) string { return fmt.Sprintf("#%d", n) })
    fmt.Println("نصوص:", strs)
}

Output:

متى تستخدم Generics؟

استخدم	لا تستخدم
هياكل بيانات (Stack, Queue, Set)	منطق أعمال محدد بنوع واحد
دوال مساعدة (Map, Filter, Sort)	عندما interface كافية
تقليل تكرار الكود الفعلي	لمجرد الاستعراض

تحدي — Challenge

package main

import (
    "cmp"
    "fmt"
)

// اكتب دالة معممة Min تُرجع أصغر عنصر
func Min[T cmp.Ordered](s []T) T {
    // اكتب الكود هنا
    return s[0]
}

// اكتب دالة معممة Max تُرجع أكبر عنصر
func Max[T cmp.Ordered](s []T) T {
    // اكتب الكود هنا
    return s[0]
}

// اكتب دالة معممة Sum تُرجع مجموع العناصر
func Sum[T cmp.Ordered](s []T) T {
    var total T
    // اكتب الكود هنا
    return total
}

func main() {
    nums := []int{3, 1, 4, 1, 5, 9, 2, 6}
    fmt.Println("أصغر:", Min(nums))
    fmt.Println("أكبر:", Max(nums))
    fmt.Println("المجموع:", Sum(nums))
}