Go 1.23 - Iteradores e Telemetria

Visao Geral do Go 1.23

Lancado em agosto de 2024, o Go 1.23 introduziu a tao esperada funcionalidade de iteradores (range over func), alem de muitas melhorias na biblioteca padrao.

Referencia: Go 1.23 Release Notes

range over func (Iteradores)

Uso Basico

Agora e possivel iterar diretamente sobre funcoes em loops for.

package main

import "fmt"

// Definindo uma funcao iteradora
func Backward[E any](s []E) func(yield func(E) bool) {
    return func(yield func(E) bool) {
        for i := len(s) - 1; i >= 0; i-- {
            if !yield(s[i]) {
                return
            }
        }
    }
}

func main() {
    s := []string{"a", "b", "c"}

    // Usando o iterador
    for v := range Backward(s) {
        fmt.Println(v) // c, b, a
    }
}

Pacote iter

Foi adicionado o novo pacote padrao iter.

import "iter"

// Seq: sequencia de valores
type Seq[V any] func(yield func(V) bool)

// Seq2: sequencia de pares chave-valor
type Seq2[K, V any] func(yield func(K, V) bool)

// Pull: converte estilo push para estilo pull
func Pull[V any](seq Seq[V]) (next func() (V, bool), stop func())

Extensoes do Pacote slices

import "slices"

s := []int{1, 2, 3, 4, 5}

// All: itera sobre todos os elementos
for i, v := range slices.All(s) {
    fmt.Printf("indice: %d, valor: %d\n", i, v)
}

// Backward: itera em ordem reversa
for i, v := range slices.Backward(s) {
    fmt.Println(i, v)
}

// Values: apenas valores sem indice
for v := range slices.Values(s) {
    fmt.Println(v)
}

// Chunk: divide em grupos de n elementos
for chunk := range slices.Chunk(s, 2) {
    fmt.Println(chunk) // [1 2], [3 4], [5]
}

Referencia: Go iter package

Extensoes do Pacote maps

import "maps"

m := map[string]int{"a": 1, "b": 2, "c": 3}

// Keys: iterador de chaves
for k := range maps.Keys(m) {
    fmt.Println(k)
}

// Values: iterador de valores
for v := range maps.Values(m) {
    fmt.Println(v)
}

// All: iterador de chaves e valores
for k, v := range maps.All(m) {
    fmt.Printf("%s: %d\n", k, v)
}

// Insert: insere no mapa a partir de um iterador
maps.Insert(m, slices.All([]struct{k string; v int}{{"d", 4}}))

Pacote unique

Fornece normalizacao (interning) de valores com eficiencia de memoria.

import "unique"

// Normalizacao de strings
h1 := unique.Make("hello")
h2 := unique.Make("hello")

// Strings iguais retornam o mesmo handle
fmt.Println(h1 == h2) // true

// Obtendo o valor
fmt.Println(h1.Value()) // "hello"

// Pode ser usado com qualquer tipo comparavel
type Point struct{ X, Y int }
p1 := unique.Make(Point{1, 2})
p2 := unique.Make(Point{1, 2})
fmt.Println(p1 == p2) // true

Referencia: Go unique package

Melhorias no time.Timer

O garbage collection e o comportamento do canal foram melhorados.

import "time"

// Timers nao utilizados sao coletados automaticamente pelo GC
timer := time.NewTimer(time.Hour)
// Nao e mais necessario chamar timer.Stop() para GC

// Comportamento do Reset foi melhorado
timer = time.NewTimer(time.Second)
if !timer.Stop() {
    // Go 1.23: o canal e drenado automaticamente
    // Antes: era necessario <-timer.C
}
timer.Reset(time.Minute)

Pacote structs (Experimental)

Permite controlar o layout de estruturas.

import "structs"

type Data struct {
    _     structs.HostLayout  // Usa o layout do host
    Value int64
}

Telemetria

Foi adicionada funcionalidade para coletar estatisticas de uso do toolchain Go.

# Verificar status da telemetria
go telemetry

# Habilitar telemetria (opt-in)
go telemetry on

# Desabilitar telemetria
go telemetry off

# Apenas local (sem upload)
go telemetry local

Referencia: Go Telemetry

Melhorias no Toolchain

Melhorias no go vet

// Novo aviso: captura de variavel de loop (continuacao do Go 1.22)
for _, v := range values {
    go func() {
        fmt.Println(v) // Sem aviso (corrigido no Go 1.22+)
    }()
}

Melhorias no go mod

# Exibicao em arvore das dependencias melhorada
go mod graph

# Informacoes de versao mais detalhadas
go version -m ./binary

Melhorias de Desempenho

PGO (Profile-Guided Optimization)

# Coleta de perfil
go test -cpuprofile=default.pgo -bench=.

# Build com PGO
go build -pgo=auto

Resumo

O Go 1.23 representa uma evolucao importante tanto em recursos da linguagem quanto no toolchain.

• range over func: A tao esperada funcionalidade de iteradores
• Pacote iter: Suporte a iteradores na biblioteca padrao
• Pacote unique: Normalizacao de valores com eficiencia de memoria
• Melhorias no time.Timer: Melhorias no GC e API
• Telemetria: Coleta de dados para melhorias no toolchain

A funcionalidade de iteradores em particular tera um grande impacto no estilo de codigo Go.