Se propuso incluir genéricos en el lenguaje de programación Go hace unos años, y finalmente se aceptó la propuesta formal en el 2021. La versión de G0 1.18 en marzo de 2022 fue el que incluyó, por primera vez, soporte para genéricos.

Pero, ¿cómo se verá afectado Go por los genéricos? ¿Cambiará nuestra manera de escribir el código?

Para poder responder a estas preguntas, tenemos que analizar detalladamente cómo funciona la programación genérica. Afortunadamente, el equipo de Go nos ha proporcionado un compilador de web donde podemos experimentar con genéricos.

Pero, ¿qué es lo que realmente cambia con la introducción de genéricos en Go?

Los genéricos permiten que nuestras funciones o estructuras de datos acepten varios tipos, que se definen en su forma genérica.

Para entender bien lo que significa esta frase, veamos un caso muy simple:

Imaginemos que tienes que hacer una función que tome un fragmento y la imprima. Así, podrías escribir este tipo de función:

func Print(s []string) {
	for _, v := range s {
		fmt.Print(v)
	}
}

Sencillo, ¿verdad? Y, ¿qué pasaría si quisiéramos que ese fragmento sea un entero? Para esto, tendrías que crear un nuevo método:

func Print(s []int) {
	for _, v := range s {
		fmt.Print(v)
	}
}

Estas soluciones podrían parecer redundantes, ya que solo estamos cambiando el parámetro. Sin embargo, así es como lo solucionamos ahora mismo en Go sin tener que recurrir a convertirlo en alguna interfaz.

Ahora con los genéricos, nos permitirán declarar nuestras funciones de esta manera:

func Print[T any](s []T) {
	for _, v := range s {
		fmt.Print(v)
	}
}

En la función de arriba, estamos declarando dos cosas:

1. Por un lado, tenemos T, que es el tipo de la palabra clave any (esta palabra clave se define específicamente como parte de un genérico, lo que indica cualquier tipo)
2. Y nuestro parámetro, donde tenemos la variable s cuyo tipo es una fragmento de T.

Ahora podremos hacer una llamada a nuestro método de esta manera:

func main() {
	Print([]string{"Hello, ", "playground\n"})
	Print([]int{1,2,3})
}

Un método para cualquier tipo de variable: genial, ¿verdad?

Esta es solo una de las implementaciones muy básicas que hay para genéricos. Aun así, ya tiene buena pinta.

Exploremos un poco más y veamos hasta dónde nos pueden llevar los genéricos.

Limitaciones de los genéricos

Hemos visto lo que se puede hacer con los genéricos. Nos permiten especificar una función que puede aceptar cualquier tipo de parámetro.

Pero el ejemplo de antes era muy simple. Existen limitaciones al uso de los genéricos. Imprimir, por ejemplo, es bastante sencillo, ya que Go puede imprimir cualquier tipo de variable que se le agregue.

¿Pero qué pasa si queremos hacer algo más complejo? Vamos a imaginar que hemos definido nuestros propios métodos para una estructura y queremos hacer una llamada:

package main

import (
	"fmt"
)

type worker string

func (w worker) Work(){
	fmt.Printf("%s is working\n", w)
}


func DoWork[T any](things []T) {
    for _, v := range things {
        v.Work()
    }
}

func main() {
	var a,b,c worker
	a = "A"
	b = "B"
	c = "C"
	DoWork([]worker{a,b,c})	
}

Y esto devolvería lo siguiente:

type checking failed for main
prog.go2:25:11: v.Work undefined (type bound for T has no method Work)

No se ejecuta porque la fragmento procesada dentro de la función es de tipo any y no implementa el método Work, lo que hace que no se ejecute.

Podríamos hacer que funcionara usando una interfaz:

package main

import (
	"fmt"
)

type Person interface {
    Work()
}

type worker string

func (w worker) Work(){
	fmt.Printf("%s is working\n", w)
}

func DoWork[T Person](things []T) {
    for _, v := range things {
        v.Work()
    }
}

func main() {
	var a,b,c worker
	a = "A"
	b = "B"
	c = "C"
	DoWork([]worker{a,b,c})
}

Imprimiría lo siguiente:

A is working
B is working
C is working

Funcionaría bien con la interfaz, pero también lo haría con una interfaz sin el genérico:

package main

import (
	"fmt"
)

type Person interface {
    Work()
}

type worker string

func (w worker) Work(){
	fmt.Printf("%s is working\n", w)
}

func DoWorkInterface(things []Person) {
    for _, v := range things {
        v.Work()
    }
}

func main() {
	var d,e,f worker
	d = "D"
	e = "E"
	f = "F"
	DoWorkInterface([]Person{d,e,f})
}

Imprimiría lo siguiente:

D is working
E is working
F is working

El uso de los genéricos solo añade un extra de lógica a nuestro código. Cuando usar solo la interfaz sea suficiente, no habría ningún motivo para añadir genéricos al código.

Los genéricos aún se encuentran en sus primeras fases de desarrollo y todavía tienen límites a la hora de realizar procesamientos complejos.

Jugando con las restricciones

Antes, usamos el tipo any para nuestra restricción genérica. Además de ese tipo, hay algunas otras restricciones que podemos usar.

Una de las restricciones es comparable. Vamos a ver cómo funciona:

func Equal[T comparable](a, b T) bool {
    return a == b
}

func main() {
	Equal("a","a")
}

Aparte de eso, también podemos intentar crear nuestra propia restricción de la siguiente manera:

package main

import(
	"fmt"
)

type Number interface {
    type int, float64
}

func MultiplyTen[T Number](a T) T{
	return a*10
}

func main() {
	fmt.Println(MultiplyTen(10))
	fmt.Println(MultiplyTen(5.55))
}

Y me parece bastante bueno: podemos tener una función para una expresión matemática simple. Por lo general, terminaremos haciendo dos funciones para incorporarlo o usaremos la reflexión, por lo que solo escribiremos una función.

Si bien todo esto es bastante interesante, aún tenemos que experimentar un poco para crear nuestras propias restricciones. Todavía es pronto para conocer todas las limitaciones de los genéricos. Y debemos tener cuidado de no abusar de ellos y usarlos solo si estamos realmente seguros de que sean necesarios.

Otras formas de usar los genéricos

Además de usar los genéricos como parte de una función, también puedes declararlos como variables de la siguiente manera:

type GenericSlice[T any] []T

Y puedes usar esto como un parámetro en una función o puedes crear un método de ese tipo:

func (g GenericSlice[T]) Print() {
	for _, v := range g {
		fmt.Println(v)
	}
}

func Print [T any](g GenericSlice[T]) {
	for _, v := range g {
		fmt.Println(v)
	}
}

func main() {
	g := GenericSlice[int]{1,2,3}
	
	g.Print() //1 2 3
	Print(g) //1 2 3
}

El uso cambiaría según tus necesidades. Diría que todavía tenemos que experimentar más con genéricos para ver qué casos de uso funcionan mejor.

Mi opinión sobre los genéricos

Los genéricos están todavía en sus fases iniciales, pero estoy bastante impresionado con la forma en la que se gestionan. No hace falta saber muchos términos complicados ni muchas librerías para implementar genéricos, y esta simplicidad es lo que hace que sean geniales.

Hay varios casos de uso en los que ya puedo intuir que usar genéricos será mejor, como por ejemplo en el caso con el método de multiplicación. Una cosa que a lo mejor confunde a la gente es que los genéricos podrían ser un sustituto para el uso de interfaces (tanto el tipo de interfaz{} como la implementación de la interfaz).

Mi consejo es no pensar en los genéricos como un sustituto de nada. Los genéricos son simplemente una herramienta más al alcance de los desarrolladores. Por otro lado, aunque los genéricos te parezcan elegantes y geniales, y quieras usarlos en cada bloque de tu código, te aconsejo que no los uses en exceso; úsalos cuando realmente los necesites y no los metas en todos los sitios en donde puedan encajar.

Eso es todo. Gracias por leer mi artículo, y espero sinceramente que los genéricos te puedan resultar útiles.

¡Qué disfrutéis de los genéricos!

Zsh es un intérprete de comandos (o shell) de Unix que está montado por encima de Bash (la shell predeterminado de macOS) y contiene muchas mejoras.

En este tutorial, vamos a configurar iTerm2 con Zsh y sus dependencias. Es una decisión muy acertada y después de hacerlo vas a pensar, "¿por qué no descubrí Zsh antes?" Bueno, ya que estás aquí, vamos a empezar.

Puntos claves

• Instalación de Homebrew
• Instalación de iTerm2
• Instalación de Zsh y Oh My Zsh
• Configurar las dependencias para crear un terminal bonito

Paso 1: instalar Homebrew

Homebrew es un gestor de paquetes de software de código abierto y gratuito que simplifica la instalación de software en dispositivos Apple que usan macOS.

Antes de instalar Homebrew, tenemos que instalar las herramientas de CLI para Xcode. Abre tu terminal y ejecuta el comando:

xcode-select —-install

Si te sale un error, ejecuta xcode-select -r para hacer reset de xcode-select.

Después, instala Homebrew.

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Paso 2: instalar iTerm2

iTerm2 es un reemplazo para el terminal y es el sucesor de iTerm. La mayoría de los desarrolladores de software prefieren iTerm2 al terminal predeterminado de macOS gracias a sus numerosas prestaciones adicionales. Puedes integrar Zsh en iTerm2 para mejorar tu productividad.

Para instalar iTerm2, ejecuta el comando:

brew cask install iterm2

Paso 3: instalar Zsh

Zsh se diseñó para poder usarse de manera interactiva, aunque también es un potente lenguaje de secuencias de comandos.

MacOS viene por defecto con Zsh en el directorio /bin/zsh.

Vamos a instalar Zsh usando brew y hacer que iTerm2 lo use.

brew install zsh

Paso 4: instalar Oh My Zsh

“Oh My Zsh es un framework de código abierto impulsado por la comunidad, para gestionar tu configuración de Zsh. No te convertirá en un desarrollador 10x... pero puede que te sientas como uno después de instalarlo.”

— Robby Russell

Se ejecuta en Zsh para proporcionar unas prestaciones configurables dentro del archivo de configuración ~/.zhrc. Instala Oh My Zsh ejecutando el comando:

sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"

Comprueba la versión instalada:

zsh --version

Puedes actualizarlo también para obtener las últimas prestaciones que ofrece.

upgrade_oh_my_zsh

Reinicia iTerm2 para empezar con la experiencia de Zsh. ¡Bienvenido al mundo de "Oh My Zsh"!

Y eso no es todo. Ahora, vamos a instalar las dependencias para sacar lo mejor de Zsh.

Paso 5: cambiar el tema predeterminado

Por defecto, Oh My Zsh viene con un montón de temas. El predeterminado es el de robbyrussell, pero lo puedes cambiar a cualquier tema que elijas. En este ejemplo, lo he cambiado a agnoster, un tema que viene preinstalado.

Tienes que seleccionar este tema en ~/.zshrc. Para abrir el fichero de configuración (.zshrc), ejecuta:

nano ~/.zshrc

O abre el fichero con un editor de textos usando:

open ~/.zshrc

Configura el tema de Zsh y actualiza los cambios:

source ~/.zhrc

Usar un tema personalizado

Para instalar un tema no preinstalado, clona el repositorio al directorio custom/themes. En este ejemplo vamos a instalar powerlevel9k:

$ git clone https://github.com/bhilburn/powerlevel9k.git ~/.oh-my-zsh/custom/themes/powerlevel9k

Luego, selecciona este tema en tu ~/.zshrc:

ZSH_THEME="powerlevel9k/powerlevel9k"

Actualiza los cambios ejecutando el comando source ~/.zshrc

Navega a iTerm2 > Preferences > Profiles > Colors si quieres cambiar el color del terminal.

El tema que hemos seleccionado en este ejemplo requiere la fuente powerline así que vamos a instalarla.

Paso 6: instalar fuente

Voy a usar Inconsolata. Puedes buscar tu fuente favorita en Powerline fonts y luego instalarla.

O también puedes descargar la fuente entera.

git clone https://github.com/powerline/fonts.git

cd fonts

./install.sh

Para cambiar la fuente, navega a iTerm2 > Preferences > Profiles > Text > Change Font.

Ahora puedes ver que Inconsolata aparece en el listado de fuentes. Selecciona tu fuente preferida. Para fuentes que tienen soporte para ligaduras como FiraCode, chequea la opción "Use ligatures" para ver las flechas o otros operadores de forma elegante, como por ejemplo ( → ).

Paso 7: instalar un esquema de colores

Vamos a cambiar el esquema de colores para tener un terminal más bonito. Navega a iTerm2-Color-Schemes y descárgate el directorio ZIP. Luego, extrae el directorio porque lo que necesitamos está en la carpeta de esquemas (schemes).

Navega a iTerm2 > Preferences > Profile > Colors > Color Presets > Import

• Navega a la carpeta de esquemas y selecciona tus colores favoritos para así importarlos.
• Haz clic en un color específico para activarlo. En este ejemplo he activado "Batman" porque es mi esquema de colores favorito.

¡Ya hemos terminado con los ajustes básicos ? ? !

Paso 8: instalar plugins

Oh My Zsh viene con un plugin de Git preinstalado. Para añadir otros plugins, como por ejemplo Docker, sugerencia automática, resaltado de sintaxis y más:

• Clona el repositorio Git del plugin que quieres. Por ejemplo:

git clone https://github.com/zsh-users/zsh-docker.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-docker

• Navega al directorio .oh-my-zsh > custom > plugins para ver el directorio clonado. Para accederlo ejecuta open ~/.oh-my-zsh
• Añade el plugin a la sección de plugins del archivo de configuración ~/.zshrc, tal como se ve en la captura abajo
• Actualiza tus cambios ejecutando source ~/.zshrc

Step 9: añadir aliases

Los alias son unos atajos que se usan para reducir el tiempo que pasas tecleando comandos. Puedes añadir aliases a comandos que ejecutas igual que en el ejemplo que tienes abajo.

Si conoces otras maneras de mejorar la productividad con Zsh, puedes comentarlas abajo. Encantado de leer tus sugerencias.