comparable Constraint क्या है

func Name[T comparable](a, b T) bool {
    return a == b
}

package main

import "fmt"

func Contains[T comparable](items []T, target T) bool {
	for _, item := range items {
		if item == target {
			return true
		}
	}
	return false
}

func main() {
	fmt.Println(Contains([]int{1, 2, 3}, 2))
	fmt.Println(Contains([]string{"a", "b"}, "c"))
}

package main

import "fmt"

func CountOccurrences[T comparable](items []T) map[T]int {
	counts := make(map[T]int)
	for _, item := range items {
		counts[item]++
	}
	return counts
}

func main() {
	fmt.Println(CountOccurrences([]string{"a", "b", "a", "c", "b", "a"}))
}

package main

import "fmt"

func Unique[T comparable](items []T) []T {
	seen := make(map[T]bool)
	var result []T
	for _, item := range items {
		if !seen[item] {
			seen[item] = true
			result = append(result, item)
		}
	}
	return result
}

func main() {
	fmt.Println(Unique([]int{1, 2, 2, 3, 1, 4}))
}

Type की Constraints · Generic Types क्या हैं · Generic Functions लिखना · Type के Parameters

1. किसी slice या map type parameter के साथ comparable उपयोग करने की कोशिश करना, क्योंकि slices और maps Go में खुद comparable नहीं हैं।
2. यह भूल जाना कि comparable सिर्फ == और != काम करने की गारंटी देता है -- यह ordering (<, >) के बारे में कुछ नहीं कहता, जिसके लिए एक अलग constraint चाहिए।
3. एक ऐसा generic function लिखना जिसे एक type को map key के रूप में चाहिए बिना इसे comparable से constrain किए, एक compile error का कारण बनते हुए।

• built-in comparable constraint किसी type parameter को == और != से compare होने देता है।
• comparable तब ज़रूरी है जब किसी type parameter को map key के रूप में उपयोग किया जाए।
• हर type comparable नहीं है -- slices, maps, और functions इसमें शामिल नहीं हैं।
• comparable ordering का मतलब नहीं रखता; < और > के लिए एक अलग constraint (जैसे Ordered) उपयोग करें।