Go 1.21 : Generics Matures et Nouvelles Optimisations

Go 1.21 : Maturité et Performance

Go 1.21 marque un tournant avec des améliorations significatives des generics, de nouvelles fonctions intégrées et des optimisations majeures.

1. Generics Améliorés

package main

import (
    "fmt"
    "constraints"
)

// Generic type avec contraintes avancées
type Numeric interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
    ~float32 | ~float64
}

// Structure générique optimisée
type SafeSlice[T any] struct {
    items []T
    mutex sync.RWMutex
}

func NewSafeSlice[T any]() *SafeSlice[T] {
    return &SafeSlice[T]{
        items: make([]T, 0),
    }
}

func (s *SafeSlice[T]) Add(item T) {
    s.mutex.Lock()
    defer s.mutex.Unlock()
    s.items = append(s.items, item)
}

func (s *SafeSlice[T]) Get(index int) (T, error) {
    s.mutex.RLock()
    defer s.mutex.RUnlock()
    
    var zero T
    if index < 0 || index >= len(s.items) {
        return zero, fmt.Errorf("index out of range")
    }
    
    return s.items[index], nil
}

// Fonctions génériques utilitaires
func Map[T, R any](slice []T, fn func(T) R) []R {
    result := make([]R, len(slice))
    for i, v := range slice {
        result[i] = fn(v)
    }
    return result
}

func Filter[T any](slice []T, predicate func(T) bool) []T {
    result := make([]T, 0, len(slice))
    for _, v := range slice {
        if predicate(v) {
            result = append(result, v)
        }
    }
    return result
}

func Reduce[T, R any](slice []T, initial R, reducer func(R, T) R) R {
    result := initial
    for _, v := range slice {
        result = reducer(result, v)
    }
    return result
}

// Usage pratique
func main() {
    numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    
    // Map: doubler chaque nombre
    doubled := Map(numbers, func(n int) int { return n * 2 })
    fmt.Println("Doubled:", doubled)
    
    // Filter: nombres pairs
    evens := Filter(numbers, func(n int) bool { return n%2 == 0 })
    fmt.Println("Evens:", evens)
    
    // Reduce: somme
    sum := Reduce(numbers, 0, func(acc, n int) int { return acc + n })
    fmt.Println("Sum:", sum)
    
    // SafeSlice générique
    safeInts := NewSafeSlice[int]()
    safeInts.Add(42)
    safeInts.Add(84)
    
    val, err := safeInts.Get(0)
    if err == nil {
        fmt.Println("First value:", val)
    }
}

Conclusion

Go 1.21 continue d'évoluer vers un langage plus expressif tout en gardant sa simplicité et ses performances exceptionnelles.