diff options
Diffstat (limited to 'stdlib/test')
30 files changed, 300 insertions, 300 deletions
diff --git a/stdlib/test/test/lux.lux b/stdlib/test/test/lux.lux index f507e1e9a..a9f638c73 100644 --- a/stdlib/test/test/lux.lux +++ b/stdlib/test/test/lux.lux @@ -15,7 +15,7 @@ (macro ["s" syntax #+ syntax:]))) (test: "Value identity." - [size (|> R;nat (:: @ map (|>. (%+ +100) (max+ +10)))) + [size (|> R;nat (:: @ map (|>. (n.% +100) (n.max +10)))) x (R;text size) y (R;text size)] ($_ seq @@ -47,8 +47,8 @@ (and (|> value inc even?) (|> value dec even?)))))] - ["Nat" R;nat inc+ dec+ even?+ odd?+ =+ <+ >+] - ["Int" R;int inc dec even? odd? = < >] + ["Nat" R;nat n.inc n.dec n.even? n.odd? n.= n.< n.>] + ["Int" R;int i.inc i.dec i.even? i.odd? i.= i.< i.>] ) (do-template [category rand-gen = < > <= >= min max] @@ -71,10 +71,10 @@ (>= y (max x y))) )))] - ["Int" R;int = < > <= >= min max] - ["Nat" R;nat =+ <+ >+ <=+ >=+ min+ max+] - ["Real" R;real =. <. >. <=. >=. min. max.] - ["Frac" R;frac =.. <.. >.. <=.. >=.. min.. max..] + ["Int" R;int i.= i.< i.> i.<= i.>= i.min i.max] + ["Nat" R;nat n.= n.< n.> n.<= n.>= n.min n.max] + ["Real" R;real r.= r.< r.> r.<= r.>= r.min r.max] + ["Frac" R;frac f.= f.< f.> f.<= f.>= f.min f.max] ) (do-template [category rand-gen = + - * / <%> > <0> <1> <10> %x <cap> <prep>] @@ -120,9 +120,9 @@ (|> x' (/ y) (* y) (= x'))) ))] - ["Nat" R;nat =+ ++ -+ *+ /+ ;%+ >+ +0 +1 +1000000 %n (;%+ +1000) id] - ["Int" R;int = + - * / ;% > 0 1 1000000 %i (;% 1000) id] - ["Real" R;real =. +. -. *. /. ;%. >. 0.0 1.0 1000000.0 %r id math;floor] + ["Nat" R;nat n.= n.+ n.- n.* n./ n.% n.> +0 +1 +1000000 %n (n.% +1000) id] + ["Int" R;int i.= i.+ i.- i.* i./ i.% i.> 0 1 1000000 %i (i.% 1000) id] + ["Real" R;real r.= r.+ r.- r.* r./ r.% r.> 0.0 1.0 1000000.0 %r id math;floor] ) (do-template [category rand-gen -> <- = <cap> %a %z] @@ -132,22 +132,22 @@ (assert "" (|> value -> <- (= value))))] - ["Int->Nat" R;int int-to-nat nat-to-int = (;% 1000000) %i %n] - ["Nat->Int" R;nat nat-to-int int-to-nat =+ (;%+ +1000000) %n %i] - ["Int->Real" R;int int-to-real real-to-int = (;% 1000000) %i %r] - ["Real->Int" R;real real-to-int int-to-real =. math;floor %r %i] - ## [R;real real-to-frac frac-to-real =. (;%. 1.0) %r %f] + ["Int->Nat" R;int int-to-nat nat-to-int i.= (i.% 1000000) %i %n] + ["Nat->Int" R;nat nat-to-int int-to-nat n.= (n.% +1000000) %n %i] + ["Int->Real" R;int int-to-real real-to-int i.= (i.% 1000000) %i %r] + ["Real->Int" R;real real-to-int int-to-real r.= math;floor %r %i] + ## [R;real real-to-frac frac-to-real r.= (r.% 1.0) %r %f] ) (test: "Simple macros and constructs" ($_ seq (assert "Can write easy loops for iterative programming." - (= 1000 - (loop [counter 0 - value 1] - (if (< 3 counter) - (recur (inc counter) (* 10 value)) - value)))) + (i.= 1000 + (loop [counter 0 + value 1] + (if (i.< 3 counter) + (recur (i.inc counter) (i.* 10 value)) + value)))) (assert "Can create lists easily through macros." (and (case (list 1 2 3) diff --git a/stdlib/test/test/lux/cli.lux b/stdlib/test/test/lux/cli.lux index 20a3cb5b6..cecc2306f 100644 --- a/stdlib/test/test/lux/cli.lux +++ b/stdlib/test/test/lux/cli.lux @@ -20,7 +20,7 @@ lux/test) (test: "CLI" - [num-args (:: @ map (%+ +10) R;nat) + [num-args (:: @ map (n.% +10) R;nat) #let [(^open "Nat/") number;Codec<Text,Nat> gen-arg (:: @ map Nat/encode R;nat)] option-name (R;text +5) @@ -29,22 +29,22 @@ (assert "Can read any argument." (|> (&;run &;any args) (case> (#;Left _) - (=+ +0 num-args) + (n.= +0 num-args) (#;Right arg) - (and (not (=+ +0 num-args)) + (and (not (n.= +0 num-args)) (Text/= arg (default (undefined) (list;head args))))))) (assert "Can safely fail parsing an argument." (|> (&;run (&;opt &;any) args) (case> (#;Right (#;Some arg)) - (and (not (=+ +0 num-args)) + (and (not (n.= +0 num-args)) (Text/= arg (default (undefined) (list;head args)))) (#;Right #;None) - (=+ +0 num-args) + (n.= +0 num-args) _ false))) @@ -55,18 +55,18 @@ false (#;Right args') - (=+ num-args (list;size args')))) + (n.= num-args (list;size args')))) (|> (&;run (&;many &;any) args) (case> (#;Left _) - (=+ +0 num-args) + (n.= +0 num-args) (#;Right args') - (=+ num-args (list;size args')))))) + (n.= num-args (list;size args')))))) (assert "Can use custom token parsers." (|> (&;run (&;parse Nat/decode) args) (case> (#;Left _) - (=+ +0 num-args) + (n.= +0 num-args) (#;Right parsed) (Text/= (Nat/encode parsed) @@ -76,7 +76,7 @@ (assert "Can obtain option values." (and (|> (&;run (&;option (list option-name)) (list& option-name args)) (case> (#;Left _) - (=+ +0 num-args) + (n.= +0 num-args) (#;Right value) (Text/= value (default (undefined) @@ -92,7 +92,7 @@ (assert "Can query if there are any more inputs." (and (|> (&;run &;end args) - (case> (#;Right []) (=+ +0 num-args) _ false)) + (case> (#;Right []) (n.= +0 num-args) _ false)) (|> (&;run (&;not &;end) args) - (case> (#;Right []) (not (=+ +0 num-args)) _ false)))) + (case> (#;Right []) (not (n.= +0 num-args)) _ false)))) )) diff --git a/stdlib/test/test/lux/codata/env.lux b/stdlib/test/test/lux/codata/env.lux index 7a374cd4d..0e24ddf75 100644 --- a/stdlib/test/test/lux/codata/env.lux +++ b/stdlib/test/test/lux/codata/env.lux @@ -11,13 +11,13 @@ (test: "lux/codata/env exports" (test-all (match 123 (run 123 ask)) - (match 246 (run 123 (local (* 2) ask))) - (match 134 (run 123 (:: Functor<Env> map inc (+ 10)))) + (match 246 (run 123 (local (i.* 2) ask))) + (match 134 (run 123 (:: Functor<Env> map i.inc (i.+ 10)))) (match 10 (run 123 (:: Applicative<Env> wrap 10))) (match 30 (run 123 (let [(^open) Applicative<Env>] - (apply (wrap (+ 10)) (wrap 20))))) + (apply (wrap (i.+ 10)) (wrap 20))))) (match 30 (run 123 (do Monad<Env> - [f (wrap +) + [f (wrap i.+) x (wrap 10) y (wrap 20)] (wrap (f x y))))))) diff --git a/stdlib/test/test/lux/codata/io.lux b/stdlib/test/test/lux/codata/io.lux index 5d521faff..916609226 100644 --- a/stdlib/test/test/lux/codata/io.lux +++ b/stdlib/test/test/lux/codata/io.lux @@ -10,12 +10,12 @@ (test: "lux/codata/io exports" (test-all (match "YOLO" (run (io "YOLO"))) - (match 11 (run (:: Functor<IO> map inc (io 10)))) + (match 11 (run (:: Functor<IO> map i.inc (io 10)))) (match 10 (run (:: Applicative<IO> wrap 10))) (match 30 (run (let [(^open) Applicative<IO>] - (apply (wrap (+ 10)) (wrap 20))))) + (apply (wrap (i.+ 10)) (wrap 20))))) (match 30 (run (do Monad<IO> - [f (wrap +) + [f (wrap i.+) x (wrap 10) y (wrap 20)] (wrap (f x y))))))) diff --git a/stdlib/test/test/lux/codata/state.lux b/stdlib/test/test/lux/codata/state.lux index 054b59d45..84c90b5b1 100644 --- a/stdlib/test/test/lux/codata/state.lux +++ b/stdlib/test/test/lux/codata/state.lux @@ -16,17 +16,17 @@ [_ (put 321)] get)))) (match 369 (product;right (run 123 (do Monad<State> - [_ (update (* 3))] + [_ (update (i.* 3))] get)))) - (match 124 (product;right (run 123 (use inc)))) - (match 246 (product;right (run 123 (local (* 2) get)))) - (match 124 (product;right (run 123 (:: Functor<State> map inc get)))) + (match 124 (product;right (run 123 (use i.inc)))) + (match 246 (product;right (run 123 (local (i.* 2) get)))) + (match 124 (product;right (run 123 (:: Functor<State> map i.inc get)))) (match 10 (product;right (run 123 (:: Applicative<State> wrap 10)))) (match 30 (product;right (run 123 (let [(^open) Applicative<State>] - (apply (wrap (+ 10)) (wrap 20)))))) + (apply (wrap (i.+ 10)) (wrap 20)))))) (match 30 (product;right (run 123 (: (State Int Int) (do Monad<State> - [f (wrap +) + [f (wrap i.+) x (wrap 10) y (wrap 20)] diff --git a/stdlib/test/test/lux/codata/struct/stream.lux b/stdlib/test/test/lux/codata/struct/stream.lux index 28292a405..1da81aa02 100644 --- a/stdlib/test/test/lux/codata/struct/stream.lux +++ b/stdlib/test/test/lux/codata/struct/stream.lux @@ -14,21 +14,21 @@ (test: "lux/codata/stream exports" (let% [<take+drop+split> (do-template [<take> <drop> <split> <arg>] [(match (^ (list 0 1 2)) - (<take> <arg> (iterate inc 0))) + (<take> <arg> (iterate i.inc 0))) (match (^=> (^stream& w x y z ...) {[w x y z] [3 4 5 6]}) - (<drop> <arg> (iterate inc 0))) + (<drop> <arg> (iterate i.inc 0))) (match (^=> (^ [(list 0 1 2) _stream_]) {_stream_ (^stream& w x y z ...)} {[w x y z] [3 4 5 6]}) - (<split> <arg> (iterate inc 0)))] + (<split> <arg> (iterate i.inc 0)))] [take drop split +3] - [take-while drop-while split-with (< 3)]) + [take-while drop-while split-with (i.< 3)]) ] (test-all (match (^=> (^stream& w x y z ...) {[w x y z] [0 1 2 3]}) - (iterate inc 0)) + (iterate i.inc 0)) (match (^=> (^stream& w x y z ...) {[w x y z] [0 0 0 0]}) (repeat 0)) @@ -36,33 +36,33 @@ {the-stream (^stream& w x y z ...)} {[w x y z] [0 1 0 1]}) (cycle (list 0 1))) - (match 0 (head (iterate inc 0))) + (match 0 (head (iterate i.inc 0))) (match (^=> (^stream& w x y z ...) {[w x y z] [1 2 3 4]}) - (tail (iterate inc 0))) - (match 9 (at +9 (iterate inc 0))) - (match 0 (at +0 (iterate inc 0))) + (tail (iterate i.inc 0))) + (match 9 (at +9 (iterate i.inc 0))) + (match 0 (at +0 (iterate i.inc 0))) <take+drop+split> (match (^=> (^stream& w x y z ...) {[w x y z] ["0" "1" "2" "3"]}) - (unfold (lambda [n] [(inc n) (Int/encode n)]) + (unfold (lambda [n] [(i.inc n) (Int/encode n)]) 0)) (match (^=> (^stream& w x y z ...) {[w x y z] [0 2 4 6]}) - (filter even? (iterate inc 0))) + (filter even? (iterate i.inc 0))) (match (^=> [e_stream o_stream] {e_stream (^stream& w x y z ...)} {o_stream (^stream& a b c d ...)} {[w x y z a b c d] [0 2 4 6 1 3 5 7]}) - (partition even? (iterate inc 0))) + (partition even? (iterate i.inc 0))) (match (^=> (^stream& w x y z ...) {[w x y z] [0 1 4 9]}) - (let [square (lambda [n] (* n n))] - (:: Functor<Stream> map square (iterate inc 0)))) + (let [square (lambda [n] (i.* n n))] + (:: Functor<Stream> map square (iterate i.inc 0)))) (match (^=> (^stream& w x y z ...) {[w x y z] [4 9 16 25]}) - (let [square (lambda [n] (* n n))] + (let [square (lambda [n] (i.* n n))] (be CoMonad<Stream> - [inputs (iterate inc 2)] + [inputs (iterate i.inc 2)] (square (head inputs))))) ))) diff --git a/stdlib/test/test/lux/concurrency/actor.lux b/stdlib/test/test/lux/concurrency/actor.lux index e9a19e8ea..718ce080a 100644 --- a/stdlib/test/test/lux/concurrency/actor.lux +++ b/stdlib/test/test/lux/concurrency/actor.lux @@ -15,7 +15,7 @@ (method: (add! {offset Int}) [Int Int] - (let [*state*' (+ offset *state*)] + (let [*state*' (i.+ offset *state*)] (wrap (#;Right [*state*' [*state* *state*']])))) (stop: @@ -26,7 +26,7 @@ (test: "lux/concurrency/actor exports" (let [counter-proc (: (Proc Int (Promise Int)) [(lambda [self output state] - (let [state' (inc state)] + (let [state' (i.inc state)] (exec (io;run (promise;resolve state' output)) (Promise/wrap (#;Right state'))))) (lambda [?error state] (Promise/wrap []))])] diff --git a/stdlib/test/test/lux/concurrency/frp.lux b/stdlib/test/test/lux/concurrency/frp.lux index 62ca0b57d..b163aaa3f 100644 --- a/stdlib/test/test/lux/concurrency/frp.lux +++ b/stdlib/test/test/lux/concurrency/frp.lux @@ -34,21 +34,21 @@ (match+ (^ (list 0 1 2 3 4 5 0 -1 -2 -3 -4 -5)) (from-promise (consume (merge (list (List->Chan (list 0 1 2 3 4 5)) (List->Chan (list 0 -1 -2 -3 -4 -5))))))) - (match+ 15 (from-promise (fold (lambda [base input] (Promise/wrap (+ input base))) 0 (List->Chan (list 0 1 2 3 4 5))))) + (match+ 15 (from-promise (fold (lambda [base input] (Promise/wrap (i.+ input base))) 0 (List->Chan (list 0 1 2 3 4 5))))) (match+ (^ (list 0 1 2 3 4 5)) (from-promise (consume (no-dups number;Eq<Int> (List->Chan (list 0 0 0 1 2 2 3 3 3 3 4 4 4 5 5)))))) (match+ (^ (list 12345)) (from-promise (consume (as-chan (:: promise;Monad<Promise> wrap 12345))))) (match+ (^ (list 1 2 3 4 5 6)) - (from-promise (consume (:: Functor<Chan> map inc (List->Chan (list 0 1 2 3 4 5)))))) + (from-promise (consume (:: Functor<Chan> map i.inc (List->Chan (list 0 1 2 3 4 5)))))) (match+ (^ (list 12345)) (from-promise (consume (:: Applicative<Chan> wrap 12345)))) (match+ (^ (list 12346)) (from-promise (consume (let [(^open) Applicative<Chan>] - (apply (wrap inc) (wrap 12345)))))) + (apply (wrap i.inc) (wrap 12345)))))) (match+ (^ (list 12346)) (from-promise (consume (do Monad<Chan> - [f (wrap inc) + [f (wrap i.inc) a (wrap 12345)] (wrap (f a)))))) )) diff --git a/stdlib/test/test/lux/concurrency/stm.lux b/stdlib/test/test/lux/concurrency/stm.lux index e29a5294b..da3c10dca 100644 --- a/stdlib/test/test/lux/concurrency/stm.lux +++ b/stdlib/test/test/lux/concurrency/stm.lux @@ -23,7 +23,7 @@ (from-promise (do promise;Monad<Promise> [_ (seqM @ (map (lambda [_] - (mapM @ (lambda [_] (commit (update inc _concurrency-var))) + (mapM @ (lambda [_] (commit (update i.inc _concurrency-var))) (list;range 1 iterations/processes))) (list;range 1 processes/vars)))] (commit (read _concurrency-var)))))) @@ -39,7 +39,7 @@ [value (read _var)] (wrap (#;Right value))))) (match+ 15 (commit (do Monad<STM> - [_ (update (* 3) _var) + [_ (update (i.* 3) _var) value (read _var)] (wrap (#;Right value))))) (match+ 15 (commit (do Monad<STM> diff --git a/stdlib/test/test/lux/data/bit.lux b/stdlib/test/test/lux/data/bit.lux index a6d897519..5aca04332 100644 --- a/stdlib/test/test/lux/data/bit.lux +++ b/stdlib/test/test/lux/data/bit.lux @@ -16,14 +16,14 @@ (test: "Bitwise operations." [pattern R;nat - idx (:: @ map (%+ width) R;nat)] + idx (:: @ map (n.% width) R;nat)] ($_ seq - (assert "" (and (<+ (&;count (&;set idx pattern)) - (&;count (&;clear idx pattern))) - (<=+ (&;count pattern) + (assert "" (and (n.< (&;count (&;set idx pattern)) (&;count (&;clear idx pattern))) - (>=+ (&;count pattern) - (&;count (&;set idx pattern))) + (n.<= (&;count pattern) + (&;count (&;clear idx pattern))) + (n.>= (&;count pattern) + (&;count (&;set idx pattern))) (or (and (&;set? idx pattern) (not (&;set? idx (&;clear idx pattern)))) @@ -35,32 +35,32 @@ (and (not (&;set? idx pattern)) (&;set? idx (&;flip idx pattern)))) - (=+ width - (++ (&;count pattern) - (&;count (&;~ pattern)))) + (n.= width + (n.+ (&;count pattern) + (&;count (&;~ pattern)))) - (=+ +0 - (&;& pattern - (&;~ pattern))) - (=+ (&;~ +0) - (&;| pattern - (&;~ pattern))) - (=+ (&;~ +0) - (&;^ pattern - (&;~ pattern))) - (=+ +0 - (&;^ pattern - pattern)) + (n.= +0 + (&;& pattern + (&;~ pattern))) + (n.= (&;~ +0) + (&;| pattern + (&;~ pattern))) + (n.= (&;~ +0) + (&;^ pattern + (&;~ pattern))) + (n.= +0 + (&;^ pattern + pattern)) - (|> pattern (&;rotate-left idx) (&;rotate-right idx) (=+ pattern)) - (|> pattern (&;rotate-right idx) (&;rotate-left idx) (=+ pattern)) - (|> pattern (&;rotate-left idx) (&;rotate-left (-+ idx width)) (=+ pattern)) - (|> pattern (&;rotate-right idx) (&;rotate-right (-+ idx width)) (=+ pattern)) + (|> pattern (&;rotate-left idx) (&;rotate-right idx) (n.= pattern)) + (|> pattern (&;rotate-right idx) (&;rotate-left idx) (n.= pattern)) + (|> pattern (&;rotate-left idx) (&;rotate-left (n.- idx width)) (n.= pattern)) + (|> pattern (&;rotate-right idx) (&;rotate-right (n.- idx width)) (n.= pattern)) )) (assert "Shift right respect the sign of ints." (let [value (nat-to-int pattern)] - (if (< 0 value) - (< 0 (&;>> idx value)) - (>= 0 (&;>> idx value))))) + (if (i.< 0 value) + (i.< 0 (&;>> idx value)) + (i.>= 0 (&;>> idx value))))) )) diff --git a/stdlib/test/test/lux/data/error.lux b/stdlib/test/test/lux/data/error.lux index cc92a1276..7cc7c2f4c 100644 --- a/stdlib/test/test/lux/data/error.lux +++ b/stdlib/test/test/lux/data/error.lux @@ -16,31 +16,31 @@ ($_ seq (assert "Functor correctly handles both cases." (and (|> (: (&;Error Int) (#;Right 10)) - (&/map inc) + (&/map i.inc) (case> (#;Right 11) true _ false)) (|> (: (&;Error Int) (#;Left "YOLO")) - (&/map inc) + (&/map i.inc) (case> (#;Left "YOLO") true _ false)) )) (assert "Applicative correctly handles both cases." (and (|> (&/wrap 20) (case> (#;Right 20) true _ false)) - (|> (&/apply (&/wrap inc) (&/wrap 10)) + (|> (&/apply (&/wrap i.inc) (&/wrap 10)) (case> (#;Right 11) true _ false)) - (|> (&/apply (&/wrap inc) (#;Left "YOLO")) + (|> (&/apply (&/wrap i.inc) (#;Left "YOLO")) (case> (#;Left "YOLO") true _ false)))) (assert "Monad correctly handles both cases." (and (|> (do &;Monad<Error> - [f (wrap +) + [f (wrap i.+) a (wrap 10) b (wrap 20)] (wrap (f a b))) (case> (#;Right 30) true _ false)) (|> (do &;Monad<Error> - [f (wrap +) + [f (wrap i.+) a (#;Left "YOLO") b (wrap 20)] (wrap (f a b))) diff --git a/stdlib/test/test/lux/data/error/exception.lux b/stdlib/test/test/lux/data/error/exception.lux index 16d09a626..92d73ae80 100644 --- a/stdlib/test/test/lux/data/error/exception.lux +++ b/stdlib/test/test/lux/data/error/exception.lux @@ -42,9 +42,9 @@ otherwise-val) default-val)]] (assert "Catch and otherwhise handlers can properly handle the flow of exception-handling." - (=+ this-val (|> (if should-throw? - (&;return default-val) - (&;throw this-ex "Uh-oh...")) - (&;catch Some-Exception (lambda [ex] some-val)) - (&;catch Another-Exception (lambda [ex] another-val)) - (&;otherwise (lambda [ex] otherwise-val)))))) + (n.= this-val (|> (if should-throw? + (&;return default-val) + (&;throw this-ex "Uh-oh...")) + (&;catch Some-Exception (lambda [ex] some-val)) + (&;catch Another-Exception (lambda [ex] another-val)) + (&;otherwise (lambda [ex] otherwise-val)))))) diff --git a/stdlib/test/test/lux/data/format/json.lux b/stdlib/test/test/lux/data/format/json.lux index d7c622bd5..270a42358 100644 --- a/stdlib/test/test/lux/data/format/json.lux +++ b/stdlib/test/test/lux/data/format/json.lux @@ -34,7 +34,7 @@ (R;Random &;JSON) (R;rec (lambda [gen-json] (do R;Monad<Random> - [size (:: @ map (%+ +2) R;nat)] + [size (:: @ map (n.% +2) R;nat)] ($_ R;alt (:: @ wrap []) R;bool @@ -81,7 +81,7 @@ (def: gen-record (R;Random Record) (do R;Monad<Random> - [size (:: @ map (%+ +2) R;nat)] + [size (:: @ map (n.% +2) R;nat)] ($_ R;seq (:: @ wrap []) R;bool @@ -100,16 +100,16 @@ (struct: _ (Eq Record) (def: (= recL recR) (and (:: bool;Eq<Bool> = (get@ #bool recL) (get@ #bool recR)) - (;= (get@ #int recL) (get@ #int recR)) - (=. (get@ #real recL) (get@ #real recR)) + (i.= (get@ #int recL) (get@ #int recR)) + (r.= (get@ #real recL) (get@ #real recR)) (:: char;Eq<Char> = (get@ #char recL) (get@ #char recR)) (:: text;Eq<Text> = (get@ #text recL) (get@ #text recR)) (:: (maybe;Eq<Maybe> number;Eq<Int>) = (get@ #maybe recL) (get@ #maybe recR)) (:: (list;Eq<List> number;Eq<Int>) = (get@ #list recL) (get@ #list recR)) (let [[tL0 tL1 tL2] (get@ #tuple recL) [tR0 tR1 tR2] (get@ #tuple recR)] - (and (;= tL0 tR0) - (=. tL1 tR1) + (and (i.= tL0 tR0) + (r.= tL1 tR1) (:: char;Eq<Char> = tL2 tR2))) ))) diff --git a/stdlib/test/test/lux/data/ident.lux b/stdlib/test/test/lux/data/ident.lux index 53ce4968e..e3e313f1a 100644 --- a/stdlib/test/test/lux/data/ident.lux +++ b/stdlib/test/test/lux/data/ident.lux @@ -15,14 +15,14 @@ (test: "Idents" [## First Ident - sizeM1 (|> R;nat (:: @ map (%+ +100))) - sizeN1 (|> R;nat (:: @ map (%+ +100))) + sizeM1 (|> R;nat (:: @ map (n.% +100))) + sizeN1 (|> R;nat (:: @ map (n.% +100))) module1 (R;text sizeM1) name1 (R;text sizeN1) #let [ident1 [module1 name1]] ## Second Ident - sizeM2 (|> R;nat (:: @ map (%+ +100))) - sizeN2 (|> R;nat (:: @ map (%+ +100))) + sizeM2 (|> R;nat (:: @ map (n.% +100))) + sizeN2 (|> R;nat (:: @ map (n.% +100))) module2 (R;text sizeM2) name2 (R;text sizeN2) #let [ident2 [module2 name2]] diff --git a/stdlib/test/test/lux/data/log.lux b/stdlib/test/test/lux/data/log.lux index 3a02638c7..2075e0232 100644 --- a/stdlib/test/test/lux/data/log.lux +++ b/stdlib/test/test/lux/data/log.lux @@ -18,18 +18,18 @@ (let [(^open "&/") (&;Monad<Log> text;Monoid<Text>)] ($_ seq (assert "Functor respects Log." - (= 11 (product;right (&/map inc ["" 10])))) + (i.= 11 (product;right (&/map i.inc ["" 10])))) (assert "Applicative respects Log." - (and (= 20 (product;right (&/wrap 20))) - (= 30 (product;right (&/apply (&/wrap (+ 10)) (&/wrap 20)))))) + (and (i.= 20 (product;right (&/wrap 20))) + (i.= 30 (product;right (&/apply (&/wrap (i.+ 10)) (&/wrap 20)))))) (assert "Monad respects Log." - (= 30 (product;right (do (&;Monad<Log> text;Monoid<Text>) - [f (wrap +) - a (wrap 10) - b (wrap 20)] - (wrap (f a b)))))) + (i.= 30 (product;right (do (&;Monad<Log> text;Monoid<Text>) + [f (wrap i.+) + a (wrap 10) + b (wrap 20)] + (wrap (f a b)))))) (assert "Can log any value." (Text/= "YOLO" (product;left (&;log "YOLO")))) diff --git a/stdlib/test/test/lux/data/number.lux b/stdlib/test/test/lux/data/number.lux index adefb480a..513af2ddf 100644 --- a/stdlib/test/test/lux/data/number.lux +++ b/stdlib/test/test/lux/data/number.lux @@ -85,18 +85,18 @@ (= unit (append unit unit)) (>= x (append x x))))))] - ["Nat/Add" R;nat Number<Nat> Add@Monoid<Nat> (;%+ +1000)] - ["Nat/Mul" R;nat Number<Nat> Mul@Monoid<Nat> (;%+ +1000)] - ["Nat/Min" R;nat Number<Nat> Min@Monoid<Nat> (;%+ +1000)] - ["Nat/Max" R;nat Number<Nat> Max@Monoid<Nat> (;%+ +1000)] - ["Int/Add" R;int Number<Int> Add@Monoid<Int> (;% 1000)] - ["Int/Mul" R;int Number<Int> Mul@Monoid<Int> (;% 1000)] - ["Int/Min" R;int Number<Int> Min@Monoid<Int> (;% 1000)] - ["Int/Max" R;int Number<Int> Max@Monoid<Int> (;% 1000)] - ["Real/Add" R;real Number<Real> Add@Monoid<Real> (;%. 1000.0)] - ["Real/Mul" R;real Number<Real> Mul@Monoid<Real> (;%. 1000.0)] - ["Real/Min" R;real Number<Real> Min@Monoid<Real> (;%. 1000.0)] - ["Real/Max" R;real Number<Real> Max@Monoid<Real> (;%. 1000.0)] + ["Nat/Add" R;nat Number<Nat> Add@Monoid<Nat> (n.% +1000)] + ["Nat/Mul" R;nat Number<Nat> Mul@Monoid<Nat> (n.% +1000)] + ["Nat/Min" R;nat Number<Nat> Min@Monoid<Nat> (n.% +1000)] + ["Nat/Max" R;nat Number<Nat> Max@Monoid<Nat> (n.% +1000)] + ["Int/Add" R;int Number<Int> Add@Monoid<Int> (i.% 1000)] + ["Int/Mul" R;int Number<Int> Mul@Monoid<Int> (i.% 1000)] + ["Int/Min" R;int Number<Int> Min@Monoid<Int> (i.% 1000)] + ["Int/Max" R;int Number<Int> Max@Monoid<Int> (i.% 1000)] + ["Real/Add" R;real Number<Real> Add@Monoid<Real> (r.% 1000.0)] + ["Real/Mul" R;real Number<Real> Mul@Monoid<Real> (r.% 1000.0)] + ["Real/Min" R;real Number<Real> Min@Monoid<Real> (r.% 1000.0)] + ["Real/Max" R;real Number<Real> Max@Monoid<Real> (r.% 1000.0)] ) (do-template [category rand-gen <Number> <Codec>] diff --git a/stdlib/test/test/lux/data/product.lux b/stdlib/test/test/lux/data/product.lux index f74c9a4d8..3d064f96e 100644 --- a/stdlib/test/test/lux/data/product.lux +++ b/stdlib/test/test/lux/data/product.lux @@ -16,11 +16,11 @@ (test: "Products" ($_ seq (assert "Can access the sides of a pair." - (and (= 1 (left [1 2])) - (= 2 (right [1 2])))) + (and (i.= 1 (left [1 2])) + (i.= 2 (right [1 2])))) (assert "Can swap the sides of a pair." (let [[_left _right] (swap [1 2])] - (and (= 2 _left) - (= 1 _right)))) + (and (i.= 2 _left) + (i.= 1 _right)))) )) diff --git a/stdlib/test/test/lux/data/struct/array.lux b/stdlib/test/test/lux/data/struct/array.lux index ba4b5a3ae..6decd910f 100644 --- a/stdlib/test/test/lux/data/struct/array.lux +++ b/stdlib/test/test/lux/data/struct/array.lux @@ -17,7 +17,7 @@ (def: bounded-size (R;Random Nat) (|> R;nat - (:: R;Monad<Random> map (|>. (%+ +100) (++ +1))))) + (:: R;Monad<Random> map (|>. (n.% +100) (n.+ +1))))) (test: "Arrays and their copies" [size bounded-size @@ -29,7 +29,7 @@ (&;new size))]] ($_ seq (assert "Size function must correctly return size of array." - (=+ size (&;size original))) + (n.= size (&;size original))) (assert "Cloning an array should yield and identical array, but not the same one." (and (:: (&;Eq<Array> number;Eq<Nat>) = original clone) (not (== original clone)))) @@ -41,7 +41,7 @@ (exec (:: &;Fold<Array> fold (lambda [x idx] (exec (&;put idx x manual-copy) - (inc+ idx))) + (n.inc idx))) +0 original) (:: (&;Eq<Array> number;Eq<Nat>) = original manual-copy))) @@ -53,9 +53,9 @@ (test: "Array mutation" [size bounded-size - idx (:: @ map (%+ size) R;nat) + idx (:: @ map (n.% size) R;nat) array (|> (R;array size R;nat) - (R;filter (|>. &;to-list (list;any? odd?+)))) + (R;filter (|>. &;to-list (list;any? n.odd?)))) #let [value (default (undefined) (&;get idx array))]] ($_ seq @@ -65,32 +65,32 @@ #;None true)) (assert "You should be able to access values put into the array." (case (&;get idx (&;put idx value array)) - (#;Some value') (=+ value' value) + (#;Some value') (n.= value' value) #;None false)) (assert "All cells should be occupied on a full array." - (and (=+ size (&;occupied array)) - (=+ +0 (&;vacant array)))) + (and (n.= size (&;occupied array)) + (n.= +0 (&;vacant array)))) (assert "Filtering mutates the array to remove invalid values." - (exec (&;filter even?+ array) - (and (<+ size (&;occupied array)) - (>+ +0 (&;vacant array)) - (=+ size (++ (&;occupied array) - (&;vacant array)))))) + (exec (&;filter n.even? array) + (and (n.< size (&;occupied array)) + (n.> +0 (&;vacant array)) + (n.= size (n.+ (&;occupied array) + (&;vacant array)))))) )) (test: "Finding values." [size bounded-size array (|> (R;array size R;nat) - (R;filter (|>. &;to-list (list;any? even?+))))] + (R;filter (|>. &;to-list (list;any? n.even?))))] ($_ seq (assert "Can find values inside arrays." - (|> (&;find even?+ array) + (|> (&;find n.even? array) (case> (#;Some _) true #;None false))) (assert "Can find values inside arrays (with access to indices)." (|> (&;find+ (lambda [idx n] - (and (even?+ n) - (<+ size idx))) + (and (n.even? n) + (n.< size idx))) array) (case> (#;Some _) true #;None false))))) @@ -106,8 +106,8 @@ (and (= array copy) (not (== array copy))))) (assert "Functor should go over all available array elements." - (let [there (map inc+ array) - back-again (map dec+ there)] + (let [there (map n.inc array) + back-again (map n.dec there)] (and (not (= array there)) (= array back-again))))))) @@ -121,7 +121,7 @@ fusion (append left right)]] ($_ seq (assert "Appending two arrays should produce a new one twice as large." - (=+ (++ sizeL sizeR) (&;size fusion))) + (n.= (n.+ sizeL sizeR) (&;size fusion))) (assert "First elements of fused array should equal the first array." (|> (: (&;Array Nat) (&;new sizeL)) diff --git a/stdlib/test/test/lux/data/struct/dict.lux b/stdlib/test/test/lux/data/struct/dict.lux index 2e14ddfff..acd878e8d 100644 --- a/stdlib/test/test/lux/data/struct/dict.lux +++ b/stdlib/test/test/lux/data/struct/dict.lux @@ -20,7 +20,7 @@ lux/test) (test: "Dictionaries." - [#let [capped-nat (:: R;Monad<Random> map (%+ +100) R;nat)] + [#let [capped-nat (:: R;Monad<Random> map (n.% +100) R;nat)] size capped-nat dict (R;dict char;Hash<Char> size R;char capped-nat) non-key (|> R;char @@ -29,10 +29,10 @@ (R;filter (lambda [val] (not (list;member? number;Eq<Nat> (&;values dict) val)))))] ($_ seq (assert "Size function should correctly represent Dict size." - (=+ size (&;size dict))) + (n.= size (&;size dict))) (assert "Dicts of size 0 should be considered empty." - (if (=+ +0 size) + (if (n.= +0 size) (&;empty? dict) (not (&;empty? dict)))) @@ -59,19 +59,19 @@ (assert "Should be able to put and then get a value." (case (&;get non-key (&;put non-key test-val dict)) - (#;Some v) (=+ test-val v) + (#;Some v) (n.= test-val v) _ true)) (assert "Should be able to put~ and then get a value." (case (&;get non-key (&;put~ non-key test-val dict)) - (#;Some v) (=+ test-val v) + (#;Some v) (n.= test-val v) _ true)) (assert "Shouldn't be able to put~ an existing key." - (or (=+ +0 size) + (or (n.= +0 size) (let [first-key (|> dict &;keys list;head (default (undefined)))] (case (&;get first-key (&;put~ first-key test-val dict)) - (#;Some v) (not (=+ test-val v)) + (#;Some v) (not (n.= test-val v)) _ true)))) (assert "Removing a key should make it's value inaccessible." @@ -81,10 +81,10 @@ (assert "Should be possible to update values via their keys." (let [base (&;put non-key test-val dict) - updt (&;update non-key inc+ base)] + updt (&;update non-key n.inc base)] (case [(&;get non-key base) (&;get non-key updt)] [(#;Some x) (#;Some y)] - (=+ (inc+ x) y) + (n.= (n.inc x) y) _ false))) @@ -92,8 +92,8 @@ (assert "Additions and removals to a Dict should affect its size." (let [plus (&;put non-key test-val dict) base (&;remove non-key plus)] - (and (=+ (inc+ (&;size dict)) (&;size plus)) - (=+ (dec+ (&;size plus)) (&;size base))))) + (and (n.= (n.inc (&;size dict)) (&;size plus)) + (n.= (n.dec (&;size plus)) (&;size base))))) (assert "A Dict should equal itself & going to<->from lists shouldn't change that." (let [(^open) (&;Eq<Dict> number;Eq<Nat>)] @@ -106,31 +106,31 @@ (assert "If you merge, and the second dict has overlapping keys, it should overwrite yours." (let [dict' (|> dict &;entries - (List/map (lambda [[k v]] [k (inc+ v)])) + (List/map (lambda [[k v]] [k (n.inc v)])) (&;from-list char;Hash<Char>)) (^open) (&;Eq<Dict> number;Eq<Nat>)] (= dict' (&;merge dict' dict)))) (assert "Can merge values in such a way that they become combined." - (list;every? (lambda [[x x*2]] (=+ (*+ +2 x) x*2)) + (list;every? (lambda [[x x*2]] (n.= (n.* +2 x) x*2)) (list;zip2 (&;values dict) - (&;values (&;merge-with ++ dict dict))))) + (&;values (&;merge-with n.+ dict dict))))) (assert "Should be able to select subset of keys from dict." (|> dict (&;put non-key test-val) (&;select (list non-key)) &;size - (=+ +1))) + (n.= +1))) (assert "Should be able to re-bind existing values to different keys." - (or (=+ +0 size) + (or (n.= +0 size) (let [first-key (|> dict &;keys list;head (default (undefined))) rebound (&;re-bind first-key non-key dict)] - (and (=+ (&;size dict) (&;size rebound)) + (and (n.= (&;size dict) (&;size rebound)) (&;contains? non-key rebound) (not (&;contains? first-key rebound)) - (=+ (default (undefined) + (n.= (default (undefined) (&;get first-key dict)) (default (undefined) (&;get non-key rebound))))))) diff --git a/stdlib/test/test/lux/data/struct/list.lux b/stdlib/test/test/lux/data/struct/list.lux index 5803e8615..aa269988b 100644 --- a/stdlib/test/test/lux/data/struct/list.lux +++ b/stdlib/test/test/lux/data/struct/list.lux @@ -19,11 +19,11 @@ (def: bounded-size (R;Random Nat) (|> R;nat - (:: R;Monad<Random> map (|>. (%+ +100) (++ +10))))) + (:: R;Monad<Random> map (|>. (n.% +100) (n.+ +10))))) (test: "Lists: Part 1" [size bounded-size - idx (:: @ map (%+ size) R;nat) + idx (:: @ map (n.% size) R;nat) sample (R;list size R;nat) other-size bounded-size other-sample (R;list other-size R;nat) @@ -32,33 +32,33 @@ (^open "&/") &;Functor<List>]] ($_ seq (assert "The size function should correctly portray the size of the list." - (=+ size (&;size sample))) + (n.= size (&;size sample))) (assert "The repeat function should produce as many elements as asked of it." - (=+ size (&;size (&;repeat size [])))) + (n.= size (&;size (&;repeat size [])))) (assert "Reversing a list does not change it's size." - (=+ (&;size sample) - (&;size (&;reverse sample)))) + (n.= (&;size sample) + (&;size (&;reverse sample)))) (assert "Reversing a list twice results in the original list." (= sample (&;reverse (&;reverse sample)))) (assert "Filtering by a predicate and its complement should result in a number of elements equal to the original list." - (and (=+ (&;size sample) - (++ (&;size (&;filter even?+ sample)) - (&;size (&;filter (bool;complement even?+) sample)))) - (let [[plus minus] (&;partition even?+ sample)] - (=+ (&;size sample) - (++ (&;size plus) - (&;size minus)))))) + (and (n.= (&;size sample) + (n.+ (&;size (&;filter n.even? sample)) + (&;size (&;filter (bool;complement n.even?) sample)))) + (let [[plus minus] (&;partition n.even? sample)] + (n.= (&;size sample) + (n.+ (&;size plus) + (&;size minus)))))) (assert "If every element in a list satisfies a predicate, there can't be any that satisfy its complement." - (if (&;every? even?+ sample) - (and (not (&;any? (bool;complement even?+) sample)) - (&;empty? (&;filter (bool;complement even?+) sample))) - (&;any? (bool;complement even?+) sample))) + (if (&;every? n.even? sample) + (and (not (&;any? (bool;complement n.even?) sample)) + (&;empty? (&;filter (bool;complement n.even?) sample))) + (&;any? (bool;complement n.even?) sample))) (assert "Any element of the list can be considered it's member." (let [elem (default (undefined) @@ -68,7 +68,7 @@ (test: "Lists: Part 2" [size bounded-size - idx (:: @ map (%+ size) R;nat) + idx (:: @ map (n.% size) R;nat) sample (R;list size R;nat) other-size bounded-size other-sample (R;list other-size R;nat) @@ -95,15 +95,15 @@ (assert "Functor should go over every element of the list." (let [(^open) &;Functor<List> - there (map inc+ sample) - back-again (map dec+ there)] + there (map n.inc sample) + back-again (map n.dec there)] (and (not (= sample there)) (= sample back-again)))) (assert "Splitting a list into chunks and re-appending them should yield the original list." (let [(^open) &;Monoid<List> [left right] (&;split idx sample) - [left' right'] (&;split-with even?+ sample)] + [left' right'] (&;split-with n.even? sample)] (and (= sample (append left right)) (= sample @@ -112,26 +112,26 @@ (append (&;take idx sample) (&;drop idx sample))) (= sample - (append (&;take-while even?+ sample) - (&;drop-while even?+ sample))) + (append (&;take-while n.even? sample) + (&;drop-while n.even? sample))) ))) (assert "Segmenting the list in pairs should yield as many elements as N/2." - (=+ (/+ +2 size) - (&;size (&;as-pairs sample)))) + (n.= (n./ +2 size) + (&;size (&;as-pairs sample)))) (assert "Sorting a list shouldn't change it's size." - (=+ (&;size sample) - (&;size (&;sort <+ sample)))) + (n.= (&;size sample) + (&;size (&;sort n.< sample)))) (assert "Sorting a list with one order should yield the reverse of sorting it with the opposite order." - (= (&;sort <+ sample) - (&;reverse (&;sort >+ sample)))) + (= (&;sort n.< sample) + (&;reverse (&;sort n.> sample)))) )) (test: "Lists: Part 3" [size bounded-size - idx (:: @ map (%+ size) R;nat) + idx (:: @ map (n.% size) R;nat) sample (R;list size R;nat) other-size bounded-size other-sample (R;list other-size R;nat) @@ -140,8 +140,8 @@ (^open "&/") &;Functor<List>]] ($_ seq (assert "If you zip 2 lists, the result's size will be that of the smaller list." - (=+ (&;size (&;zip2 sample other-sample)) - (min+ (&;size sample) (&;size other-sample)))) + (n.= (&;size (&;zip2 sample other-sample)) + (n.min (&;size sample) (&;size other-sample)))) (assert "I can pair-up elements of a list in order." (let [(^open) &;Functor<List> @@ -153,21 +153,21 @@ (assert "You can generate indices for any size, and they will be in ascending order." (let [(^open) &;Functor<List> indices (&;indices size)] - (and (=+ size (&;size indices)) + (and (n.= size (&;size indices)) (= indices - (&;sort <+ indices)) - (&;every? (=+ (dec+ size)) - (&;zip2-with ++ + (&;sort n.< indices)) + (&;every? (n.= (n.dec size)) + (&;zip2-with n.+ indices - (&;sort >+ indices))) + (&;sort n.> indices))) ))) (assert "The 'interpose' function places a value between every member of a list." (let [(^open) &;Functor<List> sample+ (&;interpose separator sample)] - (and (=+ (|> size (*+ +2) dec+) - (&;size sample+)) - (|> sample+ &;as-pairs (map product;right) (&;every? (=+ separator)))))) + (and (n.= (|> size (n.* +2) n.dec) + (&;size sample+)) + (|> sample+ &;as-pairs (map product;right) (&;every? (n.= separator)))))) (assert "List append is a monoid." (let [(^open) &;Monoid<List>] @@ -180,8 +180,8 @@ (assert "Applicative allows you to create singleton lists, and apply lists of functions to lists of values." (let [(^open) &;Applicative<List>] (and (= (list separator) (wrap separator)) - (= (map inc+ sample) - (apply (wrap inc+) sample))))) + (= (map n.inc sample) + (apply (wrap n.inc) sample))))) (assert "List concatenation is a monad." (let [(^open) &;Monad<List> @@ -190,19 +190,19 @@ (join (list sample other-sample))))) (assert "You can find any value that satisfies some criterium, if such values exist in the list." - (case (&;find even?+ sample) + (case (&;find n.even? sample) (#;Some found) - (and (even?+ found) - (&;any? even?+ sample) - (not (&;every? (bool;complement even?+) sample))) + (and (n.even? found) + (&;any? n.even? sample) + (not (&;every? (bool;complement n.even?) sample))) #;None - (and (not (&;any? even?+ sample)) - (&;every? (bool;complement even?+) sample)))) + (and (not (&;any? n.even? sample)) + (&;every? (bool;complement n.even?) sample)))) (assert "You can iteratively construct a list, generating values until you're done." - (= (&;range+ +0 (dec+ size)) - (&;iterate (lambda [n] (if (<+ size n) (#;Some (inc+ n)) #;None)) + (= (&;n.range +0 (n.dec size)) + (&;iterate (lambda [n] (if (n.< size n) (#;Some (n.inc n)) #;None)) +0))) (assert "Can enumerate all elements in a list." diff --git a/stdlib/test/test/lux/data/struct/queue.lux b/stdlib/test/test/lux/data/struct/queue.lux index 5473532bc..98379e30a 100644 --- a/stdlib/test/test/lux/data/struct/queue.lux +++ b/stdlib/test/test/lux/data/struct/queue.lux @@ -14,21 +14,21 @@ lux/test) (test: "Queues" - [size (:: @ map (%+ +100) R;nat) + [size (:: @ map (n.% +100) R;nat) sample (R;queue size R;nat) non-member (|> R;nat (R;filter (. not (&;enqueued? number;Eq<Nat> sample))))] ($_ seq (assert "I can query the size of a queue (and empty queues have size 0)." - (if (=+ +0 size) + (if (n.= +0 size) (&;empty? sample) - (=+ size (&;size sample)))) + (n.= size (&;size sample)))) (assert "Enqueueing and dequeing affects the size of queues." - (and (=+ (inc+ size) (&;size (&;enqueue non-member sample))) + (and (n.= (n.inc size) (&;size (&;enqueue non-member sample))) (or (&;empty? sample) - (=+ (dec+ size) (&;size (&;dequeue sample)))) - (=+ size (&;size (&;dequeue (&;enqueue non-member sample)))))) + (n.= (n.dec size) (&;size (&;dequeue sample)))) + (n.= size (&;size (&;dequeue (&;enqueue non-member sample)))))) (assert "Transforming to/from list can't change the queue." (let [(^open "&/") (&;Eq<Queue> number;Eq<Nat>)] diff --git a/stdlib/test/test/lux/data/struct/set.lux b/stdlib/test/test/lux/data/struct/set.lux index 7a4663509..bc284dd4a 100644 --- a/stdlib/test/test/lux/data/struct/set.lux +++ b/stdlib/test/test/lux/data/struct/set.lux @@ -17,7 +17,7 @@ (def: gen-nat (R;Random Nat) (|> R;nat - (:: R;Monad<Random> map (%+ +100)))) + (:: R;Monad<Random> map (n.% +100)))) (test: "Sets" [sizeL gen-nat @@ -29,8 +29,8 @@ #let [(^open "&/") &;Eq<Set>]] ($_ seq (assert "I can query the size of a set." - (and (=+ sizeL (&;size setL)) - (=+ sizeR (&;size setR)))) + (and (n.= sizeL (&;size setL)) + (n.= sizeR (&;size setR)))) (assert "Converting sets to/from lists can't change their values." (|> setL diff --git a/stdlib/test/test/lux/data/struct/stack.lux b/stdlib/test/test/lux/data/struct/stack.lux index c33bc4012..427c5c04d 100644 --- a/stdlib/test/test/lux/data/struct/stack.lux +++ b/stdlib/test/test/lux/data/struct/stack.lux @@ -17,7 +17,7 @@ (def: gen-nat (R;Random Nat) (|> R;nat - (:: R;Monad<Random> map (%+ +100)))) + (:: R;Monad<Random> map (n.% +100)))) (test: "Stacks" [size gen-nat @@ -25,7 +25,7 @@ new-top gen-nat] ($_ seq (assert "Can query the size of a stack." - (=+ size (&;size sample))) + (n.= size (&;size sample))) (assert "Can peek inside non-empty stacks." (case (&;peek sample) @@ -35,14 +35,14 @@ (assert "Popping empty stacks doesn't change anything. But, if they're non-empty, the top of the stack is removed." (let [sample' (&;pop sample)] - (or (=+ (&;size sample) (inc+ (&;size sample'))) + (or (n.= (&;size sample) (n.inc (&;size sample'))) (and (&;empty? sample) (&;empty? sample'))) )) (assert "Pushing onto a stack always increases it by 1, adding a new value at the top." (and (== sample (&;pop (&;push new-top sample))) - (=+ (inc+ (&;size sample)) (&;size (&;push new-top sample))) + (n.= (n.inc (&;size sample)) (&;size (&;push new-top sample))) (|> (&;push new-top sample) &;peek (default (undefined)) (== new-top)))) )) diff --git a/stdlib/test/test/lux/data/struct/tree.lux b/stdlib/test/test/lux/data/struct/tree.lux index 90b80943a..3c60628e5 100644 --- a/stdlib/test/test/lux/data/struct/tree.lux +++ b/stdlib/test/test/lux/data/struct/tree.lux @@ -17,7 +17,7 @@ (def: gen-nat (R;Random Nat) (|> R;nat - (:: R;Monad<Random> map (%+ +100)))) + (:: R;Monad<Random> map (n.% +100)))) (test: "Trees" [leaf (:: @ map &;leaf R;nat) diff --git a/stdlib/test/test/lux/data/struct/vector.lux b/stdlib/test/test/lux/data/struct/vector.lux index c3f3a706e..fe1350ce0 100644 --- a/stdlib/test/test/lux/data/struct/vector.lux +++ b/stdlib/test/test/lux/data/struct/vector.lux @@ -18,8 +18,8 @@ lux/test) (test: "Vectors" - [size (|> R;nat (:: @ map (%+ +100))) - idx (|> R;nat (:: @ map (%+ size))) + [size (|> R;nat (:: @ map (n.% +100))) + idx (|> R;nat (:: @ map (n.% size))) sample (R;vector size R;nat) other-sample (R;vector size R;nat) non-member (|> R;nat (R;filter (. not (&;member? number;Eq<Nat> sample)))) @@ -30,13 +30,13 @@ ($_ seq (assert "Can query size of vector." (if (&;empty? sample) - (and (=+ +0 size) - (=+ +0 (&;size sample))) - (=+ size (&;size sample)))) + (and (n.= +0 size) + (n.= +0 (&;size sample))) + (n.= size (&;size sample)))) (assert "Can add and remove elements to vectors." - (and (=+ (inc+ size) (&;size (&;add non-member sample))) - (=+ (dec+ size) (&;size (&;pop sample))))) + (and (n.= (n.inc size) (&;size (&;add non-member sample))) + (n.= (n.dec size) (&;size (&;pop sample))))) (assert "Can put and get elements into vectors." (|> sample @@ -47,9 +47,9 @@ (assert "Can update elements of vectors." (|> sample - (&;put idx non-member) (&;update idx inc+) + (&;put idx non-member) (&;update idx n.inc) (&;at idx) (default (undefined)) - (=+ (inc+ non-member)))) + (n.= (n.inc non-member)))) (assert "Can safely transform to/from lists." (|> sample &;to-list &;from-list (&/= sample))) @@ -59,18 +59,18 @@ (&;member? number;Eq<Nat> (&;add non-member sample) non-member))) (assert "Can fold over elements of vector." - (=+ (List/fold ++ +0 (&;to-list sample)) - (&/fold ++ +0 sample))) + (n.= (List/fold n.+ +0 (&;to-list sample)) + (&/fold n.+ +0 sample))) (assert "Functor goes over every element." - (let [there (&/map inc+ sample) - back-again (&/map dec+ there)] + (let [there (&/map n.inc sample) + back-again (&/map n.dec there)] (and (not (&/= sample there)) (&/= sample back-again)))) (assert "Applicative allows you to create singleton vectors, and apply vectors of functions to vectors of values." (and (&/= (&;vector non-member) (&/wrap non-member)) - (&/= (&/map inc+ sample) (&/apply (&/wrap inc+) sample)))) + (&/= (&/map n.inc sample) (&/apply (&/wrap n.inc) sample)))) (assert "Vector concatenation is a monad." (&/= (&/append sample other-sample) diff --git a/stdlib/test/test/lux/data/struct/zipper.lux b/stdlib/test/test/lux/data/struct/zipper.lux index 62f167ffd..6e1a168c2 100644 --- a/stdlib/test/test/lux/data/struct/zipper.lux +++ b/stdlib/test/test/lux/data/struct/zipper.lux @@ -23,7 +23,7 @@ (R;rec (lambda [gen-tree] (do R;Monad<Random> ## Each branch can have, at most, 1 child. - [size (|> R;nat (:: @ map (%+ +2)))] + [size (|> R;nat (:: @ map (n.% +2)))] (R;seq R;nat (R;list size gen-tree)))))) @@ -99,7 +99,7 @@ #;None true)))))) (assert "Can set and update the value of a node." - (|> sample &;from-tree (&;set new-val) &;value (=+ new-val))) + (|> sample &;from-tree (&;set new-val) &;value (n.= new-val))) (assert "Zipper traversal follows the outline of the tree depth-first." (List/= (tree;flatten sample) diff --git a/stdlib/test/test/lux/data/sum.lux b/stdlib/test/test/lux/data/sum.lux index 049dff77c..2ff10dbf5 100644 --- a/stdlib/test/test/lux/data/sum.lux +++ b/stdlib/test/test/lux/data/sum.lux @@ -34,6 +34,6 @@ (list (+0 "0") (+1 "1") (+0 "2")))))))) (assert "Can apply a function to an Either value depending on the case." - (and (= 10 (either (lambda [_] 10) (lambda [_] 20) (: (| Text Text) (+0 "")))) - (= 20 (either (lambda [_] 10) (lambda [_] 20) (: (| Text Text) (+1 "")))))) + (and (i.= 10 (either (lambda [_] 10) (lambda [_] 20) (: (| Text Text) (+0 "")))) + (i.= 20 (either (lambda [_] 10) (lambda [_] 20) (: (| Text Text) (+1 "")))))) ))) diff --git a/stdlib/test/test/lux/data/text.lux b/stdlib/test/test/lux/data/text.lux index 8b315c8b0..46f9192dd 100644 --- a/stdlib/test/test/lux/data/text.lux +++ b/stdlib/test/test/lux/data/text.lux @@ -18,20 +18,20 @@ lux/test) (test: "Size" - [size (:: @ map (%+ +100) R;nat) + [size (:: @ map (n.% +100) R;nat) sample (R;text size)] - (assert "" (or (and (=+ +0 size) + (assert "" (or (and (n.= +0 size) (&;empty? sample)) - (=+ size (&;size sample))))) + (n.= size (&;size sample))))) (def: bounded-size (R;Random Nat) (|> R;nat - (:: R;Monad<Random> map (|>. (%+ +100) (++ +1))))) + (:: R;Monad<Random> map (|>. (n.% +100) (n.+ +1))))) (test: "Locations" [size bounded-size - idx (:: @ map (%+ size) R;nat) + idx (:: @ map (n.% size) R;nat) sample (R;text size)] (assert "" (|> sample (&;at idx) @@ -43,11 +43,11 @@ (&;last-index-of' char' idx sample)] [(#;Some io) (#;Some lio) (#;Some io') (#;Some lio')]}) - (and (<=+ idx io) - (>=+ idx lio) + (and (n.<= idx io) + (n.>= idx lio) - (=+ idx io') - (>=+ idx lio') + (n.= idx io') + (n.>= idx lio') (&;contains? char' sample)) @@ -109,8 +109,8 @@ #let [sample1 (&;concat (list;interpose sep1 parts)) sample2 (&;concat (list;interpose sep2 parts)) (^open) &;Eq<Text>]] - (assert "" (and (=+ (list;size parts) - (list;size (&;split-all-with sep1 sample1))) + (assert "" (and (n.= (list;size parts) + (list;size (&;split-all-with sep1 sample1))) (= sample2 (&;replace sep1 sep2 sample1)) ))) diff --git a/stdlib/test/test/lux/math.lux b/stdlib/test/test/lux/math.lux index 3d5e053f7..8d96fcc41 100644 --- a/stdlib/test/test/lux/math.lux +++ b/stdlib/test/test/lux/math.lux @@ -13,14 +13,14 @@ (test: "lux/math exports" (test-all (match 1.0 (cos 0.0)) - (match -1.0 (cos (/. 2.0 tau))) - ## (match 0.0 (cos (/. 4.0 tau))) - ## (match 0.0 (cos (*. (/. 4.0 3.0) tau))) + (match -1.0 (cos (r./ 2.0 tau))) + ## (match 0.0 (cos (r./ 4.0 tau))) + ## (match 0.0 (cos (r.* (r./ 4.0 3.0) tau))) - (match 1.0 (sin (/. 4.0 tau))) - (match -1.0 (sin (*. (/. 4.0 3.0) tau))) + (match 1.0 (sin (r./ 4.0 tau))) + (match -1.0 (sin (r.* (r./ 4.0 3.0) tau))) ## (match 0.0 (sin 0.0)) - ## (match 0.0 (sin (/. 2.0 tau))) + ## (match 0.0 (sin (r./ 2.0 tau))) (match 4 (ceil 3.75)) (match 3 (floor 3.75)) @@ -30,16 +30,16 @@ (match 3.0 (cbrt 27.0)) (match 4.0 (sqrt 16.0)) - (match 90.0 (degrees (/. 4.0 tau))) - (match true (=. tau (radians (degrees tau)))) + (match 90.0 (degrees (r./ 4.0 tau))) + (match true (r.= tau (radians (degrees tau)))) (match 9 (gcd 450 27)) (match 40 (lcm 10 8)) (match 27 (infix 27)) (match 9 (infix [27 gcd 450])) - (match 9 (infix [(* 3 9) gcd 450])) - (match true (infix [#and 27 < 450 < 2000])) - (match true (infix [#and 27 < 450 > 200])) - (match true (infix [[27 < 450] and [200 < 2000]])) + (match 9 (infix [(i.* 3 9) gcd 450])) + (match true (infix [#and 27 i.< 450 i.< 2000])) + (match true (infix [#and 27 i.< 450 i.> 200])) + (match true (infix [[27 i.< 450] and [200 i.< 2000]])) )) diff --git a/stdlib/test/test/lux/pipe.lux b/stdlib/test/test/lux/pipe.lux index a601bbf98..681c4bf71 100644 --- a/stdlib/test/test/lux/pipe.lux +++ b/stdlib/test/test/lux/pipe.lux @@ -12,26 +12,26 @@ (test: "lux/pipe exports" (test-all (match 1 (|> 20 - (* 3) - (+ 4) - (_> 0 inc))) + (i.* 3) + (i.+ 4) + (_> 0 i.inc))) (match 10 (|> 5 - (@> [(+ @ @)]))) + (@> [(i.+ @ @)]))) (match 15 (|> 5 - (?> [even?] [(* 2)] - [odd?] [(* 3)] + (?> [i.even?] [(i.* 2)] + [i.odd?] [(i.* 3)] [(_> -1)]))) (match 15 (|> 5 - (?> [even?] [(* 2)] - [odd?] [(* 3)]))) + (?> [i.even?] [(i.* 2)] + [i.odd?] [(i.* 3)]))) (match 10 (|> 1 - (!> [(< 10)] - [inc]))) + (!> [(i.< 10)] + [i.inc]))) (match 20 (|> 5 (%> Monad<Identity> - [(* 3)] - [(+ 4)] - [inc]))) + [(i.* 3)] + [(i.+ 4)] + [i.inc]))) (match "five" (|> 5 (case> 0 "zero" 1 "one" |