Functions and control flow

Functions#

Các hàm trong Faber được khai báo bằng hàm, sử dụng cú pháp tham số đặt kiểu trước và kiểu trả về bằng glyph.

Cú pháp cơ bản#

hàm twice(số n) → số {
    trả n
}

Với kênh lỗi:

hàm parse(văn_bản input) → số ⇥ văn_bản {
    trả 0
}

Ví dụ#

# No parameters, no return
hàm saluta() → trống {
    ghi_chú "Salve, Mundus!"
}

# Parameter, no explicit return
hàm dic(văn_bản verbum) → trống {
    ghi_chú verbum
}

# Parameter and return type
hàm duplica(số n) → số {
    trả n * 2
}

# Multiple parameters
hàm adde(số a, số b) → số {
    trả a + b
}

Giá trị trả về#

Sử dụng trả để trả về thông thường:

hàm porta(số x) → số {
    nếu x ≺ 0 do_đó trả 0
    trả x * 2
}

Dùng trả không kèm giá trị cho kiểu trả về trống:

hàm tace() → trống {
    trả
}

Mượn và tính khả biến (ra, in, từ)#

Faber đánh dấu cách truyền một giá trị bằng các giới từ ngắn đặt trên tham số:

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

Các từ tương tự (ra, từ) cũng được dùng lại trong những cấu trúc khác — không được hiểu mọi từ là “tiêu thụ”:

Điểm vào#

Điểm vào của chương trình là bắt_đầu:

bắt_đầu {
    ghi_chú "ingressus"
}

Điểm vào CLI#

Đối với các chương trình CLI, bắt_đầu đối_số nhận các đối số lệnh đã được phân tích:

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

Chế độ truyền — tự_nguyện#

tự_nguyện đánh dấu một tham số có thể được lược bỏ bởi bên gọi:

hàm connect(văn_bản host, số port tự_nguyện) → trống {
    ghi_chú host
}

Control flow#

Rẽ nhánh điều kiện#

nếu / nếukhôngthì / khác#

bắt_đầu {
    hằng _ condition ← đúng
    nếu condition {
        # truthy branch
        ghi_chú "matched"
    }
}

Với else-if và else:

bắt_đầu {
    hằng _ score ← 85
    nếu score ≥ 90 {
        ghi_chú "A"
    }
    nếukhôngthì score ≥ 80 {
        ghi_chú "B"
    }
    khác {
        ghi_chú "C"
    }
}

Nhánh rút gọn với do_đó#

Thân nhánh chỉ gồm một câu lệnh sử dụng do_đó:

hàm classify(số b, logic ready, số value) → số ∪ rỗng_ty {
    nếu b ≡ 0 do_đó trả không_gì
    nếu ready do_đó trả value
    trả không_gì
}

Lặp#

Giá trị — lặp từ#

hàm inveni(danh_sách<số> items, số target) → số ∪ rỗng_ty {
    lặp từ items hằng item {
        nếu item ≡ target do_đó trả item
    }
    trả không_gì
}

Khóa — lặp ra#

bắt_đầu {
    hằng bảng<văn_bản, số> bảng ← { "unus": 1, "duo": 2 }
    lặp ra bảng hằng key {
        ghi_chú key
    }
}

Khoảng — lặp khoảng#

lặp khoảng 0‥10 hằng i {
    ghi_chú i
}

Vòng lặp while#

bắt_đầu {
    hằng _ condition ← đúng
    trong_khi condition {
        # body
        im_lặng
    }
}

Khối bảo vệ — canh_gác#

canh_gác nhóm các kiểm tra thoát sớm trước thân chính của một hàm. Mỗi mệnh đề nếu là một điều kiện bảo vệ được kiểm tra tuần tự:

hàm divide(số a, số b) → số {
    canh_gác {
        nếu b ≡ 0 {
            trả 0
        }
    }
    trả a / b
}

Trong v1, không thể dùng break trong canh_gác — đây là lan can bảo vệ, không phải vòng lặp.

Đối sánh mẫu — chọn#

chọn chọn nhánh khớp đầu tiên:

hàm describe(số value) → văn_bản {
    chọn value {
        trường_hợp 1 {
            trả "one"
        }
        trường_hợp 2 {
            trả "two"
        }
        mặc_định {
            trả "many"
        }
    }
}

Đối sánh union có thẻ — phân_tích#

phân_tích đối sánh đầy đủ các biến thể của hợp_nhất:

hợp_nhất Exitus {
    Bonum {
        văn_bản nuntius
    },
    Malum {
        văn_bản causa
    }
}

hàm refer(Exitus eventus) → văn_bản {
    phân_tích eventus {
        trường_hợp Bonum hằng nuntius {
            trả nuntius
        }
        trường_hợp Malum hằng causa {
            trả "Error: §"(causa)
        }
    }
}

Khối try — làm / bắt#

làm mở một khối có thể phát sinh lỗi, còn bắt khôi phục khi lỗi xảy ra:

hàm divide(số a, số b) → số {
    trả a / b
}

hàm tutus(số a, số b) → số {
    làm {
        trả divide(a, b)
    }
    bắt err {
        cảnh_báo err
        trả 0
    }
}

Generics#

Các hàm, bí danh kiểu, kiểu và giao_ước chấp nhận tham số kiểu theo cú pháp <T>.

Hàm tổng quát#

hàm identitas<T>(T giá_trị) → T {
    trả giá_trị
}

hàm primum<T>(danh_sách<T> res) → T ∪ rỗng_ty {
    trả res.đầu_tiên()
}

Đối số kiểu tường minh tại vị trí gọi#

hàm identitas<T>(T giá_trị) → T {
    trả giá_trị
}

hàm primum<T>(danh_sách<T> res) → T ∪ rỗng_ty {
    trả không_gì
}

bắt_đầu {
    hằng _ value ← identitas<số>(7)
    hằng _ maybe ← primum<số>([value])
}

kiểu tổng quát#

kiểu Par<T> {
    hằng T primus
    hằng T secundus
}

Tham số kích thước#

kích_thước khai báo một tham số kích thước/chỉ mục trong các danh sách tham số tổng quát:

hàm crea<T, kích_thước N>() → ten_xo<T, [N]> {
    trả tập_rỗng
}