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

पूर्णांक

Gleam में संख्याएँ दो तरह की होती हैं: पूर्णांक और दशमलव संख्याएँ।

पूर्णांक ऐसी संख्याएँ होती हैं जिनमें दशमलव भाग नहीं होता।

let integer = 3
// -> 3

Gleam में कई ऑपरेटर हैं जो पूर्णांकों के साथ काम करते हैं।

1 + 1 // -> 2
5 - 1 // -> 4
5 / 2 // -> 2
3 * 3 // -> 9
5 % 2 // -> 1

2 > 1  // -> True
2 < 1  // -> False
2 >= 1 // -> True
2 <= 1 // -> False

दशमलव संख्याएँ

दशमलव संख्याओं में दशमलव चिह्न के बाद एक या अधिक अंक होते हैं।

let float = 3.45
// -> 3.45

दशमलव संख्याओं के लिए भी अपने अलग ऑपरेटर होते हैं।

1.0 +. 1.4 // -> 2.4
5.0 -. 1.5 // -> 3.5
5.0 /. 2.0 // -> 2.5
3.0 *. 3.1 // -> 9.3

2.0 >. 1.0  // -> True
2.0 <. 1.0  // -> False
2.0 >=. 1.0 // -> True
2.0 <=. 1.0 // -> False

मॉड्यूल

मॉड्यूल

Gleam का कोड मॉड्यूल में बाँटा जाता है, और हर फाइल एक Gleam मॉड्यूल होती है।

अब तक हमने फंक्शन pub fn सिंटैक्स से बनाए हैं। इससे जो फंक्शन बनता है, वह दूसरे मॉड्यूल के लिए भी उपलब्ध रहता है। जिन फंक्शनों को fn से बनाया जाता है, वे उसी मॉड्यूल तक सीमित रहते हैं और दूसरे मॉड्यूल उन्हें इस्तेमाल नहीं कर सकते।

// This function is public
pub fn add(x, y) {
  x + y
}

// This function is private
fn subtract(x, y) {
  x - y
}

Gleam मॉड्यूल के अपने नाम होते हैं। यह नाम src या test डायरेक्टरी में मौजूद उस फाइल के पाथ से तय होता है।

जैसे, src\geometry\rectangle.gleam (Windows पर) या src/geometry/rectangle.gleam (UNIX जैसे ऑपरेटिंग सिस्टम पर) में बनाया गया मॉड्यूल geometry/rectangle कहलाएगा।

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

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

क्वालिफाइड इम्पोर्ट ही डिफ़ॉल्ट होते हैं। ऐसे मॉड्यूल के किसी फंक्शन को इस्तेमाल करने के लिए उसके नाम से पहले मॉड्यूल का नाम लगाना पड़ता है (जैसे gleam/list मॉड्यूल का map फंक्शन लिखने के लिए list.map लिखा जाता है)।

// Import the int module
import gleam/int

pub fn run(x: Int) -> String {
  // Use the to_string function from the int module
  int.to_string(x)
}

डिफ़ॉल्ट रूप से मॉड्यूल को जिस नाम से पुकारा जाता है, वह उसके नाम का अंतिम हिस्सा होता है, यहाँ int। लेकिन as कीवर्ड इस्तेमाल करके इसे बदला जा सकता है।

// Import the int module and refer to it as i
import gleam/int as i

pub fn run(x: Int) -> String {
  i.to_string(x)
}

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

// Import the to_string function from the int module
import gleam/int.{to_string}

pub fn run(x: Int) -> String {
  to_string(x)
}

क्वालिफाइड इम्पोर्ट को प्राथमिकता दी जाती है, क्योंकि इससे पाठक को साफ़ पता चलता है कि फंक्शन कहाँ से आ रहा है और नाम टकराने की समस्या भी नहीं होती।

स्टैंडर्ड लाइब्रेरी

Gleam की स्टैंडर्ड लाइब्रेरी काफी समृद्ध है और उसका डॉक्युमेंटेशन भी बहुत अच्छा है। इसका डॉक्युमेंटेशन hexdocs.pm/gleam_stdlib पर ऑनलाइन उपलब्ध है। इस लिंक को कहीं सहेजकर रख लीजिए, इसकी आपको बहुत बार ज़रूरत पड़ेगी!

अधिकतर डेटा टाइप के लिए एक मॉड्यूल मौजूद है जिसमें उस डेटा टाइप पर काम करने वाले फंक्शन हैं। जैसे पूर्णांकों के लिए gleam/int मॉड्यूल है, स्ट्रिंग के लिए gleam/string, ऐरे के लिए gleam/list, और इसी तरह आगे भी।