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

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

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

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

Starlark सिंटैक्स और इसके काम करने के तरीके की आधिकारिक जानकारी के लिए, Starlark Language की खास बातें देखें.

सिंटैक्स

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 टाइप का इस्तेमाल किया जा सकता है:

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

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

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

  • शब्दकोश में दोहराने का तय क्रम.

  • बार-बार होने की अनुमति नहीं है.

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