Jelszózár

A Crystalben egy változó több típusból is állhat. Ezt uniótípusnak nevezzük. A Crystalben gyakori, hogy az uniótípust a fordító következteti ki.

Az uniótípust úgy deklaráljuk, hogy a típusokat egy függőleges vonallal (|) választjuk el. Gyakran zárójelek közé tesszük őket, de ez nem kötelező. A leggyakoribb uniótípus a (T | Nil), ahol T egy típus; ez olyan metódusokban fordul elő, amelyek Nil-t adhatnak vissza. Ilyenkor azt is mondjuk, hogy a változó nilable.

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

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

Nem korlátozódik két típusra; annyi lehet, amennyit csak szeretnél.

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

typeof vs Object#class

Kétféleképpen tudhatjuk meg egy változó típusát. Vagy a typeof, vagy az Object#class használatával. A különbség az, hogy a typeof fordítási időben adja vissza a változó típusát, az Object#class viszont futásidőben. Ez azt jelenti, hogy ha például meg akarod nézni, hogy egy változó uniótípus-e, az Object#class erre nem tud válaszolni, mert csak a futásidejű típust adja vissza, ami egyetlen típus.

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

Műveletek uniótípusokkal

Mivel az uniótípus futásidőben egyetlen típus, minden szokásos művelet működik rajta. A kód fordítása során viszont a fordítónak tudnia kell, hogy éppen melyik típusról van szó. Ezért a kódot úgy kell felépíteni, hogy amikor típusspecifikus műveleteket szeretnénk használni, csak az egyik típus jöhessen szóba.

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

A Crystalben viszont van egy külön metódus az uniótípusokhoz: az is_a? metódus, amely argumentumként egy típust vár, és Boolean értéket ad vissza. A nil? metódus az is_a?(Nil) rövidítése. Ha az is_a? metódust egy vezérlőkifejezésbe tesszük, az megmondja a fordítónak, hogy melyik típusról van szó, és ezzel garantálja, hogy valóban az a típus. Egy else ágban pedig garantált lesz, hogy nem az a típus.

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

Az is_a? nem csak egyetlen típust kaphat argumentumként, hanem uniótípust is. Több típus esetén az &&-tal is kombinálható.

as

Az egyik módja annak, hogy egy uniótípusból egyetlen típust csináljunk, hogy olyan ágat írunk, amelybe csak akkor lehet belépni, ha a típus egy meghatározott típus. Egy másik megközelítés az as metódus használata. Ez egy futásidejű ellenőrzéssel alakítja az uniótípust egyetlen típussá. Ha a típus nem a várt típus, kivétel keletkezik.

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

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

as?

Az as? nagyon hasonlóan működik, mint az as, de ha a típus nem a várt típus, akkor kivétel dobása helyett nil-t ad vissza. Ez azt jelenti, hogy a várt típus és a Nil uniótípusát adja vissza.

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

foo.as?(Int32) # => nil

A nilable rövidítése

A nilable azt jelenti, hogy egy változó vagy egy adott típus, vagy Nil lehet. Ezt így írhatjuk le: (T | Nil). Mivel azonban a nilable típusok viszonylag gyakoriak, van rájuk egy rövidítés: T?.

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

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