Functions and control flow

Functions#

ฟังก์ชันใน Faber ประกาศด้วย ฟังก์ชัน โดยใช้ไวยากรณ์พารามิเตอร์ที่ระบุชนิดข้อมูลก่อน และใช้ 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
}

ค่าส่งคืน#

ใช้ คืน สำหรับการส่งคืนตามปกติ:

ฟังก์ชัน porta(จำนวน x) → จำนวน {
    ถ้า x ≺ 0 ดังนั้น คืน 0
    คืน x * 2
}

ใช้ คืน โดยไม่ระบุค่า เมื่อชนิดข้อมูลส่งคืนเป็น เปล่า:

ฟังก์ชัน tace() → เปล่า {
    คืน
}

การยืมและความเปลี่ยนแปลงได้ (de, in, ex)#

Faber ระบุวิธีส่งค่าด้วยคำบุพบทสั้น ๆ บนพารามิเตอร์:

# 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)
}

คำเดียวกัน (จาก, ออก) ยังถูกใช้ซ้ำในโครงสร้างอื่นด้วย อย่าตีความ ออก ทุกแห่งว่าแปลว่า “ใช้จนหมด”:

จุดเริ่มต้นโปรแกรม#

จุดเริ่มต้นของโปรแกรมคือ เริ่ม:

เริ่ม {
    บันทึก "ingressus"
}

จุดเริ่มต้นของ CLI#

สำหรับโปรแกรม CLI, incipit argumenta จะรับอาร์กิวเมนต์คำสั่งที่แยกวิเคราะห์แล้ว:

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

โหมดการส่งค่า — sponte#

sponte ใช้ระบุพารามิเตอร์ที่ผู้เรียกอาจละเว้นได้:

ฟังก์ชัน 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
        เงียบ
    }
}

ส่วนตรวจสอบเงื่อนไข — custodi#

custodi ใช้จัดกลุ่มการตรวจสอบเพื่อออกจากฟังก์ชันก่อนเวลาไว้ก่อนบอดีหลักของฟังก์ชัน แต่ละเคลาส์ ถ้า คือการตรวจสอบตามลำดับ:

ฟังก์ชัน divide(จำนวน a, จำนวน b) → จำนวน {
    คุ้มครอง {
        ถ้า b ≡ 0 {
            คืน 0
        }
    }
    คืน a / b
}

ใน v1 custodi ไม่สามารถใช้สำหรับการหยุดลูปได้ — มันเป็นราวกั้นสำหรับการตรวจสอบ ไม่ใช่ลูป

การจับคู่รูปแบบ — 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]> {
    คืน เซตว่าง
}