Generics em Go 1.18

Introdução

Este laboratório introduz o conceito de generics (genéricos) em Golang. A partir da versão 1.18, Golang adicionou suporte a generics, o que nos permite escrever código mais flexível e reutilizável.

Generics (Genéricos)

O problema a ser resolvido neste laboratório é entender como definir e usar funções e tipos genéricos em Golang.

• Entender o conceito de generics em Golang.
• Saber como definir funções genéricas com parâmetros de tipo e restrições.
• Saber como definir tipos genéricos com parâmetros de tipo.
• Entender como definir métodos em tipos genéricos.
• Saber como invocar funções genéricas com inferência de tipo.

$ go run generics.go
keys: [4 1 2]
list: [10 13 23]

A seguir, o código completo:

// Starting with version 1.18, Go has added support for
// _generics_, also known as _type parameters_.

package main

import "fmt"

// As an example of a generic function, `MapKeys` takes
// a map of any type and returns a slice of its keys.
// This function has two type parameters - `K` and `V`;
// `K` has the `comparable` _constraint_, meaning that
// we can compare values of this type with the `==` and
// `!=` operators. This is required for map keys in Go.
// `V` has the `any` constraint, meaning that it's not
// restricted in any way (`any` is an alias for `interface{}`).
func MapKeys[K comparable, V any](m map[K]V) []K {
    r := make([]K, 0, len(m))
    for k := range m {
        r = append(r, k)
    }
    return r
}

// As an example of a generic type, `List` is a
// singly-linked list with values of any type.
type List[T any] struct {
    head, tail *element[T]
}

type element[T any] struct {
    next *element[T]
    val  T
}

// We can define methods on generic types just like we
// do on regular types, but we have to keep the type
// parameters in place. The type is `List[T]`, not `List`.
func (lst *List[T]) Push(v T) {
    if lst.tail == nil {
        lst.head = &element[T]{val: v}
        lst.tail = lst.head
    } else {
        lst.tail.next = &element[T]{val: v}
        lst.tail = lst.tail.next
    }
}

func (lst *List[T]) GetAll() []T {
    var elems []T
    for e := lst.head; e != nil; e = e.next {
        elems = append(elems, e.val)
    }
    return elems
}

func main() {
    var m = map[int]string{1: "2", 2: "4", 4: "8"}

    // When invoking generic functions, we can often rely
    // on _type inference_. Note that we don't have to
    // specify the types for `K` and `V` when
    // calling `MapKeys` - the compiler infers them
    // automatically.
    fmt.Println("keys:", MapKeys(m))

    // ... though we could also specify them explicitly.
    _ = MapKeys[int, string](m)

    lst := List[int]{}
    lst.Push(10)
    lst.Push(13)
    lst.Push(23)
    fmt.Println("list:", lst.GetAll())
}

Resumo

Generics (Genéricos) são um recurso poderoso que nos permite escrever código mais flexível e reutilizável em Golang. Com generics, podemos definir funções e tipos que funcionam com qualquer tipo, desde que satisfaçam certas restrições. Ao usar generics, podemos reduzir a duplicação de código e melhorar a legibilidade e a capacidade de manutenção do código.