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 distintos tipos implicaba 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 funcionan con varios tipos y mantienen la seguridad de tipos completa.

Considera encontrar el valor mínimo en una porción. 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
}

[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 a Min([]float64{3.5, 1.2}) con la misma función. El compilador comprueba los tipos en tiempo de compilación, así 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

¡Construyamos un analizador de puntuaciones que funcione tanto con puntuaciones enteras como de punto flotante usando genéricos! Crearás una única función genérica que puede encontrar el valor máximo en una rebanada, eliminando la necesidad de duplicar código para distintos tipos numéricos.

Organizarás tu código en dos archivos:

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

Crea también una función genérica Sum[T int | float64](values []T) T que calcule y devuelva la suma de todos los valores de una rebanada.
main.go: Lee la entrada y demuestra tus funciones genéricas con distintos tipos.
Lee un indicador de tipo (int o float), luego lee una cantidad seguida de esa cantidad de valores. Analiza los valores según el tipo, llama a Max y a Sum con el tipo adecuado e imprime los resultados.

Para una entrada entera, imprime:
```
Max (int): [value]
Sum (int): [value]
```
Para una entrada de punto flotante, 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: Cantidad de valores (entero)
Líneas siguientes: Un valor por línea

Por ejemplo, dada la siguiente entrada:

Tu salida debería ser:

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

Y dada la siguiente entrada:

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 que el compilador genere código con seguridad de tipos para cada uso, mientras tú escribes la lógica una sola vez.

Pruébalo tú mismo

package main

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

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

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

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

	if typeStr == "int" {
		// Lee 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: Llama a Max y Sum con el slice de enteros
		// TODO: Imprime los resultados con el formato "Max (int): [value]" y "Sum (int): [value]"

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

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