Functions and control flow

Functions#

Faber में फ़ंक्शन फलन का उपयोग करके घोषित किए जाते हैं। पैरामीटर के लिए type-first सिंटैक्स और return type के लिए glyph का उपयोग किया जाता है।

मूल सिंटैक्स#

फलन twice(संख्या n) → संख्या {
    लौटाओ n
}

त्रुटि चैनल के साथ:

फलन parse(पाठ input) → संख्या ⇥ पाठ {
    लौटाओ 0
}

उदाहरण#

# No parameters, no return
फलन saluta() → रिक्त {
    दिखाओ "Salve, Mundus!"
}

# Parameter, no explicit return
फलन dic(पाठ verbum) → रिक्त {
    दिखाओ verbum
}

# Parameter and return type
फलन duplica(संख्या n) → संख्या {
    लौटाओ n * 2
}

# Multiple parameters
फलन adde(संख्या a, संख्या b) → संख्या {
    लौटाओ a + b
}

Return मान#

सामान्य return के लिए लौटाओ का उपयोग करें:

फलन porta(संख्या x) → संख्या {
    यदि x ≺ 0 अतः लौटाओ 0
    लौटाओ x * 2
}

रिक्त return type के लिए खाली लौटाओ:

फलन tace() → रिक्त {
    लौटाओ
}

Borrowing और mutability (`से`, `में`, `सेवन`)#

Faber पैरामीटर पर छोटे पूर्वसर्गों के माध्यम से बताता है कि कोई मान किस प्रकार पास किया जाता है:

Marker	उद्देश्य	सामान्य Rust lowering
(none)	स्वामित्व वाला मान	`T` by value
`से`	साझा borrow (केवल पढ़ने योग्य)	`&T`
`में`	mutable borrow	`&mut T`
`सेवन`	consume करना (callee में move करना)	`T` by move

# Shared borrow
functio imprime(de textus label) → vacuum {
    nota label
}

# Mutable borrow
functio duplica(in numerus value) → vacuum {
    value ← value * 2
}

# Consume
functio consume(ex textus buffer) → textus {
    redde buffer
}

# Owned
functio salve(textus nomen) → textus {
    redde "Salve, §!"(nomen)
}

यही शब्द (से, सेवन) अन्य constructs में भी दोबारा उपयोग किए जाते हैं — हर सेवन को “consume” न समझें:

Surface	भूमिका
पैरामीटर पर `de textus name`	साझा borrow
पैरामीटर पर `in numerus count`	mutable borrow
पैरामीटर पर `ex textus buffer`	callee में move करना
`itera ex items fixum item`	मानों पर iterate करना
`itera de tabula fixum key`	keys पर iterate करना
`ex source fixum x, ceteri rest`	fields को destructure करना
`importa ex "path"`	module से import करना

प्रवेश बिंदु#

प्रोग्राम का entry point आरंभ होता है:

आरंभ {
    दिखाओ "ingressus"
}

CLI प्रवेश बिंदु#

CLI प्रोग्रामों के लिए incipit argumenta parsed command arguments प्राप्त करता है:

@ cli "echo"
@ descriptio "Prints text"
@ operandus ceteri textus words
incipit argumenta args {
    itera ex args.words fixum word {
        nota word
    }
}

पासिंग मोड — `sponte`#

sponte ऐसे पैरामीटर को चिह्नित करता है जिसे caller छोड़ सकता है:

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

Control flow#

सशर्त शाखाकरण#

si / sin / secus#

आरंभ {
    स्थिर तार्किक condition ← सत्य
    यदि condition {
        # truthy branch
        दिखाओ "matched"
    }
}

else-if और else के साथ:

आरंभ {
    स्थिर संख्या score ← 85
    यदि score ≥ 90 {
        दिखाओ "A"
    }
    अन्यथायदि score ≥ 80 {
        दिखाओ "B"
    }
    अन्यथा {
        दिखाओ "C"
    }
}

ergo के साथ संक्षिप्त शाखा#

एकल-कथन वाली शाखा का बॉडी ergo का उपयोग करता है:

फलन classify(संख्या b, तार्किक ready, संख्या value) → संख्या ∪ शून्य {
    यदि b ≡ 0 अतः लौटाओ शून्य
    यदि ready अतः लौटाओ value
    लौटाओ शून्य
}

पुनरावृत्ति#

मान — itera ex#

फलन inveni(सूची<संख्या> items, संख्या target) → संख्या ∪ शून्य {
    दोहराओ सेवन items स्थिर item {
        यदि item ≡ target अतः लौटाओ item
    }
    लौटाओ शून्य
}

कुंजियाँ — itera de#

आरंभ {
    स्थिर json tabula ← { "unus": 1, "duo": 2 }
    दोहराओ से tabula स्थिर key {
        दिखाओ key
    }
}

परास — itera ab#

आरंभ {
    दोहराओ सीमा 0‥10 स्थिर i {
        दिखाओ i
    }
}

While लूप#

आरंभ {
    स्थिर तार्किक condition ← सत्य
    जबतक condition {
        # body
        मौन
    }
}

Guard अनुभाग — custodi#

custodi किसी फ़ंक्शन के मुख्य बॉडी से पहले शीघ्र-बाहर निकलने वाली जाँचों को समूहित करता है। प्रत्येक यदि क्लॉज़ एक क्रमिक guard है:

फलन divide(संख्या a, संख्या b) → संख्या {
    रक्षक {
        यदि b ≡ 0 {
            लौटाओ 0
        }
    }
    लौटाओ a / b
}

v1 में custodi से बाहर निकलना संभव नहीं है — यह लूप नहीं, बल्कि एक guard rail है।

पैटर्न मिलान — elige#

चुनो पहली मेल खाने वाली शाखा चुनता है:

फलन describe(संख्या value) → पाठ {
    मिलाओ value {
        स्थिति 1 {
            लौटाओ "one"
        }
        स्थिति 2 {
            लौटाओ "two"
        }
        स्थिति _ {
            लौटाओ "many"
        }
    }
}

टैग किए गए यूनियन का मिलान — discerne#

मिलाओ discretio के सभी वैरिएंट का पूर्ण मिलान करता है:

विभेद Exitus {
    Bonum {
        पाठ nuntius
    },
    Malum {
        पाठ causa
    },
}

फलन refer(Exitus eventus) → पाठ {
    मिलाओ eventus {
        स्थिति Bonum स्थिर nuntius {
            लौटाओ nuntius
        }
        स्थिति Malum स्थिर causa {
            लौटाओ "Error: §"(causa)
        }
    }
}

Try ब्लॉक — fac / cape#

करो ऐसा ब्लॉक खोलता है जिसमें त्रुटि उत्पन्न हो सकती है, और पकड़ो उसे संभालता है:

फलन divide(संख्या a, संख्या b) → संख्या {
    लौटाओ a / b
}

फलन tutus(संख्या a, संख्या b) → संख्या {
    करो {
        लौटाओ divide(a, b)
    }
    पकड़ो err {
        चेताओ err
        लौटाओ 0
    }
}

Generics#

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

जेनेरिक फ़ंक्शन#

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

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

कॉल-साइट पर स्पष्ट टाइप आर्ग्युमेंट#

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

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

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

स्थिर संख्या ∪ शून्य maybe ← primum<संख्या>([value])

जेनेरिक `वर्ग`#

वर्ग Par<T> {
    T primus
    T secundus
}

आकार पैरामीटर#

magnitudo जेनेरिक पैरामीटर सूचियों में आकार/इंडेक्स पैरामीटर घोषित करता है:

फलन crea<T, आकार N>() → टेंसर<T, [N]> {
    लौटाओ खाली
}