Cerradura con contraseña

Crystal permite que una variable conste de varios tipos. Esto se conoce como tipo unión. En Crystal, es común 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 común es (T | Nil), donde T es un tipo, y puede aparecer en métodos que pueden devolver Nil. Esto también se conoce como que una variable sea nilable.

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

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

No se limita a solo 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 maneras de obtener el tipo de una variable. Ya sea usando typeof o usando 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, por ejemplo, si una variable es un tipo unión, Object#class no podrá decirte eso, ya que solo devolverá el tipo en tiempo de ejecución, que es un solo 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 solo 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 estructurado de tal manera que solo pueda ser uno de los tipos cuando quieras usar las operaciones específicas de ese tipo.

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

Crystal sí tiene un método particular para los tipos unión: el método is_a?, que toma un tipo como argumento y devuelve un Boolean. El método nil? es un atajo para 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, por lo tanto, garantizará que sea 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 tener un solo tipo como argumento, sino que también puede tener un tipo unión. También se puede combinar con && para varios tipos.

as

Una forma de convertir un tipo unión en un solo tipo es lograr que solo se pueda entrar a una rama si el tipo es un tipo específico. Otro enfoque es usar el método as. Esto convertirá un tipo unión en un solo tipo haciendo 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 manera 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 del tipo esperado y Nil.

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

foo.as?(Int32) # => nil

Atajo para nilable

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

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

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