O Crystal permite que uma variável tenha vários tipos.
Isso é chamado de tipo união.
No Crystal, é comum que o compilador infira um tipo união.
Um tipo união ainda é um único tipo em tempo de execução, mesmo que seja formado por vários tipos.
Isso significa que, se um tipo união for formado por String e Int32, ele não será os dois ao mesmo tempo.
Em vez disso, ele será ou uma String ou um Int32.
Um tipo união é declarado separando os tipos com uma barra vertical (|).
Eles costumam ser colocados entre parênteses, mas isso não é obrigatório.
O tipo união mais comum é (T | Nil), em que T é um tipo, e pode aparecer em métodos que podem retornar Nil.
Isso também é conhecido como uma variável ser nilable.
foo : String = "Hello"
foo = nil # Error: type must be String, not (String | Nil)
foo : (String | Nil) = "Hello"
foo = nil
Ele não se limita a apenas dois tipos; pode ter quantos você quiser.
foo : (String | Int32 | Nil | Float64) = "Hello"
foo = 1
foo = nil
foo = 1.0
typeof vs Object#class
Existem duas formas de obter o tipo de uma variável.
Usando typeof ou usando Object#class.
A diferença é que typeof retorna o tipo da variável em tempo de compilação, enquanto Object#class retorna o tipo em tempo de execução.
Isso significa que, se você quiser ver, por exemplo, se uma variável é um tipo união, o Object#class não vai conseguir te dizer isso, porque ele só retorna o tipo em tempo de execução, que é um único tipo.
foo = 0 == 0 ? "a" : 1
typeof(foo) # => (String | Int32)
foo.class # => String
Como um tipo união é um único tipo em tempo de execução, todas as operações padrão funcionam nele.
Mas, ao compilar o código, o compilador precisa saber qual é o tipo.
Por isso, o código precisa ser estruturado de forma que só possa ser um dos tipos quando você quiser usar as operações específicas de um tipo.
foo : (String | Int32) = "Hello"
foo.downcase # Error: undefined method 'downcase' for (String | Int32)
O Crystal tem um método específico para tipos união: o método is_a?, que recebe um tipo como argumento e retorna um Boolean.
O método nil? é um atalho para is_a?(Nil).
Colocar o método is_a? em uma expressão de controle diz ao compilador qual é o tipo e, com isso, garante que ele é aquele tipo.
E, para um bloco else, fica garantido que ele não é aquele tipo.
foo : (String | Int32) = "Hello"
if foo.is_a?(String)
typeof(foo) # => String
foo.downcase # => "hello"
end
Esse is_a? não se limita a ter um único tipo como argumento; ele também pode receber um tipo união.
Ele também pode ser combinado com && para vários tipos.
O método is_a?, quando usado em conjunto com uma expressão de controle, não pode ser uma variável de instância ou uma variável de classe.
Em vez disso, elas precisam primeiro ser atribuídas a uma variável local.
as
Uma forma de transformar um tipo união em um único tipo é fazer com que um bloco só possa ser executado se o tipo for um tipo específico.
Outra abordagem é usar o método as.
Ele transforma um tipo união em um único tipo fazendo uma verificação em tempo de execução.
Uma exceção será lançada se o tipo não for o esperado.
foo : String | Int32 = "Hello"
foo.as(String).downcase # => "hello"
foo.as(Int32) # Error: can't cast String to Int32
Essa abordagem serve apenas para quando você tem certeza de que o tipo é o esperado, ou para quando você quer lançar uma exceção quando não for.
Usar essa abordagem com uma configuração inadequada pode levar a um comportamento inesperado.
as?
as? funciona de forma muito parecida com as, mas retorna nil em vez de lançar uma exceção se o tipo não for o esperado.
Isso significa que ele retorna um tipo união do tipo esperado e Nil.
foo : (String | Int32) = "Hello"
foo.as?(String).downcase # => "hello"
foo.as?(Int32) # => nil
Nilable significa que uma variável pode ser um tipo ou Nil.
Isso pode ser escrito como (T | Nil).
Mas, como os tipos nilable são relativamente comuns, existe uma forma abreviada para isso: T?.
# This:
foo : (String | Nil) = "Hello"
foo = nil
# Is the same as:
foo : String? = "Hello"
foo = nil
Exercício de aprendizagem
