Types and values

Data types#

Faber में एक स्थिर, प्रकार-प्रथम प्रकार-प्रणाली है। हर घोषणा में नाम से पहले प्रकार आता है: textus nomen, न कि nomen: textus। प्रकार-प्रणाली में स्केलर प्रिमिटिव, जेनरिक संग्रह, निर्धारित-आकार वाली संख्याएँ, टेंसर और GPU-संबंधी रजिस्टर प्रकार शामिल हैं।

प्रिमिटिव प्रकार#

निर्धारित-आकार वाले संख्यात्मक प्रकार#

संख्या और भिन्न की डिफ़ॉल्ट चौड़ाइयाँ (i64 और f64) होती हैं और इनके लिए स्पष्ट चौड़ाई वाले रूप भी उपलब्ध हैं:

स्थिर संख्या<i32> narrow ← 7 ∷ संख्या<i32>

स्थिर संख्या<u64> wide ← 255 ∷ संख्या<u64>

स्थिर f32 single ← 1.5 ∷ f32

प्रकार की स्थिति में चौड़ाई-संक्षेप उपलब्ध है: i8 … u64, f16, f32, f64, numerus<W> / fractus<W> के समतुल्य हैं।

Nullable प्रकार#

Nullable मान यूनियन सिंटैक्स T ∪ nihil का उपयोग करते हैं:

फलन find(पाठ key) → संख्या ∪ शून्य {
    लौटाओ शून्य
}

फलन maybe() → पाठ ∪ शून्य {
    लौटाओ शून्य
}

Faber में T? या Option<T> सिंटैक्स नहीं है। यूनियन स्पष्ट रूप से लिखना आवश्यक है।

प्रकार उपनाम#

प्रकार UserId = संख्या

जेनरिक#

फ़ंक्शन, प्रकार उपनाम, वर्ग और implendum, <T> सिंटैक्स के साथ प्रकार पैरामीटर स्वीकार करते हैं:

फलन identitas<T>(T valor) → T {
    लौटाओ valor
}

फलन primum<T>(सूची<T> res) → T ∪ शून्य {
    लौटाओ res.primus()
}

कॉल-साइट पर स्पष्ट प्रकार आर्ग्युमेंट भी समर्थित हैं:

फलन identitas<T>(T valor) → T {
    लौटाओ valor
}

स्थिर संख्या value ← identitas<संख्या>(7)

संग्रह#

स्थिर सूची<संख्या> nums ← [1, 2, 3]

स्थिर तालिका<पाठ, संख्या> scores ← { "alice": 10, "bob": 20 }

टेंसर प्रकार#

tensor<T, Figura> घना, निश्चित-आकार वाला कंटेनर है:

स्थिर टेंसर<f32, []> scalar ← खाली

स्थिर टेंसर<संख्या, [4]> vector ← [1, 2, 3, 4] ↦ टेंसर<संख्या, [4]>

स्थिर संख्या ∪ शून्य first ← vector[0]

GPU कोर प्रकार#

GPU और रजिस्टर कार्य के लिए सिस्टम लेन इन प्रकारों को पहचानती है। जिन पैकेज लक्ष्यों में हार्डवेयर समर्थन नहीं होता, वे इन्हें अस्वीकार कर देते हैं:

फलन half(f16 x) → f16 {
    लौटाओ x
}

फलन add(आव्यूह<f32, [2, 2]> a, आव्यूह<f32, [2, 2]> b) → आव्यूह<f32, [2, 2]> {
    लौटाओ a.addita(b)
}

फलन swap(परमाणु<संख्या<i32>> cell, संख्या<i32> value) → संख्या<i32> {
    लौटाओ cell.exchange(value)
}

प्रकारों पर borrow मार्कर#

Borrow मार्कर (से, में, सेवन) पैरामीटर स्थितियों में प्रकारों पर दिखाई दे सकते हैं। वे बताते हैं कि कोई मान किस प्रकार पास किया जाता है:

# shared borrow — caller retains ownership
functio imprime(de textus label) → vacuum { }

# mutable borrow — caller lends mutable access
functio duplica(in numerus value) → vacuum { }

# move — caller gives up ownership
functio consume(ex textus buffer) → textus {
    redde buffer
}

तुलना नीति#

Variables and binding#

Faber में तीन variable keywords और assignment के लिए एक विशेष glyph है। मुख्य अंतर स्थिर (केवल एक बार लिखने योग्य) और चर (स्वतंत्र रूप से फिर से assign करने योग्य) के बीच है, तथा ← (runtime flow) और = (संरचनात्मक field shape) के बीच है।

fixum — अपरिवर्तनीय binding#

स्थिर bindings केवल एक बार लिखी जा सकती हैं। इन्हें initializer के साथ या उसके बिना declare किया जा सकता है। यदि initializer के बिना declare किया गया हो, तो पढ़ने से पहले इन्हें ठीक एक बार assign करना आवश्यक है। दूसरी assignment अस्वीकार कर दी जाती है।

स्थिर संख्या count ← 0

स्थिर पाठ name ← "Marcus"

स्थिर सूची<संख्या> inferred ← [1, 2, 3]

Deferred initialisation:

आरंभ {
    स्थिर संख्या factor
    यदि सत्य {
        factor ← 10
    }
    अन्यथा {
        factor ← 100
    }
    दिखाओ factor
}

varia — परिवर्तनशील binding#

चर bindings को स्वतंत्र रूप से फिर से assign किया जा सकता है:

आरंभ {
    चर संख्या count ← 0
    count ← count + 1
    count ← count * 2
}

sit — inferred immutable sugar#

sit, fixum _ का sugar है — inferred type वाली अपरिवर्तनीय binding:

आरंभ {
    स्थिर पाठ salve ← "Salve"
    स्थिर पाठ nomen ← "Marcus"
    स्थिर संख्या x ← 42

    # Deferred form
    स्थिर पाठ label
    label ← "deferred"
}

Runtime binding बनाम structural definition#

Faber उस = को दो अलग भूमिकाओं में बाँटता है, जिसे अधिकांश भाषाएँ एक ही रूप में समेट देती हैं:

वर्ग Point {
    संख्या x
    संख्या y
}

आरंभ {
    # Runtime: ← attaches a value to a name at execution time
    चर संख्या count ← 0
    चर पाठ label ← "ready"
    count ← count + 1

    # Structural: = defines field values inside a type literal
    स्थिर Point p ← Point {x = 10, y = 20}
}

ex से field extraction#

सेवन किसी value से fields निकालकर local bindings में रखता है:

वर्ग Persona {
    पाठ nomen
    संख्या aetas
}

आरंभ {
    स्थिर Persona p ← Persona {nomen = "Marcus", aetas = 30}
    स्थिर पाठ nomen ← p.nomen
    स्थिर संख्या aetas ← p.aetas
    # prints "Marcus"
    दिखाओ nomen
}

Postfix increment और decrement#

⊕ और ⊖, परिवर्तनशील संख्या places के लिए postfix increment/decrement statements हैं। ये केवल statements के रूप में उपयोग किए जा सकते हैं — इनका कोई expression value नहीं होता और इनके prefix रूप नहीं हैं:

आरंभ {
    चर संख्या i ← 0
    # i becomes 1
    i ⊕
    # i becomes 0
    i ⊖
}

Collections#

Faber में कंपाइलर द्वारा स्वामित्व वाले कई कलेक्शन प्रकार हैं। इनके कैनोनिकल तरीके स्टैंडर्ड लाइब्रेरी में नहीं, बल्कि कंपाइलर में परिभाषित होते हैं।

Lista — क्रमबद्ध डायनेमिक कलेक्शन#

स्थिर सूची<संख्या> empty ← खाली

स्थिर सूची<संख्या> numbers ← [1, 2, 3, 4, 5]

स्थिर सूची<पाठ> names ← ["Marcus", "Julia", "Gaius"]

स्थिर सूची<सूची<संख्या>> nested ← [[1, 2], [3, 4]]

sparge के साथ स्प्रेड करें:

स्थिर सूची<संख्या> a ← [1, 2, 3]

स्थिर सूची<संख्या> b ← [4, 5, 6]

स्थिर सूची<संख्या> combined ← [फैलाओ a, फैलाओ b]

स्थिर सूची<संख्या> headed ← [0, फैलाओ a, 99]

मुख्य तरीके: longitudo, accipe, appende, summa, primus, novissimus।

Tabula — कुंजी-मान मैप#

स्थिर तालिका<पाठ, संख्या> scores ← { "alice": 10, "bob": 20 }

Tensor — घना निश्चित-आकार बफ़र#

स्थिर टेंसर<f32, []> scalar ← खाली

स्थिर टेंसर<संख्या, [4]> vector ← [1, 2, 3, 4] ↦ टेंसर<संख्या, [4]>

स्थिर संख्या ∪ शून्य first ← vector[0]

Tensor शुगर (संख्यात्मक कोड के लिए):

स्थिर टेंसर<f32, []> seed ← खाली

स्थिर टेंसर<f32, [4]> lanes ← seed.strue([1.0, 2.0, 3.0, 4.0], [4])

मुख्य तरीके: forma, accipe, ponde, crea, structa, strue, साथ ही तत्व-स्तरीय अंकगणित, मैट्रिक्स गुणन (multiplicatio) और रिडक्शन (summa, productum)।

Sparsa — विरल निश्चित-आकार बफ़र#

स्थिर विरल<f32, [2, 3]> sparse ← खाली

आरंभ {
    sparse.ponde([0, 1], 4.0)
    sparse.ponde([1, 2], 9.0)

    # accipe returns the stored value, here 4.0
    दिखाओ sparse.accipe([0, 1])
    # count of stored entries
    दिखाओ sparse.nonnihil()
}

घने और विरल रूपों के बीच रूपांतरण:

स्थिर टेंसर<f32, [2, 2]> dense ← [[1.0, 0.0], [0.0, 2.0]] ↦ टेंसर<f32, [2, 2]>

स्थिर विरल<f32, [2, 2]> sparse ← dense ↦ विरल<f32, [2, 2]>

स्थिर टेंसर<f32, [2, 2]> roundtrip ← sparse ↦ टेंसर<f32, [2, 2]>

Cursors — लेज़ी स्ट्रीम#

cursor<T> एक लेज़ी स्ट्रीम प्रकार है। इसे कलेक्शन इटरेटर, tuus व्यू या जनरेटर फ़ंक्शन से बनाया जाता है। इसका उपभोग itera ex के माध्यम से किया जाता है:

स्थिर सूची<संख्या> items ← [1, 2, 3]

आरंभ {
    दोहराओ सेवन items स्थिर item {
        दिखाओ item
    }
}

Intervallum — रेंज#

आरंभ {
    # exclusive range: 0, 1, 2, 3, 4
    दोहराओ सीमा 0‥5 स्थिर i {
        दिखाओ i
    }
    # inclusive range: 0, 1, 2, 3, 4, 5
    दोहराओ सीमा 0…5 स्थिर i {
        दिखाओ i
    }
}

‥ एक्सक्लूसिव रेंज एंडपॉइंट है; … इनक्लूसिव है।

String and template literals#

Faber में सीमाचिह्नों के अर्थ निश्चित होते हैं — हर उद्धरण-रूप स्रोत की अलग संरचना दर्शाता है। ये एक-दूसरे के पर्याय नहीं हैं।

शाब्दिक रूप#

स्ट्रिंग-टेम्पलेट अनुप्रयोग#

Faber स्ट्रिंग-टेम्पलेट अनुप्रयोग से पाठ को फ़ॉर्मैट करता है: पहले "…" या «…» लिटरल में § रिक्त-स्थान होते हैं, फिर कोष्ठक में तर्क दिए जाते हैं:

फलन greet(पाठ nomen) → पाठ {
    लौटाओ "Salve, §!"(nomen)
}

स्थिर संख्या pagina ← 3

स्थिर संख्या totum ← 10

स्थिर पाठ code ← "200"

स्थिर पाठ label ← "OK"

स्थिर पाठ msg ← "Page § of §"(pagina, totum)

स्थिर पाठ block ← "status: § (§)"(code, label)

मुख्य नियम:

• § (U+00A7) टेम्पलेट रिक्त-स्थान है
• स्थितीय रिक्त-स्थान: स्पष्ट क्रम के लिए §0, §1, … का उपयोग करें
• अंतिम ! प्रदर्शन फ़ॉर्मैटिंग चुनता है: "Salve, §!"(nomen)
• (args) प्रत्यय टेम्पलेट अनुप्रयोग है, फ़ंक्शन कॉल नहीं

ब्लॉक स्ट्रिंग#

बहुपंक्ति ब्लॉक गिलेमे «…» का उपयोग करते हैं:

स्थिर पाठ sql ← «
    select id, email
    from accounts
»

कैप्चर किए गए टेम्पलेट (forma)#

बैकटिक टेम्पलेट पाठ और पैरामीटर को रेंडर किए बिना कैप्चर करते हैं। बाउंड SQL/URL पेलोड के लिए ये सुरक्षित हैं:

स्थिर संख्या user_id ← 42

स्थिर forma query ← `select * from users where id = §`(user_id)

इनलाइन JSON#

सादा { … } इनलाइन JSON है: यह संकलन-समय का json दस्तावेज़ है, अनाम Faber ऑब्जेक्ट नहीं। कुंजियाँ उद्धृत स्ट्रिंग होती हैं और : से अलग की जाती हैं:

स्थिर json empty ← {}

स्थिर json user ← { "name": "Marcus", "age": 30, "active": true }

स्थिर json nested ← { "meta": { "version": 1 }, "tags": ["alpha", "beta"] }

टाइप किए गए वर्ग निर्माण के लिए, प्रकार का नाम और = फ़ील्ड संरचना का उपयोग करें:

वर्ग Point {
    संख्या x
    संख्या y
}

स्थिर Point p ← Point {x = 10, y = 20}

Nullability and optionality#

Faber किसी मान में अनुपस्थिति और घोषणा स्थल पर वैकल्पिक प्रावधान के बीच भेद करता है।

नलनीय मान — T ∪ nihil#

जब मान अनुपस्थित हो सकता है, तब T ∪ nihil का उपयोग करें:

फलन find(पाठ key) → संख्या ∪ शून्य {
    लौटाओ शून्य
}

फलन divide(संख्या a, संख्या b) → संख्या ∪ शून्य {
    यदि b ≡ 0 अतः लौटाओ शून्य
    लौटाओ a / b
}

वैकल्पिक घोषणा स्लॉट — sponte#

जब कोई पैरामीटर या फ़ील्ड कॉलर या कंस्ट्रक्टर द्वारा छोड़ा जा सकता हो, तब नाम के बाद sponte का उपयोग करें:

फलन connect(पाठ host, संख्या port स्वेच्छा) → रिक्त {
}

वर्ग User {
    पाठ email स्वेच्छा
}

उधार-चिह्न वैकल्पिक पैरामीटरों के साथ संयोजित किए जा सकते हैं:

फलन process(से संख्या depth स्वेच्छा) → रिक्त {
}

नल-रहित अभिकथन — !#

किसी नलनीय मान के शून्य न होने का अभिकथन करने के लिए !., ![, !( का उपयोग करें:

वर्ग Box {
    संख्या ∪ शून्य val
}

स्थिर Box ∪ शून्य maybe_name ← Box {val = 7}

स्थिर संख्या ∪ शून्य name ← maybe_name!.val

शून्य पर नल-रहित अभिकथन रनटाइम पर प्रोग्राम को रोक देता है।

नलिश सहसंयोजन — vel#

स्थिर पाठ ∪ शून्य provided ← शून्य

स्थिर पाठ name ← provided डिफ़ॉल्ट "default"

ignotum#

ignotum एस्केप हैच और अधूरी जानकारी के लिए शीर्ष-स्तरीय अज्ञात प्रकार है। यह नलनीयता की कोई व्यवस्था नहीं है।

Conversion and construction#

रनटाइम और कंपाइल-टाइम के लिए दो महत्वपूर्ण रूपांतरण ऑपरेटर:

# runtime conversion
स्थिर संख्या parsed ← "42" ↦ संख्या
# static ascription
स्थिर संख्या value ← 7

स्थिर पाठ text ← value ∷ पाठ

रनटाइम रूपांतरण — ↦#

रनटाइम रूपांतरण के लिए ↦ का उपयोग करें, विशेष रूप से ऐसी पार्सिंग या कोअर्शन के लिए जो विफल हो सकती है। ⇥ के साथ इनलाइन रिकवरी दें:

स्थिर पाठ input ← "9"

स्थिर संख्या n ← "42" ↦ संख्या

स्थिर संख्या safe ← input ↦ संख्या ⇥ 0

टाइप-निर्देशित मटेरियलाइज़ेशन:

स्थिर पाठ path ← "/etc/hosts"

स्थिर सदिश<f32, 4> lanes ← [1.0, 2.0, 3.0, 4.0] ↦ सदिश<f32, 4>

स्थिर पाठ body ← सेवा 'solum:lege' (path) ↦ पाठ

स्थिर प्रकार-निर्देशन — ∷#

स्पष्ट स्थिर प्रकार-निर्देशन के लिए ∷ का उपयोग करें। यह पोस्टफ़िक्स होता है और लक्ष्य-प्रकार द्वारा निर्देशित होता है:

स्थिर संख्या value ← 7

स्थिर संख्या<i32> x ← 7 ∷ संख्या<i32>

स्थिर पाठ text ← value ∷ पाठ

नलिश कोअलेसिंग — vel#

जब कोई मान शून्य हो, तब नलिश कोअलेसिंग के लिए vel का उपयोग करें:

स्थिर पाठ ∪ शून्य provided_name ← शून्य

स्थिर पाठ name ← provided_name डिफ़ॉल्ट "default"