Verrou à mot de passe

Crystal permet à une variable de contenir plusieurs types à la fois. C'est ce qu'on appelle un type union. En Crystal, il est courant qu'un type union soit inféré par le compilateur.

Un type union se déclare en séparant les types par une barre verticale (|). On les met souvent entre parenthèses, mais ce n'est pas obligatoire. Le type union le plus courant est (T | Nil), où T est un type, ce qui peut apparaître dans des méthodes susceptibles de renvoyer Nil. On dit alors que la variable est nilable.

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

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

Ce n'est pas limité à deux types : on peut en mettre autant qu'on veut.

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

typeof vs Object#class

Il y a deux façons d'obtenir le type d'une variable. Soit en utilisant typeof, soit en utilisant Object#class. La différence est que typeof renvoie le type d'une variable à la compilation, tandis que Object#class renvoie le type à l'exécution. Cela signifie que si tu veux savoir si une variable est un type union, par exemple, Object#class ne pourra pas te le dire, car il ne renvoie le type qu'à l'exécution, où il s'agit d'un seul type.

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

Opérations sur les types union

Comme un type union est un seul type à l'exécution, toutes les opérations standard fonctionnent dessus. Mais au moment de compiler le code, le compilateur doit savoir de quel type il s'agit. Le code doit donc être agencé de telle sorte qu'il ne puisse être que l'un des types lorsqu'on veut utiliser les opérations propres à un type.

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

Crystal possède toutefois une méthode particulière pour les types union : la méthode is_a?, qui prend un type en argument et renvoie un booléen. La méthode nil? est un raccourci pour is_a?(Nil). Placer la méthode is_a? dans une expression de contrôle indique au compilateur de quel type il s'agit, ce qui garantit que c'est bien ce type. Et dans une branche else, cela garantit que ce n'est pas ce type.

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

Cet is_a? n'est pas limité à un seul type en argument : il peut aussi prendre un type union. Il peut également être combiné avec && pour plusieurs types.

as

Une façon de transformer un type union en un seul type consiste à faire en sorte qu'une branche ne puisse être empruntée que si le type est un type précis. Une autre approche consiste à utiliser la méthode as. Celle-ci transforme un type union en un seul type en effectuant une vérification à l'exécution. Une exception est levée si le type n'est pas celui attendu.

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

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

as?

as? fonctionne de manière très similaire à as, mais renvoie nil au lieu de lever une exception si le type n'est pas celui attendu. Cela signifie qu'elle renvoie un type union composé du type attendu et de Nil.

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

foo.as?(Int32) # => nil

Raccourci nilable

Nilable signifie qu'une variable peut être soit d'un certain type, soit Nil. Cela s'écrit (T | Nil). Mais comme les types nilables sont relativement courants, il existe un raccourci : T?.

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

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