इस पेज पर Starlark के बारे में खास जानकारी दी गई है, इसे पहले स्काइलार्क के नाम से जाना जाता था, जो बेज़ल में इस्तेमाल की जाने वाली भाषा है. फ़ंक्शन और टाइप की पूरी सूची के लिए, Bazel API का रेफ़रंस देखें.
भाषा के बारे में ज़्यादा जानने के लिए, Starlark का GitHub repo देखें.
Starlark सिंटैक्स और व्यवहार के बारे में आधिकारिक जानकारी के लिए, Starlark भाषा के बारे में स्पेसिफ़िकेशन देखें.
सिंटैक्स
Starlark का सिंटैक्स Python3 से प्रेरित है. Starlark में यह सिंटैक्स मान्य है:
def fizz_buzz(n):
"""Print Fizz Buzz numbers from 1 to n."""
for i in range(1, n + 1):
s = ""
if i % 3 == 0:
s += "Fizz"
if i % 5 == 0:
s += "Buzz"
print(s if s else i)
fizz_buzz(20)
स्टारलार्क के सिमेंटिक्स Python से अलग हैं, लेकिन व्यवहार में कुछ फ़र्क़ है ऐसा बहुत कम होता है. हालांकि, उन मामलों में स्टारलार्क कोई गड़बड़ी करता है. Python के ये टाइप इस्तेमाल किए जा सकते हैं:
म्यूटेबिलिटी
स्टारलार्क में है कि म्यूटेबिलिटी पर कोई असर नहीं पड़ा. दो बदले जा सकने वाले डेटा स्ट्रक्चर उपलब्ध हैं: lists और dicts. म्यूटेबल में बदलाव डेटा स्ट्रक्चर, जैसे कि किसी सूची में वैल्यू जोड़ना या किसी एंट्री को मिटाना शब्दकोश सिर्फ़ मौजूदा कॉन्टेक्स्ट में बनाए गए ऑब्जेक्ट के लिए मान्य हैं. एक संदर्भ खत्म होता है, तो इसके मान अम्यूटेबल हो जाते हैं.
ऐसा इसलिए होता है, क्योंकि Bazel बिल्ड, पैरलल तरीके से प्रोसेस किए जाते हैं. बिल्ड के दौरान, हर .bzl
फ़ाइल और हर BUILD
फ़ाइल को अलग-अलग एक्सीक्यूशन कॉन्टेक्स्ट मिलता है. हर नियम यह भी होता है
अपने संदर्भ में विश्लेषण किया जा सकता है.
आइए, foo.bzl
फ़ाइल के साथ एक उदाहरण देखें:
# `foo.bzl`
var = [] # declare a list
def fct(): # declare a function
var.append(5) # append a value to the list
fct() # execute the fct function
foo.bzl
लोड होने पर, Bazel var
बनाता है. इसलिए, var
foo.bzl
के कॉन्टेक्स्ट का हिस्सा है. fct()
, foo.bzl
के कॉन्टेक्स्ट में चलता है. foo.bzl
के लिए आकलन पूरा होने के बाद, एनवायरमेंट में var
नाम की एक ऐसी एंट्री होती है जिसे बदला नहीं जा सकता. इसकी वैल्यू [5]
होती है.
जब कोई दूसरा bar.bzl
, foo.bzl
से सिंबल लोड करता है, तो लोड की गई वैल्यू में बदलाव नहीं होता. इस वजह से, bar.bzl
में मौजूद यह कोड गैर-कानूनी है:
# `bar.bzl`
load(":foo.bzl", "var", "fct") # loads `var`, and `fct` from `./foo.bzl`
var.append(6) # runtime error, the list stored in var is frozen
fct() # runtime error, fct() attempts to modify a frozen list
bzl
फ़ाइलों में तय किए गए ग्लोबल वैरिएबल, उन bzl
फ़ाइलों के बाहर नहीं बदले जा सकते जिनमें उन्हें तय किया गया है. bzl
फ़ाइलों का इस्तेमाल करने वाले ऊपर दिए गए उदाहरण की तरह,
नियमों के हिसाब से दी गई वैल्यू में बदलाव नहीं किया जा सकता.
BUILD और .bzl फ़ाइलों के बीच अंतर
BUILD
फ़ाइलें, नियमों को कॉल करके टारगेट रजिस्टर करती हैं. .bzl
फ़ाइल में
कॉन्सटेंट, नियमों, मैक्रो, और फ़ंक्शन की परिभाषाएं.
नेटिव फ़ंक्शन और नेटिव नियम, BUILD
फ़ाइलों में ग्लोबल सिंबल होते हैं. bzl
फ़ाइलों को native
मॉड्यूल का इस्तेमाल करके लोड करना होगा.
BUILD
फ़ाइलों में वाक्य रचना से जुड़ी दो पाबंदियां हैं: 1) फ़ंक्शन की घोषणा करना है
गैर-कानूनी है, और 2) *args
और **kwargs
आर्ग्युमेंट की अनुमति नहीं है.
Python से अंतर
ग्लोबल वैरिएबल में बदलाव नहीं किया जा सकता.
शीर्ष-स्तर पर
for
स्टेटमेंट की अनुमति नहीं है. इसके बजाय, उन्हें फ़ंक्शन में इस्तेमाल करें.BUILD
फ़ाइलों में, लिस्ट कॉम्प्रिहेंसन का इस्तेमाल किया जा सकता है.टॉप-लेवल पर
if
स्टेटमेंट इस्तेमाल करने की अनुमति नहीं है. हालांकि,if
एक्सप्रेशन इनका इस्तेमाल किया जा सकता है:first = data[0] if len(data) > 0 else None
.शब्दकोशों की मदद से दोहराने का तय क्रम.
बार-बार होने की अनुमति नहीं है.
Int टाइप, सिर्फ़ 32-बिट के साइन किए गए पूर्णांक तक सीमित है. ओवरफ़्लो से गड़बड़ी मिलेगी.
किसी कलेक्शन में, दोहराए जाने वाले चरणों के दौरान बदलाव करना गड़बड़ी है.
बराबरी की जांच को छोड़कर, कंपैरिज़न ऑपरेटर
<
,<=
,>=
,>
वगैरह का मान, अलग-अलग वैल्यू टाइप के हिसाब से तय नहीं किया जाता. संक्षेप में:5 < 'foo'
गड़बड़ी दिखाएगा और5 == "5"
गलत जवाब देगा.ट्यूपल में, आखिर में कॉमा सिर्फ़ तब मान्य होता है, जब ट्यूपल ब्रैकेट के बीच में हो — जब
1,
के बजाय(1,)
लिखा जाता है.डिक्शनरी लिटरल में डुप्लीकेट की नहीं हो सकतीं. उदाहरण के लिए, यह एक गलती है:
{"a": 4, "b": 7, "a": 1}
.स्ट्रिंग को डबल कोट में दिखाया जाता है (जैसे कि कॉल करते समय) repr).
स्ट्रिंग को दोहराया नहीं जा सकता.
Python की ये सुविधाएं इस्तेमाल नहीं की जा सकतीं:
- इंप्लिसिट स्ट्रिंग जोड़ने की प्रोसेस (साफ़ तौर पर
+
ऑपरेटर का इस्तेमाल करें). - चेन की गई तुलनाएं (जैसे कि
1 < x < 5
). class
(struct
फ़ंक्शन देखें).import
(load
का स्टेटमेंट देखें).while
,yield
.- फ़्लोट और टाइप को सेट करें.
- जनरेटर और जनरेटर एक्सप्रेशन की जानकारी दे सकते हैं.
is
(इसके बजाय==
का इस्तेमाल करें).try
,raise
,except
,finally
(गंभीर गड़बड़ियों के लिएfail
देखें).global
,nonlocal
.- ज़्यादातर बिल्ट-इन फ़ंक्शन, ज़्यादातर तरीके.