1# Generics and Type Parameters
2 
3## Basic Type Parameters
4 
5```go
6package main
7 
8// Generic function with type parameter
9func Max[T constraints.Ordered](a, b T) T {
10    if a > b {
11        return a
12    }
13    return b
14}
15 
16// Multiple type parameters
17func Map[T, U any](slice []T, fn func(T) U) []U {
18    result := make([]U, len(slice))
19    for i, v := range slice {
20        result[i] = fn(v)
21    }
22    return result
23}
24 
25// Usage
26func main() {
27    maxInt := Max(10, 20)           // T = int
28    maxFloat := Max(3.14, 2.71)     // T = float64
29    maxString := Max("abc", "xyz")  // T = string
30 
31    nums := []int{1, 2, 3}
32    doubled := Map(nums, func(n int) int { return n * 2 })
33    strings := Map(nums, func(n int) string { return fmt.Sprintf("%d", n) })
34}
35```
36 
37## Type Constraints
38 
39```go
40import "constraints"
41 
42// Built-in constraints
43type Number interface {
44    constraints.Integer | constraints.Float
45}
46 
47func Sum[T Number](numbers []T) T {
48    var total T
49    for _, n := range numbers {
50        total += n
51    }
52    return total
53}
54 
55// Custom constraints with methods
56type Stringer interface {
57    String() string
58}
59 
60func PrintAll[T Stringer](items []T) {
61    for _, item := range items {
62        fmt.Println(item.String())
63    }
64}
65 
66// Approximate constraint using ~
67type Integer interface {
68    ~int | ~int8 | ~int16 | ~int32 | ~int64
69}
70 
71type MyInt int
72 
73func Double[T Integer](n T) T {
74    return n * 2
75}
76 
77// Works with both int and MyInt
78func main() {
79    fmt.Println(Double(5))          // int
80    fmt.Println(Double(MyInt(5)))   // MyInt
81}
82```
83 
84## Generic Data Structures
85 
86```go
87// Generic Stack
88type Stack[T any] struct {
89    items []T
90}
91 
92func NewStack[T any]() *Stack[T] {
93    return &Stack[T]{
94        items: make([]T, 0),
95    }
96}
97 
98func (s *Stack[T]) Push(item T) {
99    s.items = append(s.items, item)
100}
101 
102func (s *Stack[T]) Pop() (T, bool) {
103    if len(s.items) == 0 {
104        var zero T
105        return zero, false
106    }
107    item := s.items[len(s.items)-1]
108    s.items = s.items[:len(s.items)-1]
109    return item, true
110}
111 
112func (s *Stack[T]) IsEmpty() bool {
113    return len(s.items) == 0
114}
115 
116// Usage
117intStack := NewStack[int]()
118intStack.Push(1)
119intStack.Push(2)
120 
121stringStack := NewStack[string]()
122stringStack.Push("hello")
123stringStack.Push("world")
124```
125 
126## Generic Map Operations
127 
128```go
129// Filter with generics
130func Filter[T any](slice []T, predicate func(T) bool) []T {
131    result := make([]T, 0, len(slice))
132    for _, v := range slice {
133        if predicate(v) {
134            result = append(result, v)
135        }
136    }
137    return result
138}
139 
140// Reduce/Fold
141func Reduce[T, U any](slice []T, initial U, fn func(U, T) U) U {
142    acc := initial
143    for _, v := range slice {
144        acc = fn(acc, v)
145    }
146    return acc
147}
148 
149// Keys from map
150func Keys[K comparable, V any](m map[K]V) []K {
151    keys := make([]K, 0, len(m))
152    for k := range m {
153        keys = append(keys, k)
154    }
155    return keys
156}
157 
158// Values from map
159func Values[K comparable, V any](m map[K]V) []V {
160    values := make([]V, 0, len(m))
161    for _, v := range m {
162        values = append(values, v)
163    }
164    return values
165}
166 
167// Usage
168numbers := []int{1, 2, 3, 4, 5, 6}
169evens := Filter(numbers, func(n int) bool { return n%2 == 0 })
170 
171sum := Reduce(numbers, 0, func(acc, n int) int { return acc + n })
172 
173m := map[string]int{"a": 1, "b": 2}
174keys := Keys(m)     // []string{"a", "b"}
175values := Values(m) // []int{1, 2}
176```
177 
178## Generic Pairs and Tuples
179 
180```go
181// Generic Pair
182type Pair[T, U any] struct {
183    First  T
184    Second U
185}
186 
187func NewPair[T, U any](first T, second U) Pair[T, U] {
188    return Pair[T, U]{First: first, Second: second}
189}
190 
191func (p Pair[T, U]) Swap() Pair[U, T] {
192    return Pair[U, T]{First: p.Second, Second: p.First}
193}
194 
195// Usage
196pair := NewPair("name", 42)
197swapped := pair.Swap() // Pair[int, string]
198 
199// Generic Result type (like Rust's Result<T, E>)
200type Result[T any] struct {
201    value T
202    err   error
203}
204 
205func Ok[T any](value T) Result[T] {
206    return Result[T]{value: value}
207}
208 
209func Err[T any](err error) Result[T] {
210    return Result[T]{err: err}
211}
212 
213func (r Result[T]) IsOk() bool {
214    return r.err == nil
215}
216 
217func (r Result[T]) Unwrap() (T, error) {
218    return r.value, r.err
219}
220 
221func (r Result[T]) UnwrapOr(defaultValue T) T {
222    if r.err != nil {
223        return defaultValue
224    }
225    return r.value
226}
227```
228 
229## Comparable Constraint
230 
231```go
232// Find using comparable
233func Find[T comparable](slice []T, target T) (int, bool) {
234    for i, v := range slice {
235        if v == target {
236            return i, true
237        }
238    }
239    return -1, false
240}
241 
242// Contains
243func Contains[T comparable](slice []T, target T) bool {
244    _, found := Find(slice, target)
245    return found
246}
247 
248// Unique elements
249func Unique[T comparable](slice []T) []T {
250    seen := make(map[T]struct{})
251    result := make([]T, 0, len(slice))
252 
253    for _, v := range slice {
254        if _, exists := seen[v]; !exists {
255            seen[v] = struct{}{}
256            result = append(result, v)
257        }
258    }
259 
260    return result
261}
262 
263// Usage
264nums := []int{1, 2, 2, 3, 3, 4}
265unique := Unique(nums) // []int{1, 2, 3, 4}
266 
267idx, found := Find([]string{"a", "b", "c"}, "b") // 1, true
268```
269 
270## Generic Interfaces
271 
272```go
273// Generic interface
274type Container[T any] interface {
275    Add(item T)
276    Remove() (T, bool)
277    Size() int
278}
279 
280// Implementation
281type Queue[T any] struct {
282    items []T
283}
284 
285func (q *Queue[T]) Add(item T) {
286    q.items = append(q.items, item)
287}
288 
289func (q *Queue[T]) Remove() (T, bool) {
290    if len(q.items) == 0 {
291        var zero T
292        return zero, false
293    }
294    item := q.items[0]
295    q.items = q.items[1:]
296    return item, true
297}
298 
299func (q *Queue[T]) Size() int {
300    return len(q.items)
301}
302 
303// Function accepting generic interface
304func ProcessContainer[T any](c Container[T], item T) {
305    c.Add(item)
306    fmt.Printf("Container size: %d\n", c.Size())
307}
308```
309 
310## Type Inference
311 
312```go
313// Type inference works in most cases
314func Identity[T any](x T) T {
315    return x
316}
317 
318// No need to specify type
319result := Identity(42)          // T inferred as int
320str := Identity("hello")        // T inferred as string
321 
322// Type inference with constraints
323func Min[T constraints.Ordered](a, b T) T {
324    if a < b {
325        return a
326    }
327    return b
328}
329 
330// Inferred from arguments
331minVal := Min(10, 20)           // T = int
332minFloat := Min(1.5, 2.5)       // T = float64
333 
334// Explicit type when needed
335result := Map[int, string]([]int{1, 2}, func(n int) string {
336    return fmt.Sprintf("%d", n)
337})
338```
339 
340## Generic Channels
341 
342```go
343// Generic channel operations
344func Merge[T any](channels ...<-chan T) <-chan T {
345    out := make(chan T)
346    var wg sync.WaitGroup
347 
348    for _, ch := range channels {
349        wg.Add(1)
350        go func(c <-chan T) {
351            defer wg.Done()
352            for v := range c {
353                out <- v
354            }
355        }(ch)
356    }
357 
358    go func() {
359        wg.Wait()
360        close(out)
361    }()
362 
363    return out
364}
365 
366// Generic pipeline stage
367func Stage[T, U any](in <-chan T, fn func(T) U) <-chan U {
368    out := make(chan U)
369    go func() {
370        defer close(out)
371        for v := range in {
372            out <- fn(v)
373        }
374    }()
375    return out
376}
377 
378// Usage
379ch1 := make(chan int)
380ch2 := make(chan int)
381 
382merged := Merge(ch1, ch2)
383 
384numbers := make(chan int)
385doubled := Stage(numbers, func(n int) int { return n * 2 })
386strings := Stage(doubled, func(n int) string { return fmt.Sprintf("%d", n) })
387```
388 
389## Union Constraints
390 
391```go
392// Union of types
393type StringOrInt interface {
394    string | int
395}
396 
397func Process[T StringOrInt](val T) string {
398    return fmt.Sprintf("%v", val)
399}
400 
401// More complex unions
402type Numeric interface {
403    int | int8 | int16 | int32 | int64 |
404    uint | uint8 | uint16 | uint32 | uint64 |
405    float32 | float64
406}
407 
408func Abs[T Numeric](n T) T {
409    if n < 0 {
410        return -n
411    }
412    return n
413}
414 
415// Union with methods
416type Serializable interface {
417    string | []byte
418}
419 
420func Serialize[T Serializable](data T) []byte {
421    switch v := any(data).(type) {
422    case string:
423        return []byte(v)
424    case []byte:
425        return v
426    default:
427        panic("unreachable")
428    }
429}
430```
431 
432## Quick Reference
433 
434| Feature | Syntax | Use Case |
435|---------|--------|----------|
436| Basic generic | `func F[T any]()` | Any type |
437| Constraint | `func F[T Constraint]()` | Restricted types |
438| Multiple params | `func F[T, U any]()` | Multiple type variables |
439| Comparable | `func F[T comparable]()` | Types supporting == and != |
440| Ordered | `func F[T constraints.Ordered]()` | Types supporting <, >, <=, >= |
441| Union | `T interface{int \| string}` | Either type |
442| Approximate | `~int` | Include type aliases |
443