Introducción a los Genéricos

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy — lección 67 de 107.

Antes de Go 1.18, escribir código reutilizable para diferentes tipos significaba duplicar funciones o usar la interfaz vacía any con aserciones de tipo. Los genéricos resuelven este problema permitiéndote escribir funciones y tipos que funcionan con múltiples tipos manteniendo al mismo tiempo una seguridad de tipos completa.

Considera buscar el valor mínimo en un slice. Sin genéricos, necesitarías funciones separadas para cada tipo:

func MinInt(values []int) int {
    min := values[0]
    for _, v := range values {
        if v < min {
            min = v
        }
    }
    return min
}

func MinFloat64(values []float64) float64 {
    min := values[0]
    for _, v := range values {
        if v < min {
            min = v
        }
    }
    return min
}

Con los genéricos, escribes la lógica una sola vez usando un parámetro de tipo entre corchetes:

func Min[T int | float64](values []T) T {
    min := values[0]
    for _, v := range values {
        if v < min {
            min = v
        }
    }
    return min
}

El [T int | float64] declara un parámetro de tipo T que puede ser int o float64. Ahora puedes llamar a Min([]int{3, 1, 2}) o Min([]float64{3.5, 1.2}) con la misma función. El compilador verifica los tipos en tiempo de compilación, por lo que obtienes seguridad sin sobrecarga en tiempo de ejecución.

En las próximas lecciones, exploraremos en detalle los parámetros de tipo, las restricciones y los structs genéricos.

Desafío

Fácil

¡Vamos a construir un analizador de puntuaciones que funcione tanto con puntuaciones enteras como de punto flotante utilizando genéricos! Crearás una única función genérica que pueda encontrar el valor máximo en un slice, eliminando la necesidad de duplicar código para diferentes tipos numéricos.

Organizarás tu código en dos archivos:

analyzer.go: Define tu función de análisis genérica.
Crea una función genérica Max[T int | float64](values []T) T que encuentre y devuelva el valor máximo en un slice. La función debe funcionar con los tipos int y float64 a través del parámetro de tipo T.

También crea una función genérica Sum[T int | float64](values []T) T que calcule y devuelva la suma de todos los valores en un slice.
main.go: Lee la entrada y demuestra tus funciones genéricas con diferentes tipos.
Lee un indicador de tipo (int o float), luego lee un conteo seguido de esa cantidad de valores. Procesa los valores según el tipo, llama tanto a Max como a Sum con el tipo apropiado y formatea los resultados.

Para la entrada de enteros, imprime:
```
Max (int): [value]
Sum (int): [value]
```
Para la entrada de flotantes, imprime con un decimal:
```
Max (float): [value]
Sum (float): [value]
```

Se proporcionarán las siguientes entradas:

Línea 1: Indicador de tipo (int o float)
Línea 2: Conteo de valores (entero)
Líneas siguientes: Un valor por línea

Por ejemplo, dado:

Tu salida debería ser:

Max (int): 23
Sum (int): 57

Y dado:

float
3
4.5
9.2
6.8

Tu salida debería ser:

Max (float): 9.2
Sum (float): 20.5

Observa cómo las mismas funciones genéricas manejan tanto datos enteros como de punto flotante; el parámetro de tipo [T int | float64] permite al compilador generar código seguro para cada uso mientras tú solo escribes la lógica una vez.

Pruébalo tú mismo

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Leer el indicador de tipo
	typeStr, _ := reader.ReadString('\n')
	typeStr = strings.TrimSpace(typeStr)

	// Leer la cantidad
	countStr, _ := reader.ReadString('\n')
	count, _ := strconv.Atoi(strings.TrimSpace(countStr))

	if typeStr == "int" {
		// Leer los valores enteros
		values := make([]int, count)
		for i := 0; i < count; i++ {
			line, _ := reader.ReadString('\n')
			values[i], _ = strconv.Atoi(strings.TrimSpace(line))
		}

		// TODO: Llamar a Max y Sum con el slice de enteros
		// TODO: Imprimir los resultados en el formato "Max (int): [value]" y "Sum (int): [value]"

	} else if typeStr == "float" {
		// Leer los valores flotantes
		values := make([]float64, count)
		for i := 0; i < count; i++ {
			line, _ := reader.ReadString('\n')
			values[i], _ = strconv.ParseFloat(strings.TrimSpace(line), 64)
		}

		// TODO: Llamar a Max y Sum con el slice de float64
		// TODO: Imprimir los resultados con un decimal en el formato "Max (float): [value]" y "Sum (float): [value]"
	}
}