Reglas de satisfacción de interfaces

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy. Lección 43 de 107.

Aunque Go utiliza la tipificación pato para la satisfacción implícita de interfaces, existen reglas específicas que determinan si un tipo realmente satisface una interfaz. Comprender estas reglas te ayuda a evitar errores sutiles.

La regla más importante involucra los receptores de puntero. Si un método se define con un receptor de puntero, solo un puntero a ese tipo satisface la interfaz, no el valor en sí:

type Saver interface {
    Save() string
}

type Document struct{ Name string }

func (d *Document) Save() string {  // receptor de puntero
    return "Saved: " + d.Name
}

func Process(s Saver) {
    fmt.Println(s.Save())
}

Como Save() tiene un receptor de puntero, solo *Document satisface Saver:

func main() {
    doc := Document{Name: "report.txt"}
    
    Process(&doc)  // funciona - el puntero satisface la interfaz
    // Process(doc)  // error de compilación - el valor no satisface la interfaz
}

Sin embargo, lo contrario es más flexible. Si un método tiene un receptor de valor, tanto los tipos de valor como los de puntero satisfacen la interfaz. Go desreferencia automáticamente los punteros al llamar a métodos con receptor de valor:

func (d Document) Info() string {  // receptor por valor
    return d.Name
}

// Tanto Document como *Document satisfacen una interfaz que requiere Info()

Esta asimetría existe porque Go siempre puede obtener un valor a partir de un puntero (mediante la desreferenciación), pero no siempre puede obtener un puntero a partir de un valor (es posible que el valor no sea direccionable). Tener presente esta regla evita errores confusos del compilador al trabajar con interfaces.

Desafío

Fácil

Construyamos un sistema de configuración que demuestre cómo los receptores por puntero y por valor afectan la satisfacción de una interfaz. Crearás tipos en los que la elección del receptor determina si se pueden usar valores, punteros o ambos con una interfaz.

Organizarás tu código en tres archivos:

config.go: Define una interfaz Configurable que requiera dos métodos: GetValue() string y SetValue(string). Después, crea dos tipos de configuración:
- ReadOnlyConfig con un campo Value: usa un receptor por valor para GetValue() (devuelve el Value) y un receptor por puntero para SetValue() (actualiza el Value)
- Setting con un campo Data: usa receptores por valor para ambos métodos (GetValue devuelve Data, SetValue simplemente imprime "Cannot modify" sin cambiar nada)
processor.go: Crea una función llamada ProcessConfig que acepte un Configurable y un nuevo valor de tipo string. Debe imprimir el valor actual usando GetValue(), llamar a SetValue() con el nuevo valor y, después, imprimir el valor nuevamente para mostrar cualquier cambio.
main.go: Lee los detalles de configuración de la entrada y demuestra las reglas de satisfacción de interfaces:
1. Crea un ReadOnlyConfig y pasa un puntero a ProcessConfig (es necesario porque SetValue tiene un receptor por puntero)
2. Crea un Setting y pasa el valor directamente a ProcessConfig (funciona porque ambos métodos tienen receptores por valor)

Se proporcionarán las siguientes entradas:

Línea 1: Valor inicial para ReadOnlyConfig
Línea 2: Nuevo valor que se establecerá para ReadOnlyConfig
Línea 3: Valor inicial para Setting
Línea 4: Nuevo valor que se intentará establecer para Setting

Tu función ProcessConfig debe imprimir con este formato:

Current: [value]
Current: [value after SetValue]

Por ejemplo, dados debug, production, localhost y remote, tu salida debería ser:

Current: debug
Current: production
Current: localhost
Cannot modify
Current: localhost

Observa cómo ReadOnlyConfig realmente cambia su valor (porque pasamos un puntero), mientras que Setting permanece sin cambios (su SetValue con un receptor por valor no puede modificar el original). La idea clave es que los valores de ReadOnlyConfig por sí solos no satisfarían Configurable; solo lo hacen los punteros, mientras que los valores de Setting funcionan directamente porque todos sus métodos usan receptores por valor.

Pruébalo tú mismo

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Leer entradas
	scanner.Scan()
	rocInitial := scanner.Text()
	scanner.Scan()
	rocNew := scanner.Text()
	scanner.Scan()
	settingInitial := scanner.Text()
	scanner.Scan()
	settingNew := scanner.Text()
	
	// TODO: Crea un ReadOnlyConfig con el valor rocInitial
	// TODO: Pasa un PUNTERO a ProcessConfig (requerido porque SetValue tiene receptor de puntero)
	
	// TODO: Crea un Setting con el valor settingInitial
	// TODO: Pasa el VALOR directamente a ProcessConfig (funciona porque ambos métodos tienen receptores de valor)
	
	// Usa estas variables para evitar errores de variables no usadas
	_ = rocInitial
	_ = rocNew
	_ = settingInitial
	_ = settingNew
}