Type की Constraints

type Constraint interface {
    ~int | ~float64 | string
}

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

package main

import "fmt"

type Ordered interface {
	int | int64 | float64 | string
}

func Max[T Ordered](a, b T) T {
	if a > b {
		return a
	}
	return b
}

func main() {
	fmt.Println(Max(3, 9))
	fmt.Println(Max("apple", "banana"))
}

package main

import "fmt"

type Stringer interface {
	String() string
}

func PrintAll[T Stringer](items []T) {
	for _, item := range items {
		fmt.Println(item.String())
	}
}

type Item struct {
	Name string
}

func (i Item) String() string { return "Item: " + i.Name }

func main() {
	PrintAll([]Item{{Name: "Pen"}, {Name: "Book"}})
}

package main

import "fmt"

type Numeric interface {
	~int | ~float64
}

func Average[T Numeric](nums []T) float64 {
	var total T
	for _, n := range nums {
		total += n
	}
	return float64(total) / float64(len(nums))
}

func main() {
	fmt.Println(Average([]int{2, 4, 6}))
}

Type के Parameters · Type के Switches · Type के Assertions · Type का Conversion

1. एक constraint interface define करना लेकिन यह भूल जाना कि types का एक union (int | float64) ही असल में arithmetic operators की अनुमति देता है, सिर्फ method requirements नहीं।
2. किसी struct के अपने methods को एक explicit interface declare किए बिना एक implicit constraint के रूप में उपयोग करने की कोशिश करना।
3. किसी constraint को ज़रूरत से ज़्यादा जटिल बनाना जब built-in any या standard library का constraints/cmp package पहले से ज़रूरत पूरी करता हो।

• एक constraint एक interface है जो सीमित करता है कि किसी type parameter के लिए कौन सी types substitute की जा सकती हैं।
• types का एक union, जैसे int | float64, + या < जैसे operators की अनुमति देने के लिए एक constraint में उपयोग होता है।
• built-in comparable constraint किसी type parameter पर == और != की अनुमति देता है।
• Constraints किसी भी regular interface की तरह specific methods भी मांग सकते हैं।