टाइपस्पेक्स में

टाइपस्पेक्स के बारे में

Elixir एक डायनामिक टाइप वाली भाषा है, यानी यह कंपाइल करते समय टाइप की जाँच नहीं करती। फिर भी, टाइप स्पेसिफिकेशन काम के हो सकते हैं, क्योंकि वे:

• डॉक्यूमेंटेशन का काम करते हैं।
• संभावित बग खोजने के लिए Dialyzer जैसे स्टैटिक विश्लेषण टूल इनका उपयोग कर सकते हैं।

फंक्शन बनाने से ठीक पहले @spec मॉड्यूल एट्रिब्यूट का उपयोग करके किसी फंक्शन में टाइप स्पेसिफिकेशन जोड़ा जा सकता है।

@spec longer_than?(String.t(), non_neg_integer()) :: boolean()
def longer_than?(string, length), do: String.length(string) > length

टाइप

टाइपस्पेक में अनुमत एक्सप्रेशन:

• बेसिक टाइप, जैसे:

  • boolean()
  • integer(), non_neg_integer(), pos_integer(), float()
  • list()
  • map()
  • any()

• टाइपों का यूनियन:

  • जैसे integer() | list(integer())

• पैरामीटर वाले टाइप:

  • जैसे list(integer()) - पूर्णांकों का ऐरे
  • जैसे %{age: integer()} - :age की के नीचे पूर्णांक वैल्यू वाला मैप

• रिमोट टाइप (किसी मॉड्यूल में परिभाषित), जैसे:

  • String.t()
  • Enum.t()
  • Range.t()

• लिटरल, जैसे:

  • %{} - खाली मैप
  • [] - खाली ऐरे (लेकिन [any()] गैर-खाली ऐरे है)
  • जैसे :ok - एटम लिटरल

• बिल्ट-इन विशेष टाइप, जैसे:

  • char() - 0..0x10FFFF रेंज का पूर्णांक
  • charlist() - अक्षरों का ऐरे
  • keyword() - दो एलिमेंट वाले टपल का ऐरे, जिसमें पहला एलिमेंट एटम होता है

• कस्टम टाइप

सभी टाइप की पूरी सूची आधिकारिक डॉक्यूमेंटेशन का "Typespecs" सेक्शन में मिल सकती है।

आर्गुमेंट को नाम देना

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

@spec to_hex({hue :: integer, saturation :: integer, lightness :: integer}) :: String.t()

कस्टम टाइप

कस्टम टाइप को तीन मॉड्यूल एट्रिब्यूट में से किसी एक का उपयोग करके परिभाषित किया जा सकता है:

• @type - एक पब्लिक टाइप परिभाषित करता है
• @typep - एक प्राइवेट टाइप परिभाषित करता है
• @opaque - ऐसा पब्लिक टाइप परिभाषित करता है जिसकी संरचना प्राइवेट होती है

@type color :: {hue :: integer, saturation :: integer, lightness :: integer}

@spec to_hex(color()) :: String.t()

String.t() बनाम binary() बनाम string()

String.t() Elixir स्ट्रिंग के लिए सही टाइप है, जो UTF-8 में एनकोड किए गए बाइनरी होते हैं। तकनीकी रूप से, String.t() को binary() के रूप में परिभाषित किया गया है, और विश्लेषण टूल के लिए ये दोनों टाइप एक जैसे हैं, लेकिन Elixir स्ट्रिंग के साथ काम करने वाले फंक्शन का डॉक्यूमेंटेशन करने के लिए String.t() ज़्यादा इरादा साफ़ करने वाला विकल्प है।

दूसरी ओर, string() एक अलग टाइप है। यह Erlang स्ट्रिंग है, जिसे Elixir में चारलिस्ट कहा जाता है। टाइपस्पेक में string() टाइप से बचना चाहिए और इसके बजाय charlist() का उपयोग करना चाहिए।

Dialyzer

Dialyzer एक स्टैटिक विश्लेषण टूल है जो Erlang और Elixir कोड में टाइप एरर जैसी समस्याएँ पकड़ सकता है। Elixir प्रोजेक्ट में Dialyzer इस्तेमाल करने का सबसे आसान तरीका Dialyxir है।