Generic Functions लिखना

func Name[T constraint](param T) T {
    // body
}

result := Name[Type](arg)
result := Name(arg)

package main

import "fmt"

type Number interface {
	int | float64
}

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

func main() {
	fmt.Println(Sum([]int{1, 2, 3}))
	fmt.Println(Sum([]float64{1.5, 2.5}))
}

package main

import "fmt"

func Filter[T any](items []T, keep func(T) bool) []T {
	var result []T
	for _, item := range items {
		if keep(item) {
			result = append(result, item)
		}
	}
	return result
}

func main() {
	nums := []int{1, 2, 3, 4, 5, 6}
	even := Filter(nums, func(n int) bool { return n%2 == 0 })
	fmt.Println(even)
}

package main

import "fmt"

func Map[T, U any](items []T, f func(T) U) []U {
	result := make([]U, len(items))
	for i, item := range items {
		result[i] = f(item)
	}
	return result
}

func main() {
	nums := []int{1, 2, 3}
	strs := Map(nums, func(n int) string {
		return fmt.Sprintf("#%d", n)
	})
	fmt.Println(strs)
}

Generic Types क्या हैं · अनाम Functions · Variadic Functions क्या हैं · Files को Write करना

1. एक single generic Sum function के बजाय तीन लगभग-एक-जैसे functions (SumInts, SumFloats, ...) लिखना।
2. ऐसे function पर एक अत्यधिक permissive constraint (any) उपयोग करना जिसे असल में arithmetic operators चाहिए, + उपयोग होने पर एक compile error का कारण बनते हुए।
3. यह भूल जाना कि generic functions अब भी कई values return कर सकते हैं और सभी normal Go control flow उपयोग कर सकते हैं -- generics सिर्फ type parameter mechanism को प्रभावित करते हैं।

• एक generic function type parameters के साथ declared होता है, फिर उन parameters को किसी दूसरे type की तरह उपयोग करके एक बार implement किया जाता है।
• Constraints तय करते हैं कि function के अंदर किसी type parameter पर कौन से operators और methods valid हैं।
• Generic functions कई concrete-typed variants में लगभग-duplicate code खत्म करते हैं।
• Slices, maps, और दूसरी composite types सभी अपने element type के रूप में type parameters उपयोग कर सकती हैं।