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() → เปล่า {
    คืน
}

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

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

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

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

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

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

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

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

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

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

โหมดการส่งค่า — สมัครใจ#

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

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

ส่วนตรวจสอบเงื่อนไข — คุ้มครอง#

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

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

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

การจับคู่รูปแบบ — เลือก#

เลือก เลือกแขนงแรกที่ตรงกับรูปแบบ:

ฟังก์ชัน 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]> {
    คืน เซตว่าง
}