程序

程序是指允許副作用的函數 基本用法或定義請參考Function 添加 ! 到函數名來定義它

proc!(x: Int!, y: Int!) =
    for! 0..x, i =>
        for 0..y, j =>
            print! i, j

在處理可變對象時過程是必需的，但是將可變對象作為參數并不一定使它成為過程 這是一個函數接受一個可變對象（不是過程）

peek_str s: Str! = log s

make_proc(x!: (Int => Int)): (Int => Int) = y => x! y
p! = make_proc(x => x)
print! p! 1 # 1

此外，過程和函數通過proc :> func關聯 因此，可以在過程中定義函數 但是，請注意，反過來是不可能的

proc!(x: Int!) = y -> log x, y # OK
func(x: Int) = y => print! x, y # NG

綁定

過程可以操作范圍外的變量。

x = ! 0
proc! () =
 x.inc! ()
proc! ()
assert x == 1

此時，“proc！” 具有以下類型：

proc!: {| x: Int! |} () => ()

`{| x: Int! |} '部分稱為綁定列，表示過程操作的變量及其類型。 綁定列是自動派生的，因此無需顯式編寫。 請注意，常規過程只能操作預先確定的外部變量。 這意味著不能重寫傳遞給參數的變量。 如果要執行此操作，則必須使用過程方法。 過程方法可以重寫“自”。

C! N = Class {arr = [Int; N]!}
C!.
 new() = Self! (0)::__new__ {arr = ![]}
C! (N).
    # push!: {|self: C!( N) ~> C! (N+1)|} (self: RefMut(C!( N)), x: Int) => NoneType
 push! ref! self, x = self.arr.push! (x)
    # pop!: {|self: C!( N) ~> C! (N-1)|} (self: RefMut(C!( N))) => Int
 pop! ref! self = self.arr.pop! ()
c = C!. new()
c.push! (1)
assert c.pop! () ==  1