Structs Genéricas

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy — lição 70 de 107.

Assim como as funções, as structs também podem ter parâmetros de tipo. Uma struct genérica permite criar estruturas de dados que funcionam com qualquer tipo, mantendo a segurança de tipos. Isso é perfeito para construir contêineres reutilizáveis, como pilhas, filas ou pares de chave-valor.

Para definir uma struct genérica, coloque o parâmetro de tipo após o nome da struct:

type Box[T any] struct {
    Value T
}

func main() {
    intBox := Box[int]{Value: 42}
    strBox := Box[string]{Value: "hello"}
    
    fmt.Println(intBox.Value)  // 42
    fmt.Println(strBox.Value)  // hello
}

Ao contrário de funções genéricas, você deve especificar explicitamente o tipo ao criar uma instância de uma struct genérica. O Go não consegue inferir o tipo apenas pelo contexto.

Structs genéricas podem ter múltiplos parâmetros de tipo, tornando-as ideais para estruturas como pares ou mapas:

type Pair[K, V any] struct {
    Key   K
    Value V
}

p := Pair[string, int]{Key: "age", Value: 25}
fmt.Printf("%s: %d\n", p.Key, p.Value)  // age: 25

Você também pode aplicar restrições para garantir que os tipos armazenados suportem operações específicas:

type NumberBox[T int | float64] struct {
    Value T
}

nb := NumberBox[float64]{Value: 3.14}

Structs genéricas formam a base para a construção de estruturas de dados reutilizáveis e seguras quanto ao tipo em Go. Na próxima lição, você aprenderá como definir métodos nesses tipos genéricos.

Desafio

Fácil

Vamos construir um sistema de inventário genérico que pode rastrear diferentes tipos de itens! Você criará estruturas de contêiner reutilizáveis que funcionam com qualquer tipo, mantendo total segurança de tipos.

Você organizará seu código em dois arquivos:

inventory.go: Defina suas estruturas de contêiner genéricas.
Crie uma struct genérica Item[T any] com dois campos: Name (string) e Data (do tipo T). Isso representa qualquer item com dados associados de um tipo flexível.

Crie uma struct genérica Container[T any] com um único campo Items que contém um slice de Item[T]. Este contêiner pode armazenar vários itens do mesmo tipo de dado.

Crie uma struct genérica com restrição PricedItem[T int | float64] com três campos: Name (string), Quantity (int) e Price (do tipo T). A restrição garante que os preços sejam sempre numéricos.

Implemente uma função NewContainer[T any]() *Container[T] que cria e retorna um ponteiro para um Container vazio.

Implemente um método Add em *Container[T] que recebe um nome (string) e dados (T), cria um Item e o anexa ao slice Items do contêiner.

Implemente um método Count em Container[T] que retorna o número de itens no contêiner.
main.go: Demonstre suas estruturas genéricas com diferentes tipos.
Leia um tipo de item (string, int ou priced), depois leia uma contagem seguida pelos detalhes do item.

Para o tipo string: Leia pares de nome e dados de string. Crie um Container[string], adicione todos os itens e, em seguida, imprima cada item como [Name]: [Data] seguido pela contagem total.

Para o tipo int: Leia pares de nome e dados inteiros. Crie um Container[int], adicione todos os itens e, em seguida, imprima cada item como [Name]: [Data] seguido pela contagem total.

Para o tipo priced: Leia trios de nome, quantidade e preço (como float). Crie instâncias de PricedItem[float64] diretamente e imprima cada uma como [Name] x[Quantity] @ [Price] com o preço exibindo uma casa decimal.

Imprima a linha de contagem como: Total items: [count]

As seguintes entradas serão fornecidas:

Linha 1: Tipo de item (string, int ou priced)
Linha 2: Contagem de itens (inteiro)
Linhas seguintes: Detalhes do item com base no tipo

Por exemplo, dado:

string
3
Book
Fiction Novel
Pen
Blue Ink
Notebook
Lined Paper

Sua saída deve ser:

Book: Fiction Novel
Pen: Blue Ink
Notebook: Lined Paper
Total items: 3

E dado:

int
2
Apples
50
Oranges
30

Sua saída deve ser:

Apples: 50
Oranges: 30
Total items: 2

E dado:

priced
2
Widget
10
19.99
Gadget
5
49.50

Sua saída deve ser:

Widget x10 @ 19.9
Gadget x5 @ 49.5
Total items: 2

Observe como a mesma estrutura Container funciona perfeitamente com strings e inteiros, enquanto PricedItem usa uma restrição para garantir que apenas tipos numéricos possam ser usados para preços. Você deve especificar explicitamente o parâmetro de tipo ao criar instâncias dessas structs genéricas.

Folha de consulta

Uma struct genérica permite que você crie estruturas de dados que funcionam com qualquer tipo, mantendo a segurança de tipos.

Para definir uma struct genérica, coloque o parâmetro de tipo após o nome da struct:

type Box[T any] struct {
    Value T
}

Ao criar uma instância de uma struct genérica, você deve especificar explicitamente o tipo (o Go não consegue inferi-lo):

intBox := Box[int]{Value: 42}
strBox := Box[string]{Value: "hello"}

Structs genéricas podem ter múltiplos parâmetros de tipo:

type Pair[K, V any] struct {
    Key   K
    Value V
}

p := Pair[string, int]{Key: "age", Value: 25}

Você pode aplicar restrições (constraints) para garantir que os tipos armazenados suportem operações específicas:

type NumberBox[T int | float64] struct {
    Value T
}

nb := NumberBox[float64]{Value: 3.14}

Structs genéricas podem conter campos que utilizam o parâmetro de tipo, incluindo slices:

type Container[T any] struct {
    Items []T
}

Você pode definir métodos em structs genéricas e criar funções construtoras genéricas:

func NewContainer[T any]() *Container[T] {
    return &Container[T]{Items: []T{}}
}

func (c *Container[T]) Add(item T) {
    c.Items = append(c.Items, item)
}

Experimente você mesmo

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Ler o tipo de item
	scanner.Scan()
	itemType := scanner.Text()
	
	// Ler a contagem
	scanner.Scan()
	count, _ := strconv.Atoi(scanner.Text())
	
	switch itemType {
	case "string":
		// TODO: Criar um Container[string] usando NewContainer
		// TODO: Ler 'count' itens (cada um tem o nome em uma linha, os dados na linha seguinte)
		// TODO: Adicionar cada item ao container
		// TODO: Imprimir cada item como "[Name]: [Data]"
		// TODO: Imprimir "Total items: [count]" usando o método Count
		
	case "int":
		// TODO: Criar um Container[int] usando NewContainer
		// TODO: Ler 'count' itens (cada um tem o nome em uma linha, dados inteiros na linha seguinte)
		// TODO: Adicionar cada item ao container
		// TODO: Imprimir cada item como "[Name]: [Data]"
		// TODO: Imprimir "Total items: [count]" usando o método Count
		
	case "priced":
		// TODO: Criar um slice para conter instâncias de PricedItem[float64]
		// TODO: Ler 'count' itens (cada um tem nome, quantidade e preço em linhas separadas)
		// TODO: Criar PricedItem[float64] para cada um e adicionar ao slice
		// TODO: Imprimir cada item como "[Name] x[Quantity] @ [Price]" com o preço mostrando uma casa decimal
		// TODO: Imprimir "Total items: [count]"
	}
	
	_ = scanner // Usar scanner para ler a entrada
	_ = count   // Usar count para o loop
}