77 lines
1.8 KiB
Plaintext
77 lines
1.8 KiB
Plaintext
;; x? tests that a value is present, and in if x?, elif x? and while x? a
|
|
;; local x is its payload inside the block (decision 133). e? as g names what
|
|
;; a test found.
|
|
|
|
struct Cell
|
|
count: i32
|
|
|
|
struct Node
|
|
v: i32
|
|
next: i32?
|
|
|
|
fn find(xs: [3 i32], k: i32) -> i32?
|
|
for i in range(3)
|
|
if xs[i] == k
|
|
return Some(i)
|
|
None
|
|
|
|
fn describe(a: i32?, b: i32?) -> i32
|
|
if a?
|
|
a + 100
|
|
elif b? and b > 5
|
|
b + 200
|
|
else
|
|
0
|
|
|
|
fn main()
|
|
let a: i32? = Some(3)
|
|
let n: i32? = None
|
|
println(a?, n?, not n?)
|
|
;; Narrowed in the block and in the rest of the condition.
|
|
if a? and a > 1
|
|
println(a * 2)
|
|
;; Not in the else, and not after the block: there a is still an Option.
|
|
if n?
|
|
println(n + 1)
|
|
else
|
|
println(n ?? -1)
|
|
println(a ?? 0)
|
|
println(describe(Some(1), None), describe(None, Some(9)), describe(None, Some(2)))
|
|
;; A field set through a narrowed name lands in the Option itself.
|
|
let c: Cell? = Some(Cell{.count 1})
|
|
if c?
|
|
c.count += 10
|
|
println(c!.count)
|
|
;; Assigning the payload's type keeps it present.
|
|
let m: i32? = Some(1)
|
|
if m?
|
|
m = m + 41
|
|
println(m!)
|
|
;; as names what a test found, when what is tested is not a plain name.
|
|
if find([4, 5, 6], 6)? as at
|
|
println(at)
|
|
if find([4, 5, 6], 7)? as at
|
|
println(at)
|
|
else
|
|
println("absent")
|
|
;; while as: pop until there is nothing left.
|
|
let nodes = [Node{.v 1 .next Some(1)}, Node{.v 2 .next Some(2)}, Node{.v 3 .next None}]
|
|
let cur: i32? = Some(0)
|
|
let total = 0
|
|
while cur? as i
|
|
total += nodes[i].v
|
|
cur = nodes[i].next
|
|
println(total)
|
|
;; while x? narrows the body.
|
|
let k: i32? = Some(3)
|
|
let steps = 0
|
|
while k?
|
|
steps += k
|
|
k = k - 1
|
|
if k == 0
|
|
break
|
|
println(steps)
|
|
;; A kept test with no else gives an Option.
|
|
let w = if a? then a * 5
|
|
println(w ?? 0)
|