Cerradura con contraseña

Crystal permite que una variable esté formada por varios tipos. Esto se conoce como tipo unión. En Crystal, es habitual que el compilador infiera un tipo unión.

Un tipo unión se declara separando los tipos con una barra vertical (|). A menudo se colocan entre paréntesis, pero no es obligatorio. El tipo unión más habitual es (T | Nil), donde T es un tipo, y puede aparecer en métodos que pueden devolver Nil. También se dice que una variable es nilable.

foo : String = "Hello"
foo = nil # Error: type must be String, not (String | Nil)

foo : (String | Nil) = "Hello"
foo = nil

No se limita a dos tipos, sino que puede tener tantos como quieras.

foo : (String | Int32 | Nil | Float64) = "Hello"
foo = 1
foo = nil
foo = 1.0

typeof vs Object#class

Hay dos formas de obtener el tipo de una variable. Ya sea con typeof o con Object#class. La diferencia es que typeof devuelve el tipo de una variable en tiempo de compilación, mientras que Object#class devuelve el tipo en tiempo de ejecución. Esto significa que, si quieres ver si una variable es un tipo unión, por ejemplo, Object#class no podrá decírtelo, ya que solo devuelve el tipo en tiempo de ejecución, que es un único tipo.

foo = 0 == 0 ? "a" : 1
typeof(foo) # => (String | Int32)
foo.class # => String

Operaciones con tipos unión

Como un tipo unión es un único tipo en tiempo de ejecución, todas las operaciones estándar funcionan con él. Pero al compilar el código, el compilador necesitará saber de qué tipo se trata. Por lo tanto, el código debe estar configurado de tal forma que solo pueda ser uno de los tipos cuando se quieran usar operaciones específicas de ese tipo.

foo : (String | Int32) = "Hello"
foo.downcase # Error: undefined method 'downcase' for (String | Int32)

Crystal tiene un método concreto para los tipos unión: el método is_a?, que recibe un tipo como argumento y devuelve un valor booleano. El método nil? es una forma abreviada de is_a?(Nil). Poner el método is_a? en una expresión de control le dirá al compilador de qué tipo se trata y, con ello, garantizará que es ese tipo. Y para una rama else, se garantizará que no es ese tipo.

foo : (String | Int32) = "Hello"
if foo.is_a?(String)
  typeof(foo)  # => String
  foo.downcase # => "hello"
end

Este is_a? no se limita a recibir un único tipo como argumento, sino que también puede recibir un tipo unión. También se puede combinar con && para varios tipos.

as

Una forma de convertir un tipo unión en un único tipo es hacer que solo se pueda entrar en una rama si el tipo es un tipo concreto. Otra forma es usar el método as. Esto convierte un tipo unión en un único tipo mediante una comprobación en tiempo de ejecución. Se lanzará una excepción si el tipo no es el esperado.

foo : String | Int32 = "Hello"
foo.as(String).downcase # => "hello"

foo.as(Int32) # Error: can't cast String to Int32

as?

as? funciona de forma muy similar a as, pero devolverá nil en lugar de lanzar una excepción si el tipo no es el esperado. Esto significa que devolverá un tipo unión formado por el tipo esperado y Nil.

foo : (String | Int32) = "Hello"
foo.as?(String).downcase # => "hello"

foo.as?(Int32) # => nil

Abreviatura de nilable

Nilable significa que una variable puede ser un tipo o Nil. Esto se puede escribir como (T | Nil). Pero como los tipos nilables son relativamente habituales, existe una abreviatura: T?.

# This:
foo : (String | Nil) = "Hello"
foo = nil

# Is the same as:
foo : String? = "Hello"
foo = nil