बेट्टी की बाइक दुकान

मूल बातें 2

फंक्शन एक्सपोर्ट करना

फंक्शन एक्सपोर्ट करना पहले कॉन्सेप्ट में बताया जा चुका है। यहाँ हम उसे जल्दी से दोहरा लेंगे।

Elm में हर फाइल एक मॉड्यूल होती है और उसमें बाकी सारे कोड से पहले एक module स्टेटमेंट होना ज़रूरी है।

मॉड्यूल के नाम उसकी फाइल के नाम से मेल खाने चाहिए। यानी मॉड्यूल Calculator को Calculator.elm फाइल में होना चाहिए, और मॉड्यूल Parser.Utils के लिए Parser/Utils.elm फाइल ज़रूरी है।

किसी मॉड्यूल में परिभाषित कोई भी चीज़ उसी मॉड्यूल तक सीमित रहती है और उस तक बाहर से पहुँचा नहीं जा सकता, जब तक कि उसे exposing में सूचीबद्ध न किया गया हो।

-- Calculator.elm
-- Define the Calculator module, and expose the `add` function
module Calculator exposing (add)

six = 3 + 3

add number1 number2 = number1 + number2

-- Calculator.elm
-- Define the Calculator module, and expose everything within: `six` and `add`
module Calculator exposing (..)

six = 3 + 3

add number1 number2 = number1 + number2

https://elm-lang.org/docs/syntax#modules

दूसरे मॉड्यूल से फंक्शन इम्पोर्ट करना

दूसरे मॉड्यूल में परिभाषित फंक्शन तक पहुँचने का काम इम्पोर्ट के ज़रिए होता है। जब आप किसी मॉड्यूल को इम्पोर्ट करते हैं, तो उस मॉड्यूल के अंदर के वे सारे फंक्शन उपलब्ध हो जाते हैं जिन्हें उसने बाहर के लिए उपलब्ध कराया था। लेकिन उन तक पहुँचने का तरीका इस पर निर्भर करता है कि मॉड्यूल को कैसे इम्पोर्ट किया गया है।

क्वालिफाइड इम्पोर्ट डिफ़ॉल्ट होते हैं। ऐसे मॉड्यूल के किसी फंक्शन तक पहुँचने के लिए उससे पहले मॉड्यूल का नाम लगाया जाता है, जैसे List मॉड्यूल के map फंक्शन को List.map लिखकर।

ओपन इम्पोर्ट से उस मॉड्यूल के बाहर के लिए उपलब्ध कराए गए फंक्शन सीधे इस्तेमाल किए जा सकते हैं, बिना मॉड्यूल का नाम पहले लगाए। इसके लिए exposing कीवर्ड का इस्तेमाल होता है, जो एक्सपोर्ट में इस्तेमाल होने वाले कीवर्ड का ही उल्टा रूप है। आप सारे उपलब्ध फंक्शन बाहर के लिए उपलब्ध करा सकते हैं (.. के साथ), या सिर्फ कुछ खास फंक्शन (जैसे map)।

आप दूसरे मॉड्यूल से टाइप और उनके कंस्ट्रक्टर भी इम्पोर्ट कर सकते हैं, लेकिन यह आगे के कॉन्सेप्ट में आएगा।

स्पष्टता बनाए रखने और नामों के टकराव से बचने के लिए क्वालिफाइड इम्पोर्ट को प्राथमिकता दी जाती है।

-- qualified imports
import List                            -- List.map, List.foldl
import List as L                       -- L.map, L.foldl

-- open imports
import List exposing (..)              -- map, foldl, concat, ...
import List exposing ( map, foldl )    -- map, foldl, List.concat

https://elm-lang.org/docs/syntax#modules

टाइप एनोटेशन

टाइप एनोटेशन name : parameter types -> return type के रूप में लिखे जाते हैं, जिसमें पैरामीटर के टाइप भी -> से अलग किए जाते हैं।

add : Int -> Int -> Int
add number1 number2 = number1 + number2

फंक्शन के पैरामीटर तय करने के लिए गोल ब्रैकेट का इस्तेमाल किया जा सकता है (ऐसे पैरामीटर भी इसी तरीके से लिखे जाते हैं, इसलिए ब्रैकेट लगाने पड़ते हैं)।

-- Transform every character in a string
map : (Char -> Char) -> String -> String
map charMapperFunction string =
    -- ...

https://elm-lang.org/docs/syntax#type-annotations

संख्याएँ

Elm में दो तरह की संख्याएँ होती हैं, जिन्हें Int और Float टाइप तय करते हैं। Int धनात्मक और ऋणात्मक पूर्णांकों के समूह को दर्शाता है। Float वास्तविक संख्याओं के समूह को दर्शाता है, जो कंप्यूटर की परिशुद्धता तक सीमित रहता है। संख्याओं पर लिखे गए ऑपरेशन आम तौर पर किसी एक ही टाइप पर काम करते हैं, दोनों को मिलाकर नहीं। इन दोनों के बीच बदलने के लिए फंक्शन मौजूद हैं। जैसे toFloat किसी Int को Float में बदलता है, और round, floor, ceiling या truncate किसी Float को अलग-अलग नियमों से Int में बदलते हैं।

https://package.elm-lang.org/packages/elm/core/latest/Basics#Int

स्ट्रिंग ऑपरेशन

कोड में शब्दों और वाक्यों को लिखने के लिए Elm में अपना String टाइप होता है। स्ट्रिंग लिटरल दोहरे कोटेशन के बीच लिखे जाते हैं, जैसे "Hello World!"। स्ट्रिंग जोड़ने वाला ऑपरेटर ++ और बराबरी जाँचने वाला ऑपरेटर == डिफ़ॉल्ट रूप से उपलब्ध हैं।

hello : String -> String
hello subject = "Hello " ++ subject

hello "World!" --> "Hello World!"

बाकी के अधिकांश स्ट्रिंग फंक्शन String मॉड्यूल में हैं, जिसे इम्पोर्ट करना पड़ता है।

https://package.elm-lang.org/packages/elm/core/latest/String