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 criar 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 criar um sistema genérico de inventário que possa acompanhar diferentes tipos de itens! Você criará estruturas de contêiner reutilizáveis que funcionam com qualquer tipo, mantendo a segurança total de tipos.

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

inventory.go: Defina suas estruturas genéricas de contêiner.
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 armazena um slice de Item[T]. Esse 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 adiciona 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) e, em seguida, leia uma quantidade seguida pelos detalhes dos itens.

Para o tipo string: leia pares de nome e dados string. Crie um Container[string], adicione todos os itens e, em seguida, imprima cada item como [Name]: [Data], seguido pela quantidade 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 quantidade 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 exibido com uma casa decimal.

Imprima a linha da quantidade como: Total items: [count]

As entradas a seguir serão fornecidas:

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

Por exemplo, considerando:

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 considerando:

int
2
Apples
50
Oranges
30

Sua saída deve ser:

Apples: 50
Oranges: 30
Total items: 2

E considerando:

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 tanto com strings quanto com inteiros, enquanto PricedItem usa uma restrição para garantir que somente 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.

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
}