Tipos, structs e interfaces

// Un struct es solo datos. Mayúscula inicial = público (exportado),
// minúscula = privado al paquete. Así de simple es la visibilidad en Go.
type Usuario struct {
	ID     int
	Nombre string
	email  string // privado: solo visible dentro de este paquete
}

// "Constructor": una función normal con la convención NewXxx
func NewUsuario(nombre, email string) *Usuario {
	return &Usuario{Nombre: nombre, email: email}
}

// Método = función con RECEPTOR. Esto es lo más parecido a un método de clase.
// Receptor por valor (u Usuario): recibe una copia, no puede mutar.
func (u Usuario) Saludo() string {
	return "Hola, " + u.Nombre
}

// Receptor por puntero (u *Usuario): puede modificar el original.
func (u *Usuario) CambiarEmail(nuevo string) {
	u.email = nuevo
}

type Auditoria struct {
	CreadoEn      time.Time
	ActualizadoEn time.Time
}

func (a *Auditoria) Tocar() { a.ActualizadoEn = time.Now() }

// "Embeber" un struct: sus campos y métodos se PROMOCIONAN al contenedor.
// Parece herencia, pero es composición: no hay polimorfismo de subtipo,
// no hay super(), no hay jerarquías frágiles.
type Producto struct {
	Auditoria        // ← embedding (sin nombre de campo)
	Nombre    string
	Precio    float64
}

func main() {
	p := Producto{Nombre: "Teclado", Precio: 899}
	p.Tocar()                    // método promovido desde Auditoria
	fmt.Println(p.ActualizadoEn) // campo promovido
}

// La interfaz se define donde se USA (el consumidor), no donde se implementa.
type Notificador interface {
	Enviar(destino, msg string) error
}

// Estos dos tipos NO saben que existe Notificador... y aun así lo cumplen.
type EmailSender struct{ smtp string }

func (e EmailSender) Enviar(destino, msg string) error {
	fmt.Println("email a", destino, ":", msg)
	return nil
}

type SMSSender struct{ apiKey string }

func (s SMSSender) Enviar(destino, msg string) error {
	fmt.Println("sms a", destino, ":", msg)
	return nil
}

// Polimorfismo clásico, sin jerarquías:
func avisarATodos(n Notificador, usuarios []string) {
	for _, u := range usuarios {
		n.Enviar(u, "¡Nueva versión disponible!")
	}
}

func main() {
	avisarATodos(EmailSender{smtp: "smtp.gmail.com"}, []string{"ana", "luis"})
	avisarATodos(SMSSender{apiKey: "xyz"}, []string{"ana"})
}

import (
	"errors"
	"fmt"
)

// Error centinela: un valor exportado que otros pueden comparar
var ErrSaldoInsuficiente = errors.New("saldo insuficiente")

// Error con datos propios: un struct que implementa Error() string
type ErrorValidacion struct {
	Campo string
	Regla string
}

func (e *ErrorValidacion) Error() string {
	return fmt.Sprintf("campo %q viola la regla %q", e.Campo, e.Regla)
}

func retirar(cuenta *Cuenta, monto float64) error {
	if monto <= 0 {
		return &ErrorValidacion{Campo: "monto", Regla: "positivo"}
	}
	if cuenta.Saldo < monto {
		// %w ENVUELVE el error: conserva la causa original en la cadena
		return fmt.Errorf("retirando %.2f: %w", monto, ErrSaldoInsuficiente)
	}
	cuenta.Saldo -= monto
	return nil
}

func main() {
	err := retirar(cuenta, 5000)

	// errors.Is: ¿esta cadena de errores contiene el centinela?
	if errors.Is(err, ErrSaldoInsuficiente) {
		fmt.Println("ofrece un préstamo :)")
	}

	// errors.As: ¿hay un *ErrorValidacion en la cadena? extráelo
	var ev *ErrorValidacion
	if errors.As(err, &ev) {
		fmt.Println("corrige el campo:", ev.Campo)
	}
}

func main() {
	x := 10
	p := &x          // p es *int: "la dirección donde vive x"
	*p = 25          // desreferenciar: escribir en esa dirección
	fmt.Println(x)   // 25

	// Sin puntero: la función recibe una COPIA (no pasa nada afuera)
	doblarCopia(x)
	fmt.Println(x)   // 25 (sin cambios)

	// Con puntero: la función modifica el original
	doblarReal(&x)
	fmt.Println(x)   // 50
}

func doblarCopia(n int) { n *= 2 }
func doblarReal(n *int) { *n *= 2 }

// Un slice es una VISTA sobre un array subyacente: {puntero, len, cap}
frutas := []string{"mango", "kiwi"}          // literal
nums := make([]int, 0, 10)                   // len 0, capacidad 10

frutas = append(frutas, "uva")               // append DEVUELVE el slice (¡reasigna!)
fmt.Println(len(frutas), cap(frutas))        // 3 4

// Slicing como Python, pero sin índices negativos
todos := []int{0, 1, 2, 3, 4, 5}
fmt.Println(todos[1:4])                      // [1 2 3]
fmt.Println(todos[:2], todos[3:])            // [0 1] [3 4 5]

// Recorrer: índice y valor
for i, f := range frutas {
	fmt.Println(i, f)
}

// Desde Go 1.21 el paquete "slices" trae lo que extrañabas de Streams:
slices.Contains(frutas, "kiwi")              // true
slices.Sort(todos)
idx, encontrado := slices.BinarySearch(todos, 3)

edades := map[string]int{"ana": 28, "luis": 34}
edades["carla"] = 25
delete(edades, "luis")

// El patrón "comma ok": tu containsKey + get en una sola operación
edad, ok := edades["pedro"]
if !ok {
	fmt.Println("pedro no existe (edad vale el zero value: 0)")
}

// Iteración: el ORDEN ES ALEATORIO a propósito (para que nadie dependa de él)
for nombre, edad := range edades {
	fmt.Println(nombre, edad)
}

// ¿HashSet? Un map con valores vacíos, idioma estándar:
vistos := make(map[string]struct{})
vistos["id-42"] = struct{}{}
_, existe := vistos["id-42"]

// T puede ser cualquier cosa; U también. Como <T, U> en Java.
func Map[T, U any](entrada []T, f func(T) U) []U {
	salida := make([]U, 0, len(entrada))
	for _, v := range entrada {
		salida = append(salida, f(v))
	}
	return salida
}

// Constraint: "comparable" permite usar == (para keys de map, búsquedas...)
func Contiene[T comparable](lista []T, buscado T) bool {
	for _, v := range lista {
		if v == buscado {
			return true
		}
	}
	return false
}

// Constraints propios: una interfaz con UNIÓN de tipos. La ~ significa
// "cualquier tipo cuyo tipo base sea este" (incluye tipos derivados).
type Numero interface {
	~int | ~int64 | ~float64
}

func Sumar[T Numero](nums []T) T {
	var total T
	for _, n := range nums {
		total += n
	}
	return total
}

func main() {
	dobles := Map([]int{1, 2, 3}, func(n int) int { return n * 2 })
	fmt.Println(dobles)                        // [2 4 6]
	fmt.Println(Sumar([]float64{1.5, 2.5}))    // 4
}

import "iter"

// Un iterador es una función que recibe un callback "yield".
// Si yield devuelve false, el consumidor hizo break: paramos.
func Pares(hasta int) iter.Seq[int] {
	return func(yield func(int) bool) {
		for i := 0; i <= hasta; i += 2 {
			if !yield(i) {
				return
			}
		}
	}
}

func main() {
	for p := range Pares(1_000_000) {
		if p > 8 {
			break // el iterador se detiene aquí: nunca generó el millón
		}
		fmt.Println(p) // 0 2 4 6 8
	}

	// La stdlib ya los usa: maps.Keys, slices.Values, strings.Lines...
	for clave := range maps.Keys(misDatos) {
		fmt.Println(clave)
	}
}