Composición de interfaces

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

Go te permite construir interfaces más grandes componiendo otras más pequeñas. En lugar de definir una interfaz grande con muchos métodos, incrustas interfaces existentes dentro de una nueva definición de interfaz.

type Reader interface {
    Read() string
}

type Writer interface {
    Write(data string)
}

// ReadWriter combina ambas interfaces
type ReadWriter interface {
    Reader
    Writer
}

La interfaz ReadWriter ahora requiere los métodos Read() y Write(). Cualquier tipo que implemente ambos métodos satisface ReadWriter, así como Reader y Writer individualmente.

type File struct {
    Name string
}

func (f File) Read() string       { return "file content" }
func (f File) Write(data string)  { fmt.Println("Writing:", data) }

func Process(rw ReadWriter) {
    content := rw.Read()
    rw.Write(content)
}

func main() {
    f := File{Name: "data.txt"}
    Process(f)  // File satisface ReadWriter
}

Este enfoque de composición mantiene las interfaces pequeñas y enfocadas. Puedes combinarlas según sea necesario, creando contratos precisos para tus funciones. La biblioteca estándar de Go utiliza este patrón extensamente, como io.ReadWriter, que combina io.Reader e io.Writer.

Desafío

Fácil

Vamos a construir un sistema de reproductor de medios que demuestre la composición de interfaces. Crearás interfaces pequeñas y enfocadas y luego las combinarás en una interfaz compuesta más potente que un solo tipo pueda satisfacer.

Organizarás tu código en dos archivos:

media.go: Define tres interfaces y un struct que las implemente todas:
- Una interfaz Player con un método Play() string
- Una interfaz Recorder con un método Record(content string) string
- Una interfaz MediaDevice que compone tanto Player como Recorder
- Un struct SmartDevice con un campo Name que implementa todos los métodos requeridos
main.go: Crea funciones que demuestren cómo el mismo SmartDevice puede ser utilizado a través de diferentes tipos de interfaz. Escribe tres funciones:
- UsePlayer que acepta un Player y llama a su método Play
- UseRecorder que acepta un Recorder y una cadena de contenido, luego llama a Record
- UseMediaDevice que acepta un MediaDevice y una cadena de contenido, luego llama tanto a Record como a Play
Lee el nombre del dispositivo y el contenido de la entrada, crea un SmartDevice y demuestra su uso a través de los tres tipos de interfaz.

Se proporcionarán las siguientes entradas:

Línea 1: Nombre del dispositivo
Línea 2: Contenido a grabar

Tus métodos deben devolver cadenas en estos formatos:

Play(): [Name] is playing
Record(content): [Name] recorded: [content]

Por ejemplo, dado MyPhone y voice memo, tu salida debería ser:

MyPhone is playing
MyPhone recorded: voice memo
MyPhone recorded: voice memo
MyPhone is playing

Las primeras dos líneas muestran el dispositivo utilizado a través de las interfaces individuales (Player y Recorder). Las últimas dos líneas lo muestran utilizado a través de la interfaz compuesta MediaDevice, que requiere ambas capacidades. Observa cómo tu único SmartDevice satisface las tres interfaces porque tiene ambos métodos requeridos.

Hoja de referencia

Go te permite construir interfaces más grandes componiendo otras más pequeñas al incrustar interfaces existentes dentro de la definición de una nueva interfaz:

type Reader interface {
    Read() string
}

type Writer interface {
    Write(data string)
}

// ReadWriter combina ambas interfaces
type ReadWriter interface {
    Reader
    Writer
}

Cualquier tipo que implemente todos los métodos de las interfaces incrustadas satisface la interfaz compuesta:

type File struct {
    Name string
}

func (f File) Read() string       { return "file content" }
func (f File) Write(data string)  { fmt.Println("Writing:", data) }

func Process(rw ReadWriter) {
    content := rw.Read()
    rw.Write(content)
}

func main() {
    f := File{Name: "data.txt"}
    Process(f)  // File satisface ReadWriter
}

Un tipo que implementa una interfaz compuesta también satisface cada una de las interfaces incrustadas individuales. Este enfoque de composición mantiene las interfaces pequeñas y enfocadas, permitiéndote crear contratos precisos para tus funciones.

Pruébalo tú mismo

package main

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

// TODO: Implementar UsePlayer que acepte un Player y llame a su método Play
// Debería imprimir el resultado de Play()

// TODO: Implementar UseRecorder que acepte un Recorder y una cadena content
// Debería imprimir el resultado de Record(content)

// TODO: Implementar UseMediaDevice que acepte un MediaDevice y una cadena content
// Debería imprimir el resultado de Record(content) y luego Play()

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	scanner.Scan()
	deviceName := scanner.Text()
	
	scanner.Scan()
	content := scanner.Text()
	
	// TODO: Crear un SmartDevice con el nombre dado
	
	// TODO: Usar el dispositivo a través de la interfaz Player
	
	// TODO: Usar el dispositivo a través de la interfaz Recorder
	
	// TODO: Usar el dispositivo a través de la interfaz MediaDevice
	
	_ = deviceName
	_ = content
	fmt.Println("Implement the solution")
}