स्टारलार्क भाषा

समस्या की शिकायत करें सोर्स देखें

यह पेज Starlark के बारे में खास जानकारी है. इसे पहले स्काइलार्क के नाम से जाना जाता था. यह बैजल में इस्तेमाल की जाने वाली भाषा है. फ़ंक्शन और टाइप की पूरी सूची देखने के लिए, 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)

स्टारलार्क के सिमैंटिक, Python से अलग हो सकते हैं. हालांकि, लोगों के व्यवहार में बहुत कम अंतर होता है. हालांकि, कुछ ऐसे मामले नहीं होते जहां स्टारलार्क में गड़बड़ी होती है. इन Python टाइप का इस्तेमाल किया जा सकता है:

म्यूटेबिलिटी

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

ऐसा इसलिए होता है, क्योंकि 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 का आकलन पूरा होने के बाद, एनवायरमेंट में [5] वैल्यू वाली var ऐसी एंट्री होती है जिसे बदला नहीं जा सकता.

जब कोई दूसरा 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.
  • ज़्यादातर बिल्टइन फ़ंक्शन का इस्तेमाल करते हैं.