72 lines
1.6 KiB
Plaintext
72 lines
1.6 KiB
Plaintext
;;;; match over numbers, chars, strings and dyn values: each arm is (= t lit)
|
|
;;;; over one temporary, and a _ arm is the rest.
|
|
|
|
(defn small [n i16] string
|
|
(match n
|
|
5 "five"
|
|
-3 "minus three"
|
|
_ "other"))
|
|
|
|
(defn half [x f32] i32
|
|
(match x
|
|
0.5 1
|
|
2 2
|
|
_ 0))
|
|
|
|
(defn letter [c u8] i32
|
|
(match c
|
|
\a 1
|
|
98 2
|
|
_ 0))
|
|
|
|
(defn command [s string] i32
|
|
(match s
|
|
"go" 1
|
|
"stop" 2
|
|
"" 3
|
|
_ 0))
|
|
|
|
(defn big [n u64] i32
|
|
(match n
|
|
18446744073709551615 1
|
|
_ 0))
|
|
|
|
;; Over a dyn the test is dyn =, so 1 matches 1.0 and "go" matches only a
|
|
;; string.
|
|
(defn kind [d dyn] string
|
|
(match d
|
|
1 "one"
|
|
2.5 "two and a half"
|
|
"go" "go"
|
|
_ "other"))
|
|
|
|
(defn calls [] i32
|
|
(print "(called) ")
|
|
7)
|
|
|
|
;; recur from inside an arm: the arm is the loop's tail.
|
|
(defn count-down [from i32] i32
|
|
(loop [n from steps 0]
|
|
(match n
|
|
0 steps
|
|
_ (recur (- n 1) (+ steps 1)))))
|
|
|
|
(defn main [] i32
|
|
(println (small 5))
|
|
(println (small -3))
|
|
(println (small 4))
|
|
(print (half 0.5)) (print (half 2.0)) (print (half 3.0)) (println "")
|
|
(print (letter 97)) (print (letter 98)) (print (letter 99)) (println "")
|
|
(print (command "go")) (print (command "stop")) (print (command ""))
|
|
(print (command "gone")) (println "")
|
|
(print (big 18446744073709551615)) (print (big 1)) (println "")
|
|
(println (kind 1))
|
|
(println (kind 1.0))
|
|
(println (kind 2.5))
|
|
(println (kind "go"))
|
|
(println (kind "1"))
|
|
;; The scrutinee is evaluated once, however many arms test it.
|
|
(println (match (calls) 1 "a" 2 "b" 7 "seven" _ "c"))
|
|
(print (count-down 4)) (println "")
|
|
0)
|