Un canal en Go es un tipo compuesto que funciona como un conducto de comunicación tipado, definido por la palabra clave chan seguida del tipo de dato que transporta. A diferencia de otros lenguajes que dependen de abstracciones de nivel superior o bloqueos manuales para gestionar el acceso a recursos compartidos, Go integra la dirección de la comunicación directamente en su sistema de tipos, permitiendo que el compilador verifique la integridad del flujo de datos en tiempo de compilación.
Este diseño resuelve el problema de la mutabilidad imprevista y las condiciones de carrera mediante la restricción de capacidades. Al declarar un canal en la firma de una función, no solo estamos definiendo qué datos pasan a través de él, sino qué operaciones (send, receive o ambas) están permitidas en ese ámbito específico. Esto elimina la necesidad de documentar o confiar en que una función “no debería” cerrar un canal que solo consume; el sistema de tipos simplemente lo prohíbe.
Mecánica de tipos y asignabilidad
En Go, existen tres variaciones del tipo canal que el compilador trata como entidades distintas: chan T (bidireccional), chan<- T (solo envío) y <-chan T (solo recepción). Técnicamente, un canal bidireccional se puede asignar a una variable de tipo direccional, pero la operación inversa es imposible. Esta propiedad se conoce como asignabilidad restrictiva: el compilador permite “perder” capacidades (pasar de bidireccional a unidireccional) para aumentar la seguridad, pero nunca “ganarlas”.
package main
import "fmt"
// sendOnly define un tipo chan<- int: solo permite el operador ch <- v
func sendOnly(ch chan<- int, value int) {
ch <- value
// _ = <-ch // Error de compilación: receive from send-only type chan<- int
}
// receiveOnly define un tipo <-chan int: solo permite el operador v := <-ch
func receiveOnly(ch <-chan int) int {
return <-ch
// ch <- 10 // Error de compilación: send to receive-only type <-chan int
}
func main() {
// La creación siempre es bidireccional mediante make
bidirectional := make(chan int, 1)
// La conversión ocurre implícitamente en la llamada a la función
sendOnly(bidirectional, 100)
result := receiveOnly(bidirectional)
fmt.Println(result) // Output: 100
}
El comportamiento más contraintuitivo ocurre al intentar cerrar un canal. La función close(ch) solo es válida para tipos chan T y chan<- T. Intentar cerrar un canal de tipo <-chan int resultará en un error de compilación. Esto refuerza el patrón de diseño donde el emisor es el único responsable de señalizar la finalización del flujo, evitando pánicos por envíos en canales cerrados.
Incompatibilidad de tipos en colecciones de canales
Un aspecto crítico del sistema de tipos de Go es que la asignabilidad de canales individuales no se extiende a las colecciones que los contienen. Aunque un chan int es asignable a un chan<- int, un slice de tipo []chan int no es asignable a un slice de tipo []chan<- int. Esto se debe a que los slices en Go son invariantes.
Si el compilador permitiera esta asignación, se abriría un agujero de seguridad: podrías tener una referencia a la misma memoria que el sistema de tipos cree que es solo de envío en un lugar, pero que otra parte del código trata como bidireccional a través del slice original. Para transformar una colección de canales, es obligatorio realizar una iteración manual y convertir cada elemento individualmente a su tipo direccional correspondiente.
- Módulo: Sistema de Tipos
- Artículo número: #30