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 al permitirte escribir funciones y tipos que funcionen 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 genéricos, escribes la lógica una 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 comprueba 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 las estructuras genéricas.

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 recuento 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: Recuento 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.

Hoja de referencia

Los genéricos le permiten escribir código reutilizable que funciona con múltiples tipos manteniendo la seguridad de tipos. Antes de Go 1.18, se necesitaban funciones separadas para cada tipo o se utilizaba la interfaz vacía con aserciones de tipo.

Los parámetros de tipo se declaran entre corchetes y especifican qué tipos puede aceptar una función genérica:

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

La sintaxis [T int | float64] declara un parámetro de tipo T que puede ser int o float64. El operador de tubería | enumera los tipos permitidos.

Puede llamar a funciones genéricas con diferentes tipos:

Min([]int{3, 1, 2})           // Works with int
Min([]float64{3.5, 1.2})      // Works with float64

El compilador realiza la comprobación de tipos en tiempo de compilación, proporcionando seguridad sin sobrecarga en tiempo de ejecución.

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]"
	}
}