O Crystal permite que uma variável seja de vários tipos.
Isto chama-se tipo união.
No Crystal, é comum o compilador inferir um tipo união.
Um tipo união continua a ser um único tipo em tempo de execução, mesmo que seja composto por vários tipos.
Isto significa que, se um tipo união for construído com String e Int32, não será ambos ao mesmo tempo.
Será antes um String ou um Int32.
Um tipo união declara-se separando os tipos com uma barra vertical (|).
Aparecem frequentemente entre parênteses, mas isso não é obrigatório.
O tipo união mais comum é (T | Nil), em que T é um tipo, e pode surgir em métodos que podem devolver Nil.
Isto 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
Não está limitado a dois tipos: pode ter tantos quantos quiseres.
foo : (String | Int32 | Nil | Float64) = "Hello"
foo = 1
foo = nil
foo = 1.0
typeof vs Object#class
Há duas formas de obter o tipo de uma variável.
Ou com typeof, ou com Object#class.
A diferença é que typeof devolve o tipo da variável em tempo de compilação, enquanto Object#class devolve o tipo em tempo de execução.
Isto significa que, se quiseres ver, por exemplo, se uma variável é um tipo união, Object#class não to poderá dizer, porque só devolve o tipo em tempo de execução, que é um único tipo.
foo = 0 == 0 ? "a" : 1
typeof(foo) # => (String | Int32)
foo.class # => String
Operações sobre tipos união
Como um tipo união é um único tipo em tempo de execução, todas as operações normais funcionam com ele.
Mas, ao compilar o código, o compilador precisa de saber de que tipo se trata.
Por isso, o código tem de estar organizado de forma a que só possa ser um dos tipos quando queres usar as operações específicas desse tipo.
foo : (String | Int32) = "Hello"
foo.downcase # Error: undefined method 'downcase' for (String | Int32)
O Crystal tem de facto um método específico para tipos união: o método is_a?, que recebe um tipo como argumento e devolve um Boolean.
O método nil? é um atalho para is_a?(Nil).
Colocar o método is_a? numa expressão de controlo indica ao compilador de que tipo se trata e, assim, garante que é esse o tipo.
E, num ramo else, fica garantido que não é esse o tipo.
foo : (String | Int32) = "Hello"
if foo.is_a?(String)
typeof(foo) # => String
foo.downcase # => "hello"
end
Este is_a? não está limitado a receber um único tipo como argumento: também pode receber um tipo união.
Também pode ser combinado com && para vários tipos.
O método is_a?, quando usado em conjunto com uma expressão de controlo, não pode ser uma variável de instância nem uma variável de classe.
Em vez disso, estas têm de ser atribuídas primeiro a uma variável local.
as
Uma forma de transformar um tipo união num único tipo é fazer com que um ramo só possa ser executado se o tipo for um tipo específico.
Outra abordagem é usar o método as.
Este transforma um tipo união num único tipo através de uma verificação em tempo de execução.
É lançada uma exceção 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
Esta abordagem destina-se apenas a quando tens a certeza de que o tipo é o esperado ou a quando queres lançar uma exceção se não for.
Usar esta abordagem com uma configuração inadequada pode levar a comportamentos inesperados.
as?
as? funciona de forma muito semelhante a as, mas devolve nil em vez de lançar uma exceção se o tipo não for o esperado.
Isto significa que devolve um tipo união do tipo esperado com Nil.
foo : (String | Int32) = "Hello"
foo.as?(String).downcase # => "hello"
foo.as?(Int32) # => nil
Abreviatura de nilable
Nilable significa que uma variável pode ser um tipo ou Nil.
Pode escrever-se como (T | Nil).
Mas, como os tipos nilable são relativamente comuns, existe uma abreviatura: T?.
# This:
foo : (String | Nil) = "Hello"
foo = nil
# Is the same as:
foo : String? = "Hello"
foo = nil
Exercício de aprendizagem
