Passwortschloss

In Crystal kann eine Variable aus mehreren Typen bestehen. Das nennt man einen Union-Typ. In Crystal ist es üblich, dass der Compiler einen Union-Typ selbst herleitet.

Ein Union-Typ wird deklariert, indem man die Typen mit einem senkrechten Strich (|) trennt. Sie werden oft in runde Klammern gesetzt, nötig ist das aber nicht. Der häufigste Union-Typ ist (T | Nil), wobei T ein Typ ist. Er kommt in Methoden vor, die Nil zurückgeben können. Man sagt dann auch, die Variable ist nilable.

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

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

Er ist nicht auf zwei Typen beschränkt, sondern kann so viele Typen umfassen, wie du willst.

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

typeof vs. Object#class

Es gibt zwei Möglichkeiten, den Typ einer Variable zu ermitteln. Entweder mit typeof oder mit Object#class. Der Unterschied ist, dass typeof den Typ einer Variable zur Kompilierzeit zurückgibt, während Object#class den Typ zur Laufzeit zurückgibt. Wenn du zum Beispiel herausfinden willst, ob eine Variable einen Union-Typ hat, kann Object#class dir das nicht sagen, denn es gibt nur den Typ zur Laufzeit zurück, und der ist ein einzelner Typ.

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

Operationen mit Union-Typen

Da ein Union-Typ zur Laufzeit ein einzelner Typ ist, funktionieren alle Standardoperationen damit. Beim Kompilieren des Codes muss der Compiler aber wissen, um welchen Typ es sich handelt. Deshalb muss der Code so aufgebaut sein, dass er nur einer der Typen sein kann, wenn du typspezifische Operationen verwenden willst.

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

Crystal hat eine spezielle Methode für Union-Typen: die is_a?-Methode. Sie nimmt einen Typ als Argument und gibt einen booleschen Wert zurück. Die nil?-Methode ist eine Kurzform für is_a?(Nil). Wenn du die is_a?-Methode in einen Kontrollausdruck setzt, weiß der Compiler, um welchen Typ es sich handelt, und kann deshalb garantieren, dass es dieser Typ ist. Und für einen else-Zweig ist dann garantiert, dass es nicht dieser Typ ist.

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

Dieses is_a? ist nicht auf einen einzelnen Typ als Argument beschränkt, sondern kann auch einen Union-Typ entgegennehmen. Es lässt sich außerdem mit && kombinieren, um mehrere Typen zu prüfen.

as

Eine Möglichkeit, einen Union-Typ in einen einzelnen Typ umzuwandeln, besteht darin, einen Zweig nur dann zu betreten, wenn es sich um einen bestimmten Typ handelt. Ein anderer Ansatz ist die as-Methode. Sie wandelt einen Union-Typ mithilfe einer Prüfung zur Laufzeit in einen einzelnen Typ um. Ist der Typ nicht der erwartete, wird eine Exception ausgelöst.

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

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

as?

as? funktioniert sehr ähnlich wie as, gibt aber nil zurück, statt eine Exception auszulösen, wenn der Typ nicht der erwartete ist. Das heißt, sie gibt einen Union-Typ aus dem erwarteten Typ und Nil zurück.

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

foo.as?(Int32) # => nil

Kurzschreibweise für nilable

Nilable bedeutet, dass eine Variable entweder ein Typ oder Nil sein kann. Das kannst du als (T | Nil) schreiben. Da nilable Typen aber recht häufig vorkommen, gibt es dafür eine Kurzschreibweise: T?.

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

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