पासवर्ड लॉक

Crystal में एक वेरिएबल कई टाइप का हो सकता है। इसे यूनियन टाइप कहते हैं। Crystal में यूनियन टाइप का अनुमान अक्सर कंपाइलर खुद लगा लेता है।

यूनियन टाइप घोषित करने के लिए टाइपों को पाइप (|) से अलग किया जाता है। इन्हें अक्सर गोल ब्रैकेट में रखा जाता है, लेकिन यह ज़रूरी नहीं है। सबसे आम यूनियन टाइप (T | Nil) है, जिसमें T कोई टाइप है। ऐसा यूनियन टाइप उन मेथड में मिलता है जो Nil लौटा सकते हैं। इसे यह भी कहा जाता है कि वेरिएबल निलेबल है।

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

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

यह सिर्फ दो टाइपों तक सीमित नहीं है, बल्कि जितने चाहें उतने टाइप रख सकते हैं।

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

typeof vs Object#class

किसी वेरिएबल का टाइप पता करने के दो तरीके हैं। या तो typeof से, या Object#class से। अंतर यह है कि typeof कंपाइल टाइम पर वेरिएबल का टाइप देता है, जबकि Object#class रनटाइम पर टाइप देता है। इसका मतलब है कि अगर आप देखना चाहते हैं कि कोई वेरिएबल यूनियन टाइप है या नहीं, तो Object#class आपको यह नहीं बता पाएगा, क्योंकि वह रनटाइम पर ही टाइप देता है, और वहाँ टाइप एक ही होता है।

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

यूनियन टाइप पर ऑपरेशन

चूँकि रनटाइम पर यूनियन टाइप एक ही टाइप होता है, इसलिए उस पर सारे सामान्य ऑपरेशन काम करते हैं। लेकिन कोड कंपाइल करते समय कंपाइलर को यह जानना होता है कि वह कौन-सा टाइप है। इसलिए जब टाइप-विशेष ऑपरेशन इस्तेमाल करने हों, तो कोड ऐसे लिखा जाना चाहिए कि वह उनमें से सिर्फ एक टाइप ही हो सके।

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

Crystal में यूनियन टाइप के लिए एक खास मेथड है: is_a? मेथड, जो आर्गुमेंट के रूप में एक टाइप लेता है और बूलियन लौटाता है। nil? मेथड is_a?(Nil) का छोटा रूप है। is_a? मेथड को किसी कंट्रोल एक्सप्रेशन में रखने से कंपाइलर को पता चल जाता है कि वह कौन-सा टाइप है, और इस तरह यह गारंटी हो जाती है कि वह वही टाइप है। और else ब्रांच में यह गारंटी होती है कि वह उस टाइप का नहीं है।

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

यह is_a? सिर्फ एक टाइप को आर्गुमेंट लेने तक सीमित नहीं है, बल्कि यूनियन टाइप भी ले सकता है। कई टाइपों के लिए इसे && के साथ भी जोड़ा जा सकता है।

as

यूनियन टाइप को एक ही टाइप बनाने का एक तरीका यह है कि ब्रांच में तभी प्रवेश हो जब टाइप कोई खास टाइप हो। दूसरा तरीका as मेथड इस्तेमाल करना है। यह रनटाइम पर जाँच करके यूनियन टाइप को एक ही टाइप बना देता है। अगर टाइप वह नहीं है जिसकी उम्मीद है, तो एक एक्सेप्शन उठाया जाता है।

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

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

as?

as? लगभग as की तरह ही काम करता है, लेकिन अगर टाइप वह नहीं है जिसकी उम्मीद है, तो एक्सेप्शन उठाने के बजाय यह nil लौटाता है। इसका मतलब है कि यह अपेक्षित टाइप और Nil का यूनियन टाइप लौटाता है।

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

foo.as?(Int32) # => nil

निलेबल का छोटा रूप

निलेबल का मतलब है कि वेरिएबल या तो कोई टाइप हो सकता है या Nil। इसे (T | Nil) लिखा जा सकता है। लेकिन चूँकि निलेबल टाइप काफी आम हैं, इसलिए इनके लिए एक छोटा रूप भी है: T?।

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

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