95 lines
3.6 KiB
Plaintext
95 lines
3.6 KiB
Plaintext
;;;; Typed values crossing into dyn beside a dyn operand: a u64, a dyn nil past
|
|
;;;; a fold's pair (a bare nil is refused, see test_flan), and an is-numeric $t.
|
|
;;;; With an argument, the program runs the trap that argument names instead.
|
|
|
|
(defn add-dyn [x $t] dyn
|
|
{:where (is-numeric $t)}
|
|
(+ x (the dyn 1)))
|
|
|
|
(defn add-late [x $t d dyn] dyn
|
|
{:where (is-numeric $t)}
|
|
(+ x 1 d))
|
|
|
|
(defn dyn-first [x $t d dyn] dyn
|
|
{:where (is-numeric $t)}
|
|
(* d x 2))
|
|
|
|
(defn less-late [x $t d dyn] bool
|
|
{:where (is-numeric $t)}
|
|
(< x 10 d))
|
|
|
|
(defn biggest [x $t d dyn] dyn
|
|
{:where (is-numeric $t)}
|
|
(max x d 0))
|
|
|
|
(defn low-bits [x $t d dyn] dyn
|
|
{:where (is-integer $t)}
|
|
(bit-and x 7 d))
|
|
|
|
(defn boxed [x $t] dyn
|
|
{:where (is-numeric $t)}
|
|
(the dyn x))
|
|
|
|
(defn main [args [str]] i32
|
|
(let [z (the dyn 0)
|
|
n (the dyn 4)
|
|
small (the u64 9223372036854775807)
|
|
big (the u64 18446744073709551615)
|
|
nothing (the dyn nil)]
|
|
;; A u64 up to the largest i64 crosses as its value.
|
|
(println (+ z small) (max small 0 z) (the dyn small) (= small (+ z small)))
|
|
;; A $t at i32, f64 and u64, beside a dyn in any position.
|
|
(println (add-dyn 2) (add-dyn 2.5) (add-dyn (the u64 7)))
|
|
(println (add-late 2 n) (add-late 2.5 n) (dyn-first 3 n) (dyn-first 1.5 n))
|
|
(println (less-late 1 n) (less-late 1 (the dyn 20)) (less-late 0.5 (the dyn 10.5)))
|
|
(println (biggest 3 n) (biggest -2.5 (the dyn -1)) (low-bits 13 n) (low-bits (the u8 255) n))
|
|
(println (boxed 7) (boxed 0.25) (boxed small))
|
|
;; A nil past the pair is compared, not refused.
|
|
(println (= 1 1 nothing) (!= 1 2 nothing) (= 1 1 (the dyn nil)))
|
|
(when (> (length args) 1)
|
|
(let [a (at args 1)]
|
|
(when (= a "u64") (println (+ z big)))
|
|
(when (= a "u64-max") (println (max big 0 z)))
|
|
(when (= a "u64-generic") (println (boxed big)))
|
|
(when (= a "nil-first") (println (+ (the dyn nil) 1 2)))
|
|
(when (= a "nil-last") (println (+ 1 2 (the dyn nil))))
|
|
(when (= a "nil-less") (println (< 1 2 (the dyn nil))))
|
|
(when (= a "nil-min") (println (min 1 2 nothing)))
|
|
(when (= a "nil-bits") (println (bit-or 1 2 nothing)))
|
|
;; At a typed want too: the dyn nil traps in any position.
|
|
(let [r (the i32 0)]
|
|
(when (= a "nil-want-first") (set r (+ (the dyn nil) 1 2)))
|
|
(when (= a "nil-want-last") (set r (+ 1 2 (the dyn nil))))
|
|
(set r (+ r (at-i32 a))) (the-literal a)
|
|
(println r)))))
|
|
0)
|
|
|
|
;; A dyn beside typed operands at an i32 want: the whole form is dyn, and only
|
|
;; its answer is opened at i32, so every position wraps nowhere and traps alike.
|
|
(defn at-i32 [a str] i32
|
|
(let [big (the dyn 2147483647)
|
|
none (the dyn nil)]
|
|
(cond
|
|
(= a "big-first") (+ big 1 1)
|
|
(= a "big-mid") (+ 1 big 1)
|
|
(= a "big-last") (+ 1 1 big)
|
|
(= a "big-pair") (+ 1 big)
|
|
(= a "big-shift") (<< big 1)
|
|
(= a "i32-nil-first") (+ none 1 1)
|
|
(= a "i32-nil-mid") (+ 1 none 1)
|
|
(= a "i32-nil-last") (+ 1 1 none)
|
|
:else 0)))
|
|
|
|
;; (the dyn <literal>) is a dyn like any other: beside nil it traps at run
|
|
;; time, as a dyn bound to a name does. And opening one at f64 or bool names
|
|
;; its site.
|
|
(defn the-literal [a str] ()
|
|
(let [x (the f64 0.0)
|
|
b false]
|
|
(when (= a "lit-int") (println (+ (the dyn 1) nil)))
|
|
(when (= a "lit-float") (println (+ (the dyn 1.5) nil)))
|
|
(when (= a "lit-bool") (println (+ (the dyn true) nil)))
|
|
(when (= a "lit-let") (let [d (the dyn 1)] (println (+ d nil))))
|
|
(when (= a "want-f64") (set x (the dyn 3)) (println x))
|
|
(when (= a "want-bool") (set b (the dyn 3)) (println b))))
|