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(own textus buffer) → textus {
    redde buffer
}

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

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

Surface	भूमिका
पैरामीटर पर `से पाठ name`	साझा borrow
पैरामीटर पर `में संख्या count`	mutable borrow
पैरामीटर पर `स्वामित्व पाठ buffer`	callee में move करना
`दोहराओ सेवन items स्थिर item`	मानों पर iterate करना
`दोहराओ से तालिका स्थिर key`	keys पर iterate करना
`सेवन source स्थिर x, बाकी rest`	fields को destructure करना
`आयात सेवन "path"`	module से import करना

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

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

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

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

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

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

पासिंग मोड — `स्वेच्छा`#

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

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

Control flow#

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

यदि / अन्यथायदि / अन्यथा#

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

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

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

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

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

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

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

मान — दोहराओ सेवन#

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

कुंजियाँ — दोहराओ से#

आरंभ {
    स्थिर तालिका<पाठ, संख्या> तालिका ← { "unus": 1, "duo": 2 }
    दोहराओ से तालिका स्थिर key {
        दिखाओ key
    }
}

परास — दोहराओ सीमा#

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

While लूप#

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

Guard अनुभाग — रक्षक#

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

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

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

पैटर्न मिलान — चुनो#

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

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

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

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

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

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

Try ब्लॉक — करो / पकड़ो#

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

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

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

Generics#

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

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

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

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

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

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

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

आरंभ {
    स्थिर _ value ← identitas<संख्या>(7)
    स्थिर _ maybe ← primum<संख्या>([value])
}

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

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

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

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

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