Starlark की भाषा

यह पेज Starlark के बारे में खास जानकारी देता है, जिसे पहले Skylark कहा जाता था, जो बैजल में इस्तेमाल की जाने वाली भाषा है. फ़ंक्शन और प्रकारों की पूरी सूची के लिए, Bazel API संदर्भ देखें.

भाषा के बारे में ज़्यादा जानकारी के लिए, Starlark का GitHub रेपो देखें.

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)

Starlark के सिमैंटिक, Python से अलग हो सकते हैं, लेकिन आम तौर पर इनका इस्तेमाल बहुत कम होता है. हालांकि, Starlark की गड़बड़ी का पता चलता है. नीचे दिए गए Python प्रकार काम करते हैं:

गतिविधि

Starlark तरह की समस्याओं को ठीक करता है. बदलाव करने लायक दो डेटा स्ट्रक्चर उपलब्ध हैं: सूचियां और शब्दकोश. म्यूट किए जा सकने वाले डेटा स्ट्रक्चर में बदलाव, जैसे कि सूची में मान जोड़ना या किसी डिक्शनरी में एंट्री मिटाना, सिर्फ़ मौजूदा ऑब्जेक्ट में बनाए गए ऑब्जेक्ट के लिए मान्य होता है. संदर्भ खत्म होने के बाद, इसके मान बदल नहीं सकते.

ऐसा इसलिए होता है, क्योंकि बैजल पैरलल एक्ज़ीक्यूशन का इस्तेमाल करता है. बिल्ड के दौरान, हर .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 के लोड होने पर बैजल 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 फ़ाइलों का इस्तेमाल करने वाले ऊपर दिए गए उदाहरण की तरह ही, नियम के मुताबिक दिए गए मान में कोई बदलाव नहीं हो सकता.

CREATED और .bzl फ़ाइलों में अंतर

BUILD फ़ाइलें, नियमों को कॉल करके टारगेट रजिस्टर करती हैं. .bzl फ़ाइलें, कॉन्सटेंट, नियम, मैक्रो, और फ़ंक्शन के लिए परिभाषाएं देती हैं.

नेटिव फ़ंक्शन और नेटिव नियम BUILD फ़ाइलों में ग्लोबल सिंबल हैं. native मॉड्यूल का इस्तेमाल करके, bzl फ़ाइलों को लोड करना होगा.

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.
  • कई तरीकों से काम करता है, ज़्यादातर तरीके.