Go 1 23

// Iterator function
func Count(n int) func(func(int) bool) {
    return func(yield func(int) bool) {
        for i := 0; i < n; i++ {
            if !yield(i) {
                return
            }
        }
    }
}

// Range over iterator
for i := range Count(5) {
    fmt.Println(i)  // 0, 1, 2, 3, 4
}

import "iter"

func Fibonacci(max int) iter.Seq[int] {
    return func(yield func(int) bool) {
        a, b := 0, 1
        for a <= max {
            if !yield(a) {
                return
            }
            a, b = b, a+b
        }
    }
}

for n := range Fibonacci(100) {
    fmt.Println(n)  // 0, 1, 1, 2, 3, 5, 8, 13, ...
}

import "unique"

// Canonicalize values
h1 := unique.Make("hello")
h2 := unique.Make("hello")

fmt.Println(h1 == h2)  // true (same Handle, shares storage)

// Use case: String interning
type Logger struct {
    messages []unique.Handle[string]
}

func (l *Logger) Log(message string) {
    l.messages = append(l.messages, unique.Make(message))
    // Repeated strings share storage
}

func createTimer() {
    timer := time.NewTimer(time.Hour)
    // Timer becomes unreachable - GC reclaims it
    // No explicit Stop() needed for GC
}

import "slices"

s := []string{"a", "b", "c"}

// Iterate with index
for i, v := range slices.All(s) {
    fmt.Printf("%d: %s\n", i, v)
}

// Values only
for v := range slices.Values(s) {
    fmt.Println(v)
}

// Backward iteration
for i, v := range slices.Backward(s) {
    fmt.Printf("%d: %s\n", i, v)  // 2: c, 1: b, 0: a
}