- In lux/test, renamed "test:" to "context:", and "assert" to "test".

63 files changed, 2896 insertions, 2896 deletions

diff --git a/stdlib/source/lux/test.lux b/stdlib/source/lux/test.lux
index b104df4f9..ab64ee86e 100644
--- a/stdlib/source/lux/test.lux
+++ b/stdlib/source/lux/test.lux
@@ -38,7 +38,7 @@
   (All [a] (-> Text Test))
   (:: Monad<Promise> wrap (#E;Error message)))
 
-(def: #export (assert message condition)
+(def: #export (test message condition)
   {#;doc "Check that a condition is true, and fail with the given message otherwise."}
   (-> Text Bool Test)
   (if condition
@@ -160,65 +160,65 @@
     output
 
     (#E;Error error)
-    (assert error false)))
+    (test error false)))
 
-(syntax: #export (test: description [body test^])
+(syntax: #export (context: description [body test^])
   {#;doc (doc "Macro for definint tests."
-              (test: "Simple macros and constructs"
+              (context: "Simple macros and constructs"
                 ($_ seq
-                    (assert "Can write easy loops for iterative programming."
-                            (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)
-                                   (#;Cons 1 (#;Cons 2 (#;Cons 3 #;Nil)))
-                                   true
-
-                                   _
-                                   false)
-                                 
-                                 (case (list& 1 2 3 (list 4 5 6))
-                                   (#;Cons 1 (#;Cons 2 (#;Cons 3 (#;Cons 4 (#;Cons 5 (#;Cons 6 #;Nil))))))
-                                   true
-
-                                   _
-                                   false)))
-
-                    (assert "Can have defaults for Maybe values."
-                            (and (is "yolo" (default "yolo"
-                                              #;None))
-                                 
-                                 (is "lol" (default "yolo"
-                                             (#;Some "lol")))))
+                    (test "Can write easy loops for iterative programming."
+                          (i.= 1000
+                               (loop [counter 0
+                                      value 1]
+                                 (if (i.< 3 counter)
+                                   (recur (i.inc counter) (i.* 10 value))
+                                   value))))
+
+                    (test "Can create lists easily through macros."
+                          (and (case (list 1 2 3)
+                                 (#;Cons 1 (#;Cons 2 (#;Cons 3 #;Nil)))
+                                 true
+
+                                 _
+                                 false)
+                               
+                               (case (list& 1 2 3 (list 4 5 6))
+                                 (#;Cons 1 (#;Cons 2 (#;Cons 3 (#;Cons 4 (#;Cons 5 (#;Cons 6 #;Nil))))))
+                                 true
+
+                                 _
+                                 false)))
+
+                    (test "Can have defaults for Maybe values."
+                          (and (is "yolo" (default "yolo"
+                                            #;None))
+                               
+                               (is "lol" (default "yolo"
+                                           (#;Some "lol")))))
                     ))
               "Also works with random generation of values for property-based testing."
-              (test: "Addition & Substraction"
+              (context: "Addition & Substraction"
                 [x (:: @ map <prep> rand-gen)
                  y (:: @ map <prep> rand-gen)]
-                (assert ""
-                        (and (|> x (- y) (+ y) (= x))
-                             (|> x (+ y) (- y) (= x)))))
+                (test ""
+                      (and (|> x (- y) (+ y) (= x))
+                           (|> x (+ y) (- y) (= x)))))
               "By default, random tests will be tried 100 times, you can specify the amount you want:"
-              (test: "Addition & Substraction"
+              (context: "Addition & Substraction"
                 #times +1234
                 [x (:: @ map <prep> rand-gen)
                  y (:: @ map <prep> rand-gen)]
-                (assert ""
-                        (and (|> x (- y) (+ y) (= x))
-                             (|> x (+ y) (- y) (= x)))))
+                (test ""
+                      (and (|> x (- y) (+ y) (= x))
+                           (|> x (+ y) (- y) (= x)))))
               "If a test fails, you'll be shown a seed that you can then use to reproduce a failing scenario."
-              (test: "Addition & Substraction"
+              (context: "Addition & Substraction"
                 #seed +987654321
                 [x (:: @ map <prep> rand-gen)
                  y (:: @ map <prep> rand-gen)]
-                (assert ""
-                        (and (|> x (- y) (+ y) (= x))
-                             (|> x (+ y) (- y) (= x)))))
+                (test ""
+                      (and (|> x (- y) (+ y) (= x))
+                           (|> x (+ y) (- y) (= x)))))
               )}
   (let [body (case body
                (#Property config bindings body)
diff --git a/stdlib/test/test/lux.lux b/stdlib/test/test/lux.lux
index fd69b1e22..a43609668 100644
--- a/stdlib/test/test/lux.lux
+++ b/stdlib/test/test/lux.lux
@@ -10,62 +10,62 @@
        [macro]
        (macro ["s" syntax #+ syntax:])))
 
-(test: "Value identity."
+(context: "Value identity."
   [size (|> R;nat (:: @ map (|>. (n.% +100) (n.max +10))))
    x (R;text size)
    y (R;text size)]
   ($_ seq
-      (assert "Every value is identical to itself, and the 'id' function doesn't change values in any way."
-              (and (is x x)
-                   (is x (id x))))
+      (test "Every value is identical to itself, and the 'id' function doesn't change values in any way."
+            (and (is x x)
+                 (is x (id x))))
 
-      (assert "Values created separately can't be identical."
-              (not (is x y)))
+      (test "Values created separately can't be identical."
+            (not (is x y)))
       ))
 
 (do-template [category rand-gen inc dec even? odd? = < >]
-  [(test: (format "[" category "] " "Moving up-down or down-up should result in same value.")
+  [(context: (format "[" category "] " "Moving up-down or down-up should result in same value.")
      [value rand-gen]
-     (assert "" (and (|> value inc dec (= value))
-                     (|> value dec inc (= value)))))
+     (test "" (and (|> value inc dec (= value))
+                   (|> value dec inc (= value)))))
 
-   (test: (format "[" category "] " "(x+1) > x && (x-1) < x")
+   (context: (format "[" category "] " "(x+1) > x && (x-1) < x")
      [value rand-gen]
-     (assert "" (and (|> value inc (> value))
-                     (|> value dec (< value)))))
+     (test "" (and (|> value inc (> value))
+                   (|> value dec (< value)))))
 
-   (test: (format "[" category "] " "Every odd/even number is surrounded by two of the other kind.")
+   (context: (format "[" category "] " "Every odd/even number is surrounded by two of the other kind.")
      [value rand-gen]
-     (assert ""
-             (if (even? value)
-               (and (|> value inc odd?)
-                    (|> value dec odd?))
-               (and (|> value inc even?)
-                    (|> value dec even?)))))]
+     (test ""
+           (if (even? value)
+             (and (|> value inc odd?)
+                  (|> value dec odd?))
+             (and (|> value inc even?)
+                  (|> value dec even?)))))]
 
   ["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]
-  [(test: (format "[" category "] " "The symmetry of numerical comparisons.")
+  [(context: (format "[" category "] " "The symmetry of numerical comparisons.")
      [x rand-gen
       y rand-gen]
-     (assert ""
-             (or (= x y)
-                 (if (< y x)
-                   (> x y)
-                   (< x y)))))
+     (test ""
+           (or (= x y)
+               (if (< y x)
+                 (> x y)
+                 (< x y)))))
 
-   (test: (format "[" category "] " "Minimums and maximums.")
+   (context: (format "[" category "] " "Minimums and maximums.")
      [x rand-gen
       y rand-gen]
-     (assert ""
-             (and (and (<= x (min x y))
-                       (<= y (min x y)))
-                  (and (>= x (max x y))
-                       (>= y (max x y)))
-                  )))]
+     (test ""
+           (and (and (<= x (min x y))
+                     (<= y (min x y)))
+                (and (>= x (max x y))
+                     (>= y (max x y)))
+                )))]
 
   ["Int"  R;int  i.= i.< i.> i.<= i.>= i.min i.max]
   ["Nat"  R;nat  n.= n.< n.> n.<= n.>= n.min n.max]
@@ -74,46 +74,46 @@
   )
 
 (do-template [category rand-gen = + - * / <%> > <0> <1> <factor> %x <cap> <prep>]
-  [(test: (format "[" category "] " "Additive identity")
+  [(context: (format "[" category "] " "Additive identity")
      [x rand-gen]
-     (assert ""
-             (and (|> x (+ <0>) (= x))
-                  (|> x (- <0>) (= x)))))
+     (test ""
+           (and (|> x (+ <0>) (= x))
+                (|> x (- <0>) (= x)))))
 
-   (test: (format "[" category "] " "Addition & Substraction")
+   (context: (format "[" category "] " "Addition & Substraction")
      [x (:: @ map <prep> rand-gen)
       y (:: @ map <prep> rand-gen)
       #let [x (* <factor> x)
             y (* <factor> y)]]
-     (assert ""
-             (and (|> x (- y) (+ y) (= x))
-                  (|> x (+ y) (- y) (= x)))))
+     (test ""
+           (and (|> x (- y) (+ y) (= x))
+                (|> x (+ y) (- y) (= x)))))
 
-   (test: (format "[" category "] " "Multiplicative identity")
+   (context: (format "[" category "] " "Multiplicative identity")
      [x rand-gen]
-     (assert ""
-             ## Skip this test for Deg
-             ## because Deg division loses the last
-             ## 32 bits of precision.
-             (or (T/= "Deg" category)
-                 (and (|> x (* <1>) (= x))
-                      (|> x (/ <1>) (= x))))))
-
-   (test: (format "[" category "] " "Multiplication & Division")
+     (test ""
+           ## Skip this test for Deg
+           ## because Deg division loses the last
+           ## 32 bits of precision.
+           (or (T/= "Deg" category)
+               (and (|> x (* <1>) (= x))
+                    (|> x (/ <1>) (= x))))))
+
+   (context: (format "[" category "] " "Multiplication & Division")
      [x (:: @ map <cap> rand-gen)
       y (|> rand-gen
             (:: @ map <cap>)
             (R;filter (|>. (= <0>) not)))
       #let [r (<%> y x)
             x' (- r x)]]
-     (assert ""
-             ## Skip this test for Deg
-             ## because Deg division loses the last
-             ## 32 bits of precision.
-             (or (T/= "Deg" category)
-                 (or (> x' y)
-                     (|> x' (/ y) (* y) (= x'))))
-             ))]
+     (test ""
+           ## Skip this test for Deg
+           ## because Deg division loses the last
+           ## 32 bits of precision.
+           (or (T/= "Deg" category)
+               (or (> x' y)
+                   (|> x' (/ y) (* y) (= x'))))
+           ))]
 
   ["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]
@@ -122,11 +122,11 @@
   )
 
 (do-template [category rand-gen -> <- = <cap> %a %z]
-  [(test: (format "[" category "] " "Numeric conversions")
+  [(context: (format "[" category "] " "Numeric conversions")
      [value rand-gen
       #let [value (<cap> value)]]
-     (assert ""
-             (|> value -> <- (= value))))]
+     (test ""
+           (|> value -> <- (= value))))]
 
   ["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]
@@ -135,45 +135,45 @@
   ## [R;real real-to-deg deg-to-real r.= (r.% 1.0) %r %f]
   )
 
-(test: "Simple macros and constructs"
+(context: "Simple macros and constructs"
   ($_ seq
-      (assert "Can write easy loops for iterative programming."
-              (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)
-                     (#;Cons 1 (#;Cons 2 (#;Cons 3 #;Nil)))
-                     true
-
-                     _
-                     false)
-                   
-                   (case (list& 1 2 3 (list 4 5 6))
-                     (#;Cons 1 (#;Cons 2 (#;Cons 3 (#;Cons 4 (#;Cons 5 (#;Cons 6 #;Nil))))))
-                     true
-
-                     _
-                     false)))
-
-      (assert "Can have defaults for Maybe values."
-              (and (is "yolo" (default "yolo"
-                                #;None))
-                   
-                   (is "lol" (default "yolo"
-                               (#;Some "lol")))))
+      (test "Can write easy loops for iterative programming."
+            (i.= 1000
+                 (loop [counter 0
+                        value 1]
+                   (if (i.< 3 counter)
+                     (recur (i.inc counter) (i.* 10 value))
+                     value))))
+
+      (test "Can create lists easily through macros."
+            (and (case (list 1 2 3)
+                   (#;Cons 1 (#;Cons 2 (#;Cons 3 #;Nil)))
+                   true
+
+                   _
+                   false)
+                 
+                 (case (list& 1 2 3 (list 4 5 6))
+                   (#;Cons 1 (#;Cons 2 (#;Cons 3 (#;Cons 4 (#;Cons 5 (#;Cons 6 #;Nil))))))
+                   true
+
+                   _
+                   false)))
+
+      (test "Can have defaults for Maybe values."
+            (and (is "yolo" (default "yolo"
+                              #;None))
+                 
+                 (is "lol" (default "yolo"
+                             (#;Some "lol")))))
       ))
 
 (template: (hypotenuse x y)
   (i.+ (i.* x x) (i.* y y)))
 
-(test: "Templates"
+(context: "Templates"
   [x R;int
    y R;int]
-  (assert "Template application is a stand-in for the templated code."
-          (i.= (i.+ (i.* x x) (i.* y y))
-               (hypotenuse x y))))
+  (test "Template application is a stand-in for the templated code."
+        (i.= (i.+ (i.* x x) (i.* y y))
+             (hypotenuse x y))))
diff --git a/stdlib/test/test/lux/cli.lux b/stdlib/test/test/lux/cli.lux
index b8ed6ca0c..b19a9d345 100644
--- a/stdlib/test/test/lux/cli.lux
+++ b/stdlib/test/test/lux/cli.lux
@@ -13,82 +13,82 @@
        ["R" math/random])
   lux/test)
 
-(test: "CLI"
+(context: "CLI"
   [num-args (|> R;nat (:: @ map (n.% +10)))
    #let [(^open "Nat/") number;Codec<Text,Nat>
          gen-arg (:: @ map Nat/encode R;nat)]
    option-name (R;text +5)
    args (R;list num-args gen-arg)]
   ($_ seq
-      (assert "Can read any argument."
-              (|> (&;run &;any args)
-                  (case> (#;Left _)
-                         (n.= +0 num-args)
-                         
-                         (#;Right arg)
-                         (and (not (n.= +0 num-args))
-                              (Text/= arg (default (undefined)
-                                            (list;head args)))))))
+      (test "Can read any argument."
+            (|> (&;run &;any args)
+                (case> (#;Left _)
+                       (n.= +0 num-args)
+                       
+                       (#;Right arg)
+                       (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 (n.= +0 num-args))
-                              (Text/= arg (default (undefined)
-                                            (list;head args))))
+      (test "Can safely fail parsing an argument."
+            (|> (&;run (&;opt &;any) args)
+                (case> (#;Right (#;Some arg))
+                       (and (not (n.= +0 num-args))
+                            (Text/= arg (default (undefined)
+                                          (list;head args))))
 
-                         (#;Right #;None)
-                         (n.= +0 num-args)
+                       (#;Right #;None)
+                       (n.= +0 num-args)
 
-                         _
-                         false)))
+                       _
+                       false)))
       
-      (assert "Can read multiple arguments."
-              (and (|> (&;run (&;some &;any) args)
-                       (case> (#;Left _)
-                              false
-                              
-                              (#;Right args')
-                              (n.= num-args (list;size args'))))
-                   (|> (&;run (&;many &;any) args)
-                       (case> (#;Left _)
-                              (n.= +0 num-args)
-                              
-                              (#;Right args')
-                              (n.= num-args (list;size args'))))))
+      (test "Can read multiple arguments."
+            (and (|> (&;run (&;some &;any) args)
+                     (case> (#;Left _)
+                            false
+                            
+                            (#;Right args')
+                            (n.= num-args (list;size args'))))
+                 (|> (&;run (&;many &;any) args)
+                     (case> (#;Left _)
+                            (n.= +0 num-args)
+                            
+                            (#;Right args')
+                            (n.= num-args (list;size args'))))))
 
-      (assert "Can use custom token parsers."
-              (|> (&;run (&;parse Nat/decode) args)
-                  (case> (#;Left _)
-                         (n.= +0 num-args)
-                         
-                         (#;Right parsed)
-                         (Text/= (Nat/encode parsed)
-                                 (default (undefined)
-                                   (list;head args))))))
+      (test "Can use custom token parsers."
+            (|> (&;run (&;parse Nat/decode) args)
+                (case> (#;Left _)
+                       (n.= +0 num-args)
+                       
+                       (#;Right parsed)
+                       (Text/= (Nat/encode parsed)
+                               (default (undefined)
+                                 (list;head args))))))
 
-      (assert "Can obtain option values."
-              (and (|> (&;run (&;option (list option-name)) (list& option-name args))
-                       (case> (#;Left _)
-                              (n.= +0 num-args)
-                              
-                              (#;Right value)
-                              (Text/= value (default (undefined)
-                                              (list;head args)))))
-                   (|> (&;run (&;option (list option-name)) args)
-                       (case> (#;Left _) true (#;Right _) false))))
+      (test "Can obtain option values."
+            (and (|> (&;run (&;option (list option-name)) (list& option-name args))
+                     (case> (#;Left _)
+                            (n.= +0 num-args)
+                            
+                            (#;Right value)
+                            (Text/= value (default (undefined)
+                                            (list;head args)))))
+                 (|> (&;run (&;option (list option-name)) args)
+                     (case> (#;Left _) true (#;Right _) false))))
 
-      (assert "Can check flags."
-              (and (|> (&;run (&;flag (list option-name)) (list& option-name args))
-                       (case> (#;Right true) true _ false))
-                   (|> (&;run (&;flag (list option-name)) args)
-                       (case> (#;Right false) true _ false))))
+      (test "Can check flags."
+            (and (|> (&;run (&;flag (list option-name)) (list& option-name args))
+                     (case> (#;Right true) true _ false))
+                 (|> (&;run (&;flag (list option-name)) args)
+                     (case> (#;Right false) true _ false))))
 
-      (assert "Can query if there are any more inputs."
-              (and (|> (&;run &;end args)
-                       (case> (#;Right []) (n.= +0 num-args)
-                              _ (n.> +0 num-args)))
-                   (|> (&;run (&;not &;end) args)
-                       (case> (#;Right []) (n.> +0 num-args)
-                              _ (n.= +0 num-args)))))
+      (test "Can query if there are any more inputs."
+            (and (|> (&;run &;end args)
+                     (case> (#;Right []) (n.= +0 num-args)
+                            _ (n.> +0 num-args)))
+                 (|> (&;run (&;not &;end) args)
+                     (case> (#;Right []) (n.> +0 num-args)
+                            _ (n.= +0 num-args)))))
       ))
diff --git a/stdlib/test/test/lux/concurrency/actor.lux b/stdlib/test/test/lux/concurrency/actor.lux
index a92c2c376..a8f6ed7fb 100644
--- a/stdlib/test/test/lux/concurrency/actor.lux
+++ b/stdlib/test/test/lux/concurrency/actor.lux
@@ -20,7 +20,7 @@
   (stop:
     (wrap [])))
 
-(test: "Actors"
+(context: "Actors"
   (let [counter-proc (: (&;Behavior Int (Promise Int))
                         [(function [self output state]
                            (let [state' (i.inc state)]
@@ -28,22 +28,22 @@
                                (Promise/wrap (#;Right state')))))
                          (function [?error state] (Promise/wrap []))])]
     ($_ seq
-        (assert "Can check where an actor is alive."
-                (let [counter (: (&;Actor Int (Promise Int))
-                                 (io;run (&;spawn 0 counter-proc)))]
-                  (&;alive? counter)))
+        (test "Can check where an actor is alive."
+              (let [counter (: (&;Actor Int (Promise Int))
+                               (io;run (&;spawn 0 counter-proc)))]
+                (&;alive? counter)))
         
-        (assert "Can poison/kill actors."
-                (let [counter (: (&;Actor Int (Promise Int))
-                                 (io;run (&;spawn 0 counter-proc)))]
-                  (and (io;run (&;poison counter))
-                       (not (&;alive? counter)))))
+        (test "Can poison/kill actors."
+              (let [counter (: (&;Actor Int (Promise Int))
+                               (io;run (&;spawn 0 counter-proc)))]
+                (and (io;run (&;poison counter))
+                     (not (&;alive? counter)))))
         
-        (assert "Can't poison an already poisoned actor."
-                (let [counter (: (&;Actor Int (Promise Int))
-                                 (io;run (&;spawn 0 counter-proc)))]
-                  (and (io;run (&;poison counter))
-                       (not (io;run (&;poison counter))))))
+        (test "Can't poison an already poisoned actor."
+              (let [counter (: (&;Actor Int (Promise Int))
+                               (io;run (&;spawn 0 counter-proc)))]
+                (and (io;run (&;poison counter))
+                     (not (io;run (&;poison counter))))))
         
         (do Monad<Promise>
           [#let [counter (: (&;Actor Int (Promise Int))
@@ -57,10 +57,10 @@
            =1 output-1
            =2 output-2
            =3 output-3]
-          (assert "Can send messages to actors."
-                  (and (i.= 1 =1)
-                       (i.= 2 =2)
-                       (i.= 3 =3))))
+          (test "Can send messages to actors."
+                (and (i.= 1 =1)
+                     (i.= 2 =2)
+                     (i.= 3 =3))))
         
         (do Monad<Promise>
           [#let [adder (: Adder
@@ -69,11 +69,11 @@
            t2 (add! 2 adder)
            t3 (add! 3 adder)
            #let [_ (io;run (&;poison adder))]]
-          (assert "Can use custom-defined actors."
-                  (case [t1 t2 t3]
-                    [[0 1] [1 3] [3 6]]
-                    true
+          (test "Can use custom-defined actors."
+                (case [t1 t2 t3]
+                  [[0 1] [1 3] [3 6]]
+                  true
 
-                    _
-                    false)))
+                  _
+                  false)))
         )))
diff --git a/stdlib/test/test/lux/concurrency/atom.lux b/stdlib/test/test/lux/concurrency/atom.lux
index 84deafa07..e3f30902b 100644
--- a/stdlib/test/test/lux/concurrency/atom.lux
+++ b/stdlib/test/test/lux/concurrency/atom.lux
@@ -9,24 +9,24 @@
        ["R" math/random])
   lux/test)
 
-(test: "Atoms"
+(context: "Atoms"
   [value R;nat
    swap-value R;nat
    set-value R;nat
    #let [box (&;atom value)]]
   ($_ seq
-      (assert "Can obtain the value of an atom."
-              (n.= value (io;run (&;get box))))
+      (test "Can obtain the value of an atom."
+            (n.= value (io;run (&;get box))))
 
-      (assert "Can swap the value of an atom."
-              (and (io;run (&;compare-and-swap value swap-value box))
-                   (n.= swap-value (io;run (&;get box)))))
+      (test "Can swap the value of an atom."
+            (and (io;run (&;compare-and-swap value swap-value box))
+                 (n.= swap-value (io;run (&;get box)))))
 
-      (assert "Can update the value of an atom."
-              (exec (io;run (&;update n.inc box))
-                (n.= (n.inc swap-value) (io;run (&;get box)))))
+      (test "Can update the value of an atom."
+            (exec (io;run (&;update n.inc box))
+              (n.= (n.inc swap-value) (io;run (&;get box)))))
 
-      (assert "Can immediately set the value of an atom."
-              (exec (io;run (&;set set-value box))
-                (n.= set-value (io;run (&;get box)))))
+      (test "Can immediately set the value of an atom."
+            (exec (io;run (&;set set-value box))
+              (n.= set-value (io;run (&;get box)))))
       ))
diff --git a/stdlib/test/test/lux/concurrency/frp.lux b/stdlib/test/test/lux/concurrency/frp.lux
index 245428f38..2d9a45167 100644
--- a/stdlib/test/test/lux/concurrency/frp.lux
+++ b/stdlib/test/test/lux/concurrency/frp.lux
@@ -17,108 +17,108 @@
                _ (&;close _chan)]
               (wrap _chan)))))
 
-(test: "FRP"
+(context: "FRP"
   ($_ seq
       (do Monad<Promise>
         [elems (&;consume (List->Chan (list 0 1 2 3 4 5)))]
-        (assert "Can consume a chan into a list."
-                (case elems
-                  (^ (list 0 1 2 3 4 5))
-                  true
+        (test "Can consume a chan into a list."
+              (case elems
+                (^ (list 0 1 2 3 4 5))
+                true
 
-                  _
-                  false)))
+                _
+                false)))
 
       (do Monad<Promise>
         [elems (&;consume (let [input (List->Chan (list 0 1 2 3 4 5))
                                 output (: (&;Chan Int) (&;chan))]
                             (exec (&;pipe input output)
                               output)))]
-        (assert "Can pipe one channel into another."
-                (case elems
-                  (^ (list 0 1 2 3 4 5))
-                  true
+        (test "Can pipe one channel into another."
+              (case elems
+                (^ (list 0 1 2 3 4 5))
+                true
 
-                  _
-                  false)))
+                _
+                false)))
 
       (do Monad<Promise>
         [elems (&;consume (&;filter i.even? (List->Chan (list 0 1 2 3 4 5))))]
-        (assert "Can filter a channel's elements."
-                (case elems
-                  (^ (list 0 2 4))
-                  true
+        (test "Can filter a channel's elements."
+              (case elems
+                (^ (list 0 2 4))
+                true
 
-                  _
-                  false)))
+                _
+                false)))
 
       (do Monad<Promise>
         [elems (&;consume (&;merge (list (List->Chan (list 0 1 2 3 4 5))
                                          (List->Chan (list 0 -1 -2 -3 -4 -5)))))]
-        (assert "Can merge channels."
-                (case elems
-                  (^ (list 0 1 2 3 4 5 0 -1 -2 -3 -4 -5))
-                  true
+        (test "Can merge channels."
+              (case elems
+                (^ (list 0 1 2 3 4 5 0 -1 -2 -3 -4 -5))
+                true
 
-                  _
-                  false)))
+                _
+                false)))
       
       (do Monad<Promise>
         [output (&;fold (function [base input] (Promise/wrap (i.+ input base))) 0 (List->Chan (list 0 1 2 3 4 5)))]
-        (assert "Can fold over a channel."
-                (i.= 15 output)))
+        (test "Can fold over a channel."
+              (i.= 15 output)))
 
       (do Monad<Promise>
         [elems (&;consume (&;distinct number;Eq<Int> (List->Chan (list 0 0 0 1 2 2 3 3 3 3 4 4 4 5 5))))]
-        (assert "Can avoid immediate repetition in the channel."
-                (case elems
-                  (^ (list 0 1 2 3 4 5))
-                  true
+        (test "Can avoid immediate repetition in the channel."
+              (case elems
+                (^ (list 0 1 2 3 4 5))
+                true
 
-                  _
-                  false)))
+                _
+                false)))
 
       (do Monad<Promise>
         [elems (&;consume (&;once (:: promise;Monad<Promise> wrap 12345)))]
-        (assert "Can convert a promise into a single-value channel."
-                (case elems
-                  (^ (list 12345))
-                  true
+        (test "Can convert a promise into a single-value channel."
+              (case elems
+                (^ (list 12345))
+                true
 
-                  _
-                  false)))
+                _
+                false)))
 
       (do Monad<Promise>
         [elems (&;consume (:: &;Functor<Chan> map i.inc (List->Chan (list 0 1 2 3 4 5))))]
-        (assert "Functor goes over every element in a channel."
-                (case elems
-                  (^ (list 1 2 3 4 5 6))
-                  true
+        (test "Functor goes over every element in a channel."
+              (case elems
+                (^ (list 1 2 3 4 5 6))
+                true
 
-                  _
-                  false)))
+                _
+                false)))
 
       (do Monad<Promise>
         [elems (&;consume (let [(^open) &;Applicative<Chan>]
                             (apply (wrap i.inc) (wrap 12345))))]
-        (assert "Applicative works over all channel values."
-                (case elems
-                  (^ (list 12346))
-                  true
+        (test "Applicative works over all channel values."
+              (case elems
+                (^ (list 12346))
+                true
 
-                  _
-                  false)))
+                _
+                false)))
 
       (do Monad<Promise>
         [elems (&;consume (do &;Monad<Chan>
                             [f (wrap i.inc)
                              a (wrap 12345)]
                             (wrap (f a))))]
-        (assert "Monad works over all channel values."
-                (case elems
-                  (^ (list 12346))
-                  true
+        (test "Monad works over all channel values."
+              (case elems
+                (^ (list 12346))
+                true
 
-                  _
-                  false)))
+                _
+                false)))
       ))
diff --git a/stdlib/test/test/lux/concurrency/promise.lux b/stdlib/test/test/lux/concurrency/promise.lux
index 8c4e623e4..30802085b 100644
--- a/stdlib/test/test/lux/concurrency/promise.lux
+++ b/stdlib/test/test/lux/concurrency/promise.lux
@@ -9,63 +9,63 @@
        ["R" math/random])
   lux/test)
 
-(test: "Promises"
+(context: "Promises"
   ($_ seq
       (do &;Monad<Promise>
         [running? (&;future (io true))]
-        (assert "Can run IO actions in separate threads."
-                running?))
+        (test "Can run IO actions in separate threads."
+              running?))
 
       (do &;Monad<Promise>
         [_ (&;wait +500)]
-        (assert "Can wait for a specified amount of time."
-                true))
+        (test "Can wait for a specified amount of time."
+              true))
 
       (do &;Monad<Promise>
         [[left right] (&;seq (&;future (io true))
                              (&;future (io false)))]
-        (assert "Can combine promises sequentially."
-                (and left (not right))))
+        (test "Can combine promises sequentially."
+              (and left (not right))))
 
       (do &;Monad<Promise>
         [?left (&;alt (&;delay +100 true)
                       (&;delay +200 false))
          ?right (&;alt (&;delay +200 true)
                        (&;delay +100 false))]
-        (assert "Can combine promises alternatively."
-                (case [?left ?right]
-                  [(#;Left true) (#;Right false)]
-                  true
+        (test "Can combine promises alternatively."
+              (case [?left ?right]
+                [(#;Left true) (#;Right false)]
+                true
 
-                  _
-                  false)))
+                _
+                false)))
 
       (do &;Monad<Promise>
         [?left (&;either (&;delay +100 true)
                          (&;delay +200 false))
          ?right (&;either (&;delay +200 true)
                           (&;delay +100 false))]
-        (assert "Can combine promises alternatively [Part 2]."
-                (and ?left (not ?right))))
+        (test "Can combine promises alternatively [Part 2]."
+              (and ?left (not ?right))))
 
-      (assert "Can poll a promise for its value."
-              (and (|> (&;poll (:: &;Monad<Promise> wrap true))
-                       (case> (#;Some true) true _ false))
-                   (|> (&;poll (&;delay +200 true))
-                       (case> #;None true _ false))))
+      (test "Can poll a promise for its value."
+            (and (|> (&;poll (:: &;Monad<Promise> wrap true))
+                     (case> (#;Some true) true _ false))
+                 (|> (&;poll (&;delay +200 true))
+                     (case> #;None true _ false))))
 
-      (assert "Cant re-resolve a resolved promise."
-              (and (not (io;run (&;resolve false (:: &;Monad<Promise> wrap true))))
-                   (io;run (&;resolve true (: (&;Promise Bool) (&;promise))))))
+      (test "Cant re-resolve a resolved promise."
+            (and (not (io;run (&;resolve false (:: &;Monad<Promise> wrap true))))
+                 (io;run (&;resolve true (: (&;Promise Bool) (&;promise))))))
 
       (do &;Monad<Promise>
         [?none (&;time-out +100 (&;delay +200 true))
          ?some (&;time-out +200 (&;delay +100 true))]
-        (assert "Can establish maximum waiting times for promises to be fulfilled."
-                (case [?none ?some]
-                  [#;None (#;Some true)]
-                  true
+        (test "Can establish maximum waiting times for promises to be fulfilled."
+              (case [?none ?some]
+                [#;None (#;Some true)]
+                true
 
-                  _
-                  false)))
+                _
+                false)))
       ))
diff --git a/stdlib/test/test/lux/concurrency/stm.lux b/stdlib/test/test/lux/concurrency/stm.lux
index c1c8144ae..8471eb67a 100644
--- a/stdlib/test/test/lux/concurrency/stm.lux
+++ b/stdlib/test/test/lux/concurrency/stm.lux
@@ -12,7 +12,7 @@
 
 (def: iterations/processes Int 100)
 
-(test: "STM"
+(context: "STM"
   (do promise;Monad<Promise>
     [#let [_var (&;var 0)
            changes (io;run (&;follow _var))]
@@ -29,17 +29,17 @@
      ?c2+changes' changes'
      #let [[c2 changes'] (default [-1 changes] ?c2+changes')]]
     ($_ seq
-        (assert "Can read STM vars."
-                (i.= 0 output1))
+        (test "Can read STM vars."
+              (i.= 0 output1))
         
-        (assert "Can write STM vars."
-                (i.= 5 output2))
+        (test "Can write STM vars."
+              (i.= 5 output2))
         
-        (assert "Can update STM vars."
-                (i.= 15 output3))
+        (test "Can update STM vars."
+              (i.= 15 output3))
         
-        (assert "Can follow all the changes to STM vars."
-                (and (i.= 5 c1) (i.= 15 c2)))
+        (test "Can follow all the changes to STM vars."
+              (and (i.= 5 c1) (i.= 15 c2)))
 
         (let [_concurrency-var (&;var 0)]
           (do promise;Monad<Promise>
@@ -49,7 +49,7 @@
                                   (list;i.range 1 iterations/processes)))
                           (list;i.range 1 (nat-to-int promise;concurrency-level))))
              last-val (&;commit (&;read _concurrency-var))]
-            (assert "Can modify STM vars concurrently from multiple threads."
-                    (i.= (i.* iterations/processes (nat-to-int promise;concurrency-level))
-                         last-val))))
+            (test "Can modify STM vars concurrently from multiple threads."
+                  (i.= (i.* iterations/processes (nat-to-int promise;concurrency-level))
+                       last-val))))
         )))
diff --git a/stdlib/test/test/lux/control/cont.lux b/stdlib/test/test/lux/control/cont.lux
index 133629e45..b053e4d38 100644
--- a/stdlib/test/test/lux/control/cont.lux
+++ b/stdlib/test/test/lux/control/cont.lux
@@ -11,65 +11,65 @@
        ["R" math/random])
   lux/test)
 
-(test: "Continuations"
+(context: "Continuations"
   [sample R;nat
    #let [(^open "&/") &;Monad<Cont>]
    elems (R;list +3 R;nat)]
   ($_ seq
-      (assert "Can run continuations to compute their values."
-              (n.= sample (&;run (&/wrap sample))))
+      (test "Can run continuations to compute their values."
+            (n.= sample (&;run (&/wrap sample))))
 
-      (assert "Can use functor."
-              (n.= (n.inc sample) (&;run (&/map n.inc (&/wrap sample)))))
+      (test "Can use functor."
+            (n.= (n.inc sample) (&;run (&/map n.inc (&/wrap sample)))))
 
-      (assert "Can use applicative."
-              (n.= (n.inc sample) (&;run (&/apply (&/wrap n.inc) (&/wrap sample)))))
+      (test "Can use applicative."
+            (n.= (n.inc sample) (&;run (&/apply (&/wrap n.inc) (&/wrap sample)))))
 
-      (assert "Can use monad."
-              (n.= (n.inc sample) (&;run (do &;Monad<Cont>
-                                           [func (wrap n.inc)
-                                            arg (wrap sample)]
-                                           (wrap (func arg))))))
+      (test "Can use monad."
+            (n.= (n.inc sample) (&;run (do &;Monad<Cont>
+                                         [func (wrap n.inc)
+                                          arg (wrap sample)]
+                                         (wrap (func arg))))))
 
-      (assert "Can use the current-continuation as a escape hatch."
-              (n.= (n.* +2 sample)
-                   (&;run (do &;Monad<Cont>
-                            [value (&;call/cc
-                                    (function [k]
-                                      (do @
-                                        [temp (k sample)]
-                                        ## If this code where to run,
-                                        ## the output would be
-                                        ## (n.* +4 sample)
-                                        (k temp))))]
-                            (wrap (n.* +2 value))))))
+      (test "Can use the current-continuation as a escape hatch."
+            (n.= (n.* +2 sample)
+                 (&;run (do &;Monad<Cont>
+                          [value (&;call/cc
+                                  (function [k]
+                                    (do @
+                                      [temp (k sample)]
+                                      ## If this code where to run,
+                                      ## the output would be
+                                      ## (n.* +4 sample)
+                                      (k temp))))]
+                          (wrap (n.* +2 value))))))
 
-      (assert "Can use the current-continuation to build a time machine."
-              (n.= (n.+ +100 sample)
-                   (&;run (do &;Monad<Cont>
-                            [[restart [output idx]] (&;portal [sample +0])]
-                            (if (n.< +10 idx)
-                              (restart [(n.+ +10 output) (n.inc idx)])
-                              (wrap output))))))
+      (test "Can use the current-continuation to build a time machine."
+            (n.= (n.+ +100 sample)
+                 (&;run (do &;Monad<Cont>
+                          [[restart [output idx]] (&;portal [sample +0])]
+                          (if (n.< +10 idx)
+                            (restart [(n.+ +10 output) (n.inc idx)])
+                            (wrap output))))))
 
-      (assert "Can use delimited continuations with shifting."
-              (let [(^open "&/") &;Monad<Cont>
-                    (^open "L/") (list;Eq<List> number;Eq<Nat>)
-                    visit (: (-> (List Nat)
-                                 (&;Cont (List Nat) (List Nat)))
-                             (function visit [xs]
-                               (case xs
-                                 #;Nil
-                                 (&/wrap #;Nil)
+      (test "Can use delimited continuations with shifting."
+            (let [(^open "&/") &;Monad<Cont>
+                  (^open "L/") (list;Eq<List> number;Eq<Nat>)
+                  visit (: (-> (List Nat)
+                               (&;Cont (List Nat) (List Nat)))
+                           (function visit [xs]
+                             (case xs
+                               #;Nil
+                               (&/wrap #;Nil)
 
-                                 (#;Cons x xs')
-                                 (do &;Monad<Cont>
-                                   [output (&;shift (function [k]
-                                                      (do @
-                                                        [tail (k xs')]
-                                                        (wrap (#;Cons x tail)))))]
-                                   (visit output)))))]
-                (L/= elems
-                     (&;run (&;reset (visit elems))))
-                ))
+                               (#;Cons x xs')
+                               (do &;Monad<Cont>
+                                 [output (&;shift (function [k]
+                                                    (do @
+                                                      [tail (k xs')]
+                                                      (wrap (#;Cons x tail)))))]
+                                 (visit output)))))]
+              (L/= elems
+                   (&;run (&;reset (visit elems))))
+              ))
       ))
diff --git a/stdlib/test/test/lux/control/effect.lux b/stdlib/test/test/lux/control/effect.lux
index abbdca56a..65a7646ca 100644
--- a/stdlib/test/test/lux/control/effect.lux
+++ b/stdlib/test/test/lux/control/effect.lux
@@ -45,7 +45,7 @@
       Handler<EffA,IO> Handler<EffB,IO> Handler<EffC,IO>))
 
 ## [Tests]
-(test: "Algebraic effects"
+(context: "Algebraic effects"
   (with-expansions
     [<single-effect-tests> (do-template [<op> <op-size> <field> <field-value>]
                              [(io;run (with-handler Handler<EffABC,IO>
@@ -60,13 +60,13 @@
                              [opA +10 fieldA +10]
                              [opB +4  fieldB +20]
                              [opC +2  fieldC +30])]
-    (assert "Can handle effects using handlers."
-            (and <single-effect-tests>
+    (test "Can handle effects using handlers."
+          (and <single-effect-tests>
 
-                 (n.= +60 (io;run (with-handler Handler<EffABC,IO>
-                                    (doE Functor<EffABC>
-                                      [a (lift fieldA)
-                                       b (lift fieldB)
-                                       c (lift fieldC)]
-                                      (wrap ($_ n.+ a b c))))))
-                 ))))
+               (n.= +60 (io;run (with-handler Handler<EffABC,IO>
+                                  (doE Functor<EffABC>
+                                    [a (lift fieldA)
+                                     b (lift fieldB)
+                                     c (lift fieldC)]
+                                    (wrap ($_ n.+ a b c))))))
+               ))))
diff --git a/stdlib/test/test/lux/control/exception.lux b/stdlib/test/test/lux/control/exception.lux
index bef3ae4cd..d8c4ff9c2 100644
--- a/stdlib/test/test/lux/control/exception.lux
+++ b/stdlib/test/test/lux/control/exception.lux
@@ -16,7 +16,7 @@
 
 (exception: Unknown-Exception)
 
-(test: "Exceptions"
+(context: "Exceptions"
   [should-throw? R;bool
    which? R;bool
    should-catch? R;bool
@@ -43,5 +43,5 @@
                     (&;catch Some-Exception (function [ex] some-val))
                     (&;catch Another-Exception (function [ex] another-val))
                     (&;otherwise (function [ex] otherwise-val)))]]
-  (assert "Catch and otherwhise handlers can properly handle the flow of exception-handling."
-          (n.= expected actual)))
+  (test "Catch and otherwhise handlers can properly handle the flow of exception-handling."
+        (n.= expected actual)))
diff --git a/stdlib/test/test/lux/control/interval.lux b/stdlib/test/test/lux/control/interval.lux
index b4c48a541..79ec0ed5e 100644
--- a/stdlib/test/test/lux/control/interval.lux
+++ b/stdlib/test/test/lux/control/interval.lux
@@ -11,34 +11,34 @@
              ["S" coll/set]
              ["L" coll/list])))
 
-(test: "Equality."
+(context: "Equality."
   [bottom R;int
    top R;int
    #let [(^open "&/") &;Eq<Interval>]]
   ($_ seq
-      (assert "Every interval is equal to itself."
-              (and (let [self (&;between number;Enum<Int> bottom top)]
-                     (&/= self self))
-                   (let [self (&;between number;Enum<Int> top bottom)]
-                     (&/= self self))
-                   (let [self (&;singleton number;Enum<Int> bottom)]
-                     (&/= self self))))))
-
-(test: "Boundaries"
+      (test "Every interval is equal to itself."
+            (and (let [self (&;between number;Enum<Int> bottom top)]
+                   (&/= self self))
+                 (let [self (&;between number;Enum<Int> top bottom)]
+                   (&/= self self))
+                 (let [self (&;singleton number;Enum<Int> bottom)]
+                   (&/= self self))))))
+
+(context: "Boundaries"
   [bottom R;int
    top R;int
    #let [interval (&;between number;Enum<Int> bottom top)]]
   ($_ seq
-      (assert "Every boundary value belongs to it's interval."
-              (and (&;within? interval bottom)
-                   (&;within? interval top)))
-      (assert "Every interval starts with its bottom."
-              (&;starts-with? bottom interval))
-      (assert "Every interval ends with its top."
-              (&;ends-with? top interval))
-      (assert "The boundary values border the interval."
-              (and (&;borders? interval bottom)
-                   (&;borders? interval top)))
+      (test "Every boundary value belongs to it's interval."
+            (and (&;within? interval bottom)
+                 (&;within? interval top)))
+      (test "Every interval starts with its bottom."
+            (&;starts-with? bottom interval))
+      (test "Every interval ends with its top."
+            (&;ends-with? top interval))
+      (test "The boundary values border the interval."
+            (and (&;borders? interval bottom)
+                 (&;borders? interval top)))
       ))
 
 (def: (list-to-4tuple list)
@@ -78,7 +78,7 @@
       gen-outer
       gen-singleton))
 
-(test: "Unions"
+(context: "Unions"
   [some-interval gen-interval
    left-inner gen-inner
    right-inner gen-inner
@@ -88,17 +88,17 @@
    right-outer gen-outer
    #let [(^open "&/") &;Eq<Interval>]]
   ($_ seq
-      (assert "The union of an interval to itself yields the same interval."
-              (&/= some-interval (&;union some-interval some-interval)))
-      (assert "The union of 2 inner intervals is another inner interval."
-              (&;inner? (&;union left-inner right-inner)))
-      (assert "The union of 2 outer intervals yields an inner interval when their complements don't overlap, and an outer when they do."
-              (if (&;overlaps? (&;complement left-outer) (&;complement right-outer))
-                (&;outer? (&;union left-outer right-outer))
-                (&;inner? (&;union left-outer right-outer))))
+      (test "The union of an interval to itself yields the same interval."
+            (&/= some-interval (&;union some-interval some-interval)))
+      (test "The union of 2 inner intervals is another inner interval."
+            (&;inner? (&;union left-inner right-inner)))
+      (test "The union of 2 outer intervals yields an inner interval when their complements don't overlap, and an outer when they do."
+            (if (&;overlaps? (&;complement left-outer) (&;complement right-outer))
+              (&;outer? (&;union left-outer right-outer))
+              (&;inner? (&;union left-outer right-outer))))
       ))
 
-(test: "Intersections"
+(context: "Intersections"
   [some-interval gen-interval
    left-inner gen-inner
    right-inner gen-inner
@@ -108,27 +108,27 @@
    right-outer gen-outer
    #let [(^open "&/") &;Eq<Interval>]]
   ($_ seq
-      (assert "The intersection of an interval to itself yields the same interval."
-              (&/= some-interval (&;intersection some-interval some-interval)))
-      (assert "The intersection of 2 inner intervals yields an inner interval when they overlap, and an outer when they don't."
-              (if (&;overlaps? left-inner right-inner)
-                (&;inner? (&;intersection left-inner right-inner))
-                (&;outer? (&;intersection left-inner right-inner))))
-      (assert "The intersection of 2 outer intervals is another outer interval."
-              (&;outer? (&;intersection left-outer right-outer)))
+      (test "The intersection of an interval to itself yields the same interval."
+            (&/= some-interval (&;intersection some-interval some-interval)))
+      (test "The intersection of 2 inner intervals yields an inner interval when they overlap, and an outer when they don't."
+            (if (&;overlaps? left-inner right-inner)
+              (&;inner? (&;intersection left-inner right-inner))
+              (&;outer? (&;intersection left-inner right-inner))))
+      (test "The intersection of 2 outer intervals is another outer interval."
+            (&;outer? (&;intersection left-outer right-outer)))
       ))
 
-(test: "Complement"
+(context: "Complement"
   [some-interval gen-interval
    #let [(^open "&/") &;Eq<Interval>]]
   ($_ seq
-      (assert "The complement of a complement is the same as the original."
-              (&/= some-interval (|> some-interval &;complement &;complement)))
-      (assert "The complement of an interval does not overlap it."
-              (not (&;overlaps? some-interval (&;complement some-interval))))
+      (test "The complement of a complement is the same as the original."
+            (&/= some-interval (|> some-interval &;complement &;complement)))
+      (test "The complement of an interval does not overlap it."
+            (not (&;overlaps? some-interval (&;complement some-interval))))
       ))
 
-(test: "Positioning/location"
+(context: "Positioning/location"
   [[l m r] (|> (R;set number;Hash<Int> +3 R;int)
                (:: @ map (|>. S;to-list
                               (L;sort i.<)
@@ -140,15 +140,15 @@
    #let [left (&;singleton number;Enum<Int> l)
          right (&;singleton number;Enum<Int> r)]]
   ($_ seq
-      (assert "'precedes?' and 'succeeds?' are symetric."
-              (and (&;precedes? right left)
-                   (&;succeeds? left right)))
-      (assert "Can check if an interval is before or after some element."
-              (and (&;before? m left)
-                   (&;after? m right)))
+      (test "'precedes?' and 'succeeds?' are symetric."
+            (and (&;precedes? right left)
+                 (&;succeeds? left right)))
+      (test "Can check if an interval is before or after some element."
+            (and (&;before? m left)
+                 (&;after? m right)))
       ))
 
-(test: "Touching intervals"
+(context: "Touching intervals"
   [[b t1 t2] (|> (R;set number;Hash<Int> +3 R;int)
                  (:: @ map (|>. S;to-list
                                 (L;sort i.<)
@@ -160,19 +160,19 @@
    #let [int-left (&;between number;Enum<Int> t1 t2)
          int-right (&;between number;Enum<Int> b t1)]]
   ($_ seq
-      (assert "An interval meets another if it's top is the other's bottom."
-              (&;meets? int-left int-right))
-      (assert "Two intervals touch one another if any one meets the other."
-              (&;touches? int-left int-right))
-      (assert "Can check if 2 intervals start together."
-              (&;starts? (&;between number;Enum<Int> b t2)
-                         (&;between number;Enum<Int> b t1)))
-      (assert "Can check if 2 intervals finish together."
-              (&;finishes? (&;between number;Enum<Int> b t2)
-                           (&;between number;Enum<Int> t1 t2)))
+      (test "An interval meets another if it's top is the other's bottom."
+            (&;meets? int-left int-right))
+      (test "Two intervals touch one another if any one meets the other."
+            (&;touches? int-left int-right))
+      (test "Can check if 2 intervals start together."
+            (&;starts? (&;between number;Enum<Int> b t2)
+                       (&;between number;Enum<Int> b t1)))
+      (test "Can check if 2 intervals finish together."
+            (&;finishes? (&;between number;Enum<Int> b t2)
+                         (&;between number;Enum<Int> t1 t2)))
       ))
 
-(test: "Nesting & overlap"
+(context: "Nesting & overlap"
   [some-interval gen-interval
    [x0 x1 x2 x3] (|> (R;set number;Hash<Int> +4 R;int)
                      (:: @ map (|>. S;to-list
@@ -183,35 +183,35 @@
                                            _
                                            (undefined)))))]
   ($_ seq
-      (assert "Every interval is nested into itself."
-              (&;nested? some-interval some-interval))
-      (assert "No interval overlaps with itself."
-              (not (&;overlaps? some-interval some-interval)))
+      (test "Every interval is nested into itself."
+            (&;nested? some-interval some-interval))
+      (test "No interval overlaps with itself."
+            (not (&;overlaps? some-interval some-interval)))
       (let [small-inner (&;between number;Enum<Int> x1 x2)
             large-inner (&;between number;Enum<Int> x0 x3)]
-        (assert "Inner intervals can be nested inside one another."
-                (and (&;nested? large-inner small-inner)
-                     (not (&;nested? small-inner large-inner)))))
+        (test "Inner intervals can be nested inside one another."
+              (and (&;nested? large-inner small-inner)
+                   (not (&;nested? small-inner large-inner)))))
       (let [left-inner (&;between number;Enum<Int> x0 x2)
             right-inner (&;between number;Enum<Int> x1 x3)]
-        (assert "Inner intervals can overlap one another."
-                (and (&;overlaps? left-inner right-inner)
-                     (&;overlaps? right-inner left-inner))))
+        (test "Inner intervals can overlap one another."
+              (and (&;overlaps? left-inner right-inner)
+                   (&;overlaps? right-inner left-inner))))
       (let [small-outer (&;between number;Enum<Int> x2 x1)
             large-outer (&;between number;Enum<Int> x3 x0)]
-        (assert "Outer intervals can be nested inside one another."
-                (and (&;nested? small-outer large-outer)
-                     (not (&;nested? large-outer small-outer)))))
+        (test "Outer intervals can be nested inside one another."
+              (and (&;nested? small-outer large-outer)
+                   (not (&;nested? large-outer small-outer)))))
       (let [left-inner (&;between number;Enum<Int> x0 x1)
             right-inner (&;between number;Enum<Int> x2 x3)
             outer (&;between number;Enum<Int> x0 x3)]
-        (assert "Inners can be nested inside outers."
-                (and (&;nested? outer left-inner)
-                     (&;nested? outer right-inner))))
+        (test "Inners can be nested inside outers."
+              (and (&;nested? outer left-inner)
+                   (&;nested? outer right-inner))))
       (let [left-inner (&;between number;Enum<Int> x0 x2)
             right-inner (&;between number;Enum<Int> x1 x3)
             outer (&;between number;Enum<Int> x1 x2)]
-        (assert "Inners can overlap outers."
-                (and (&;overlaps? outer left-inner)
-                     (&;overlaps? outer right-inner))))
+        (test "Inners can overlap outers."
+              (and (&;overlaps? outer left-inner)
+                   (&;overlaps? outer right-inner))))
       ))
diff --git a/stdlib/test/test/lux/control/pipe.lux b/stdlib/test/test/lux/control/pipe.lux
index 4687a5635..ca80e8c1b 100644
--- a/stdlib/test/test/lux/control/pipe.lux
+++ b/stdlib/test/test/lux/control/pipe.lux
@@ -11,64 +11,64 @@
        ["R" math/random])
   lux/test)
 
-(test: "Pipes"
+(context: "Pipes"
   ($_ seq
-      (assert "Can dismiss previous pipeline results and begin a new line."
-              (|> 20
-                  (i.* 3)
-                  (i.+ 4)
-                  (_> 0 i.inc)
-                  (i.= 1)))
+      (test "Can dismiss previous pipeline results and begin a new line."
+            (|> 20
+                (i.* 3)
+                (i.+ 4)
+                (_> 0 i.inc)
+                (i.= 1)))
       
-      (assert "Can give names to piped values within a pipeline's scope."
-              (and (|> 5
-                       (@> [(i.+ @ @)])
-                       (i.= 10))
-                   (|> 5
-                       (@> X [(i.+ X X)])
-                       (i.= 10))))
+      (test "Can give names to piped values within a pipeline's scope."
+            (and (|> 5
+                     (@> [(i.+ @ @)])
+                     (i.= 10))
+                 (|> 5
+                     (@> X [(i.+ X X)])
+                     (i.= 10))))
       
-      (assert "Can do branching in pipelines."
-              (and (|> 5
-                       (?> [i.even?] [(i.* 2)]
-                           [i.odd?] [(i.* 3)]
-                           [(_> -1)])
-                       (i.= 15))
-                   (|> 4
-                       (?> [i.even?] [(i.* 2)]
-                           [i.odd?] [(i.* 3)])
-                       (i.= 8))
-                   (|> 5
-                       (?> [i.even?] [(i.* 2)]
-                           [(_> -1)])
-                       (i.= -1))))
+      (test "Can do branching in pipelines."
+            (and (|> 5
+                     (?> [i.even?] [(i.* 2)]
+                         [i.odd?] [(i.* 3)]
+                         [(_> -1)])
+                     (i.= 15))
+                 (|> 4
+                     (?> [i.even?] [(i.* 2)]
+                         [i.odd?] [(i.* 3)])
+                     (i.= 8))
+                 (|> 5
+                     (?> [i.even?] [(i.* 2)]
+                         [(_> -1)])
+                     (i.= -1))))
 
-      (assert "Can loop within pipelines."
-              (|> 1
-                  (!> [(i.< 10)]
-                      [i.inc])
-                  (i.= 10)))
+      (test "Can loop within pipelines."
+            (|> 1
+                (!> [(i.< 10)]
+                    [i.inc])
+                (i.= 10)))
       
-      (assert "Can use monads within pipelines."
-              (|> 5
-                  (%> Monad<Identity>
-                      [(i.* 3)]
-                      [(i.+ 4)]
-                      [i.inc])
-                  (i.= 20)))
+      (test "Can use monads within pipelines."
+            (|> 5
+                (%> Monad<Identity>
+                    [(i.* 3)]
+                    [(i.+ 4)]
+                    [i.inc])
+                (i.= 20)))
       
-      (assert "Can pattern-match against piped values."
-              (|> 5
-                  (case> 0 "zero"
-                         1 "one"
-                         2 "two"
-                         3 "three"
-                         4 "four"
-                         5 "five"
-                         6 "six"
-                         7 "seven"
-                         8 "eight"
-                         9 "nine"
-                         _ "???")
-                  (T/= "five")))
+      (test "Can pattern-match against piped values."
+            (|> 5
+                (case> 0 "zero"
+                       1 "one"
+                       2 "two"
+                       3 "three"
+                       4 "four"
+                       5 "five"
+                       6 "six"
+                       7 "seven"
+                       8 "eight"
+                       9 "nine"
+                       _ "???")
+                (T/= "five")))
       ))
diff --git a/stdlib/test/test/lux/control/reader.lux b/stdlib/test/test/lux/control/reader.lux
index 85b5edf8b..f7aa8630f 100644
--- a/stdlib/test/test/lux/control/reader.lux
+++ b/stdlib/test/test/lux/control/reader.lux
@@ -9,29 +9,29 @@
              [number]))
   lux/test)
 
-(test: "Readers"
+(context: "Readers"
   ($_ seq
-      (assert "" (i.= 123 (&;run 123 &;ask)))
-      (assert "" (i.= 246 (&;run 123 (&;local (i.* 2) &;ask))))
-      (assert "" (i.= 134 (&;run 123 (:: &;Functor<Reader> map i.inc (i.+ 10)))))
-      (assert "" (i.= 10 (&;run 123 (:: &;Applicative<Reader> wrap 10))))
-      (assert "" (i.= 30 (&;run 123 (let [(^open "&/") &;Applicative<Reader>]
-                                      (&/apply (&/wrap (i.+ 10)) (&/wrap 20))))))
-      (assert "" (i.= 30 (&;run 123 (do &;Monad<Reader>
-                                      [f (wrap i.+)
-                                       x (wrap 10)
-                                       y (wrap 20)]
-                                      (wrap (f x y))))))))
+      (test "" (i.= 123 (&;run 123 &;ask)))
+      (test "" (i.= 246 (&;run 123 (&;local (i.* 2) &;ask))))
+      (test "" (i.= 134 (&;run 123 (:: &;Functor<Reader> map i.inc (i.+ 10)))))
+      (test "" (i.= 10 (&;run 123 (:: &;Applicative<Reader> wrap 10))))
+      (test "" (i.= 30 (&;run 123 (let [(^open "&/") &;Applicative<Reader>]
+                                    (&/apply (&/wrap (i.+ 10)) (&/wrap 20))))))
+      (test "" (i.= 30 (&;run 123 (do &;Monad<Reader>
+                                    [f (wrap i.+)
+                                     x (wrap 10)
+                                     y (wrap 20)]
+                                    (wrap (f x y))))))))
 
-(test: "Monad transformer"
+(context: "Monad transformer"
   (let [(^open "io/") io;Monad<IO>]
-    (assert "Can add reader functionality to any monad."
-            (|> (do (&;ReaderT io;Monad<IO>)
-                  [a (&;lift-reader (io/wrap 123))
-                   b (wrap 456)]
-                  (wrap (i.+ a b)))
-                (&;run "")
-                io;run
-                (case> 579 true
-                       _   false)))
+    (test "Can add reader functionality to any monad."
+          (|> (do (&;ReaderT io;Monad<IO>)
+                [a (&;lift-reader (io/wrap 123))
+                 b (wrap 456)]
+                (wrap (i.+ a b)))
+              (&;run "")
+              io;run
+              (case> 579 true
+                     _   false)))
     ))
diff --git a/stdlib/test/test/lux/control/state.lux b/stdlib/test/test/lux/control/state.lux
index de1560f48..d789010ea 100644
--- a/stdlib/test/test/lux/control/state.lux
+++ b/stdlib/test/test/lux/control/state.lux
@@ -18,91 +18,91 @@
       product;right
       (n.= output)))
 
-(test: "Basics"
+(context: "Basics"
   [state R;nat
    value R;nat]
   ($_ seq
-      (assert "Can get the state as a value."
-              (with-conditions [state state]
-                &;get))
-      (assert "Can replace the state."
-              (with-conditions [state value]
-                (do &;Monad<State>
-                  [_ (&;put value)]
-                  &;get)))
-      (assert "Can update the state."
-              (with-conditions [state (n.* value state)]
-                (do &;Monad<State>
-                  [_ (&;update (n.* value))]
-                  &;get)))
-      (assert "Can use the state."
-              (with-conditions [state (n.inc state)]
-                (&;use n.inc)))
-      (assert "Can use a temporary (local) state."
-              (with-conditions [state (n.* value state)]
-                (&;local (n.* value)
-                         &;get)))
+      (test "Can get the state as a value."
+            (with-conditions [state state]
+              &;get))
+      (test "Can replace the state."
+            (with-conditions [state value]
+              (do &;Monad<State>
+                [_ (&;put value)]
+                &;get)))
+      (test "Can update the state."
+            (with-conditions [state (n.* value state)]
+              (do &;Monad<State>
+                [_ (&;update (n.* value))]
+                &;get)))
+      (test "Can use the state."
+            (with-conditions [state (n.inc state)]
+              (&;use n.inc)))
+      (test "Can use a temporary (local) state."
+            (with-conditions [state (n.* value state)]
+              (&;local (n.* value)
+                       &;get)))
       ))
 
-(test: "Structures"
+(context: "Structures"
   [state R;nat
    value R;nat]
   ($_ seq
-      (assert "Can use functor."
-              (with-conditions [state (n.inc state)]
-                (:: &;Functor<State> map n.inc &;get)))
-      (assert "Can use applicative."
-              (let [(^open "&/") &;Applicative<State>]
-                (and (with-conditions [state value]
-                       (&/wrap value))
-                     (with-conditions [state (n.+ value value)]
-                       (&/apply (&/wrap (n.+ value))
-                                (&/wrap value))))))
-      (assert "Can use monad."
-              (with-conditions [state (n.+ value value)]
-                (: (&;State Nat Nat)
-                   (do &;Monad<State>
-                     [f (wrap n.+)
-                      x (wrap value)
-                      y (wrap value)]
-                     (wrap (f x y))))))
+      (test "Can use functor."
+            (with-conditions [state (n.inc state)]
+              (:: &;Functor<State> map n.inc &;get)))
+      (test "Can use applicative."
+            (let [(^open "&/") &;Applicative<State>]
+              (and (with-conditions [state value]
+                     (&/wrap value))
+                   (with-conditions [state (n.+ value value)]
+                     (&/apply (&/wrap (n.+ value))
+                              (&/wrap value))))))
+      (test "Can use monad."
+            (with-conditions [state (n.+ value value)]
+              (: (&;State Nat Nat)
+                 (do &;Monad<State>
+                   [f (wrap n.+)
+                    x (wrap value)
+                    y (wrap value)]
+                   (wrap (f x y))))))
       ))
 
-(test: "Monad transformer"
+(context: "Monad transformer"
   [state R;nat
    left R;nat
    right R;nat]
   (let [lift (&;lift-state io;Monad<IO>)
         (^open "io/") io;Monad<IO>]
-    (assert "Can add state functionality to any monad."
-            (|> (: (&;State' io;IO Nat Nat)
-                   (do (&;StateT io;Monad<IO>)
-                     [a (lift (io/wrap left))
-                      b (wrap right)]
-                     (wrap (n.+ a b))))
-                (&;run' state)
-                io;run
-                (case> [state' output']
-                       (and (n.= state state')
-                            (n.= (n.+ left right) output')))))
+    (test "Can add state functionality to any monad."
+          (|> (: (&;State' io;IO Nat Nat)
+                 (do (&;StateT io;Monad<IO>)
+                   [a (lift (io/wrap left))
+                    b (wrap right)]
+                   (wrap (n.+ a b))))
+              (&;run' state)
+              io;run
+              (case> [state' output']
+                     (and (n.= state state')
+                          (n.= (n.+ left right) output')))))
     ))
 
-(test: "Loops"
+(context: "Loops"
   [limit (|> R;nat (:: @ map (n.% +10)))
    #let [condition (do &;Monad<State>
                      [state &;get]
                      (wrap (n.< limit state)))]]
   ($_ seq
-      (assert "'while' will only execute if the condition is true."
-              (|> (&;while condition (&;update n.inc))
-                  (&;run +0)
-                  (case> [state' output']
-                         (n.= limit state'))))
-      (assert "'do-while' will execute at least once."
-              (|> (&;do-while condition (&;update n.inc))
-                  (&;run +0)
-                  (case> [state' output']
-                         (or (n.= limit state')
-                             (and (n.= +0 limit)
-                                  (n.= +1 state'))))))
+      (test "'while' will only execute if the condition is true."
+            (|> (&;while condition (&;update n.inc))
+                (&;run +0)
+                (case> [state' output']
+                       (n.= limit state'))))
+      (test "'do-while' will execute at least once."
+            (|> (&;do-while condition (&;update n.inc))
+                (&;run +0)
+                (case> [state' output']
+                       (or (n.= limit state')
+                           (and (n.= +0 limit)
+                                (n.= +1 state'))))))
       ))
diff --git a/stdlib/test/test/lux/control/thunk.lux b/stdlib/test/test/lux/control/thunk.lux
index cc8ca653d..506c675a1 100644
--- a/stdlib/test/test/lux/control/thunk.lux
+++ b/stdlib/test/test/lux/control/thunk.lux
@@ -6,18 +6,18 @@
        ["R" math/random])
   lux/test)
 
-(test: "Thunks"
+(context: "Thunks"
   [left R;nat
    right R;nat
    #let [thunk (&;freeze (n.* left right))
          expected (n.* left right)]]
   ($_ seq
-      (assert "Thunking does not alter the expected value."
-              (n.= expected
-                   (&;thaw thunk)))
-      (assert "Thunks only evaluate once."
-              (and (not (is expected
-                            (&;thaw thunk)))
-                   (is (&;thaw thunk)
-                       (&;thaw thunk))))
+      (test "Thunking does not alter the expected value."
+            (n.= expected
+                 (&;thaw thunk)))
+      (test "Thunks only evaluate once."
+            (and (not (is expected
+                          (&;thaw thunk)))
+                 (is (&;thaw thunk)
+                     (&;thaw thunk))))
       ))
diff --git a/stdlib/test/test/lux/data/bit.lux b/stdlib/test/test/lux/data/bit.lux
index fe04806cd..789eaa88f 100644
--- a/stdlib/test/test/lux/data/bit.lux
+++ b/stdlib/test/test/lux/data/bit.lux
@@ -7,63 +7,63 @@
        ["R" math/random])
   lux/test)
 
-(test: "Bitwise operations."
+(context: "Bitwise operations."
   [pattern R;nat
    idx (:: @ map (n.% &;width) R;nat)]
   ($_ seq
-      (assert "Clearing and settings bits should alter the count."
-              (and (n.< (&;count (&;set idx pattern))
-                        (&;count (&;clear idx pattern)))
-                   (n.<= (&;count pattern)
-                         (&;count (&;clear idx pattern)))
-                   (n.>= (&;count pattern)
-                         (&;count (&;set idx pattern)))))
-      (assert "Can query whether a bit is set."
-              (and (or (and (&;set? idx pattern)
-                            (not (&;set? idx (&;clear idx pattern))))
-                       (and (not (&;set? idx pattern))
-                            (&;set? idx (&;set idx pattern))))
+      (test "Clearing and settings bits should alter the count."
+            (and (n.< (&;count (&;set idx pattern))
+                      (&;count (&;clear idx pattern)))
+                 (n.<= (&;count pattern)
+                       (&;count (&;clear idx pattern)))
+                 (n.>= (&;count pattern)
+                       (&;count (&;set idx pattern)))))
+      (test "Can query whether a bit is set."
+            (and (or (and (&;set? idx pattern)
+                          (not (&;set? idx (&;clear idx pattern))))
+                     (and (not (&;set? idx pattern))
+                          (&;set? idx (&;set idx pattern))))
 
-                   (or (and (&;set? idx pattern)
-                            (not (&;set? idx (&;flip idx pattern))))
-                       (and (not (&;set? idx pattern))
-                            (&;set? idx (&;flip idx pattern))))))
-      (assert "The negation of a bit pattern should have a complementary bit count."
-              (n.= &;width
-                   (n.+ (&;count pattern)
-                        (&;count (&;not pattern)))))
-      (assert "Can do simple binary boolean logic."
-              (and (n.= +0
-                        (&;and pattern
-                               (&;not pattern)))
-                   (n.= (&;not +0)
-                        (&;or pattern
-                              (&;not pattern)))
-                   (n.= (&;not +0)
-                        (&;xor pattern
-                               (&;not pattern)))
-                   (n.= +0
-                        (&;xor pattern
-                               pattern))))
-      (assert "rotate-left and rotate-right are inverses of one another."
-              (and (|> pattern
-                       (&;rotate-left idx)
-                       (&;rotate-right idx)
-                       (n.= pattern))
-                   (|> pattern
-                       (&;rotate-right idx)
-                       (&;rotate-left idx)
-                       (n.= pattern))))
-      (assert "Rotate as many spaces as the bit-pattern's width leaves the pattern unchanged."
-              (and (|> pattern
-                       (&;rotate-left &;width)
-                       (n.= pattern))
-                   (|> pattern
-                       (&;rotate-right &;width)
-                       (n.= pattern))))
-      (assert "Shift right respect the sign of ints."
-              (let [value (nat-to-int pattern)]
-                (if (i.< 0 value)
-                  (i.< 0 (&;shift-right idx value))
-                  (i.>= 0 (&;shift-right idx value)))))
+                 (or (and (&;set? idx pattern)
+                          (not (&;set? idx (&;flip idx pattern))))
+                     (and (not (&;set? idx pattern))
+                          (&;set? idx (&;flip idx pattern))))))
+      (test "The negation of a bit pattern should have a complementary bit count."
+            (n.= &;width
+                 (n.+ (&;count pattern)
+                      (&;count (&;not pattern)))))
+      (test "Can do simple binary boolean logic."
+            (and (n.= +0
+                      (&;and pattern
+                             (&;not pattern)))
+                 (n.= (&;not +0)
+                      (&;or pattern
+                            (&;not pattern)))
+                 (n.= (&;not +0)
+                      (&;xor pattern
+                             (&;not pattern)))
+                 (n.= +0
+                      (&;xor pattern
+                             pattern))))
+      (test "rotate-left and rotate-right are inverses of one another."
+            (and (|> pattern
+                     (&;rotate-left idx)
+                     (&;rotate-right idx)
+                     (n.= pattern))
+                 (|> pattern
+                     (&;rotate-right idx)
+                     (&;rotate-left idx)
+                     (n.= pattern))))
+      (test "Rotate as many spaces as the bit-pattern's width leaves the pattern unchanged."
+            (and (|> pattern
+                     (&;rotate-left &;width)
+                     (n.= pattern))
+                 (|> pattern
+                     (&;rotate-right &;width)
+                     (n.= pattern))))
+      (test "Shift right respect the sign of ints."
+            (let [value (nat-to-int pattern)]
+              (if (i.< 0 value)
+                (i.< 0 (&;shift-right idx value))
+                (i.>= 0 (&;shift-right idx value)))))
       ))
diff --git a/stdlib/test/test/lux/data/bool.lux b/stdlib/test/test/lux/data/bool.lux
index 51e499779..13203a5a3 100644
--- a/stdlib/test/test/lux/data/bool.lux
+++ b/stdlib/test/test/lux/data/bool.lux
@@ -6,28 +6,28 @@
        ["R" math/random])
   lux/test)
 
-(test: "Boolean operations."
+(context: "Boolean operations."
   [value R;bool]
-  (assert "" (and (not (and value (not value)))
-                  (or value (not value))
+  (test "" (and (not (and value (not value)))
+                (or value (not value))
 
-                  (not (:: Or@Monoid<Bool> unit))
-                  (:: Or@Monoid<Bool> append value (not value))
-                  (:: And@Monoid<Bool> unit)
-                  (not (:: And@Monoid<Bool> append value (not value)))
-                  
-                  (:: Eq<Bool> = value (not (not value)))
-                  (not (:: Eq<Bool> = value (not value)))
+                (not (:: Or@Monoid<Bool> unit))
+                (:: Or@Monoid<Bool> append value (not value))
+                (:: And@Monoid<Bool> unit)
+                (not (:: And@Monoid<Bool> append value (not value)))
+                
+                (:: Eq<Bool> = value (not (not value)))
+                (not (:: Eq<Bool> = value (not value)))
 
-                  (not (:: Eq<Bool> = value ((complement id) value)))
-                  (:: Eq<Bool> = value ((complement not) value))
+                (not (:: Eq<Bool> = value ((complement id) value)))
+                (:: Eq<Bool> = value ((complement not) value))
 
-                  (case (|> value
-                            (:: Codec<Text,Bool> encode)
-                            (:: Codec<Text,Bool> decode))
-                    (#;Right dec-value)
-                    (:: Eq<Bool> = value dec-value)
+                (case (|> value
+                          (:: Codec<Text,Bool> encode)
+                          (:: Codec<Text,Bool> decode))
+                  (#;Right dec-value)
+                  (:: Eq<Bool> = value dec-value)
 
-                    (#;Left _)
-                    false)
-                  )))
+                  (#;Left _)
+                  false)
+                )))
diff --git a/stdlib/test/test/lux/data/char.lux b/stdlib/test/test/lux/data/char.lux
index dd3c0c2da..e0f790905 100644
--- a/stdlib/test/test/lux/data/char.lux
+++ b/stdlib/test/test/lux/data/char.lux
@@ -9,40 +9,40 @@
        ["R" math/random])
   lux/test)
 
-(test: "Char operations"
+(context: "Char operations"
   [value R;char
    other R;char]
   ($_ seq
-      (assert "Can compare characterss for equality."
-              (:: Eq<Char> = value value))
+      (test "Can compare characterss for equality."
+            (:: Eq<Char> = value value))
 
-      (assert "Can go back-and-forth into numeric codes."
-              (|> value code char (:: Eq<Char> = value)))
+      (test "Can go back-and-forth into numeric codes."
+            (|> value code char (:: Eq<Char> = value)))
 
-      (assert "Can encode/decode as text."
-              (and (|> value
-                       (:: Codec<Text,Char> encode)
-                       (:: Codec<Text,Char> decode)
-                       (case> (#;Right dec-value)
-                              (:: Eq<Char> = value dec-value)
+      (test "Can encode/decode as text."
+            (and (|> value
+                     (:: Codec<Text,Char> encode)
+                     (:: Codec<Text,Char> decode)
+                     (case> (#;Right dec-value)
+                            (:: Eq<Char> = value dec-value)
 
-                              (#;Left _)
-                              false))
-                   (|> value as-text
-                       (text;nth +0) (default (undefined))
-                       (:: Eq<Char> = value))))
+                            (#;Left _)
+                            false))
+                 (|> value as-text
+                     (text;nth +0) (default (undefined))
+                     (:: Eq<Char> = value))))
 
-      (assert "Characters have an ordering relationship."
-              (if (:: Order<Char> < other value)
-                (:: Order<Char> > value other)
-                (:: Order<Char> >= other value)))
+      (test "Characters have an ordering relationship."
+            (if (:: Order<Char> < other value)
+              (:: Order<Char> > value other)
+              (:: Order<Char> >= other value)))
       ))
 
-(test: "Special cases"
-  (assert "Can test whether a char is white-space."
-          (and (space? #" ")
-               (space? #"\n")
-               (space? #"\t")
-               (space? #"\r")
-               (space? #"\f")
-               (not (space? #"a")))))
+(context: "Special cases"
+  (test "Can test whether a char is white-space."
+        (and (space? #" ")
+             (space? #"\n")
+             (space? #"\t")
+             (space? #"\r")
+             (space? #"\f")
+             (not (space? #"a")))))
diff --git a/stdlib/test/test/lux/data/coll/array.lux b/stdlib/test/test/lux/data/coll/array.lux
index 6006cf021..97ecedadb 100644
--- a/stdlib/test/test/lux/data/coll/array.lux
+++ b/stdlib/test/test/lux/data/coll/array.lux
@@ -14,7 +14,7 @@
   (|> R;nat
       (:: R;Monad<Random> map (|>. (n.% +100) (n.+ +1)))))
 
-(test: "Arrays and their copies"
+(context: "Arrays and their copies"
   [size bounded-size
    original (R;array size R;nat)
    #let [clone (&;clone original)
@@ -23,30 +23,30 @@
          manual-copy (: (&;Array Nat)
                         (&;new size))]]
   ($_ seq
-      (assert "Size function must correctly return size of array."
-              (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 (is original clone))))
-      (assert "Full-range manual copies should give the same result as cloning."
-              (exec (&;copy size +0 original +0 copy)
-                (and (:: (&;Eq<Array> number;Eq<Nat>) = original copy)
-                     (not (is original copy)))))
-      (assert "Array folding should go over all values."
-              (exec (:: &;Fold<Array> fold
-                        (function [x idx]
-                          (exec (&;put idx x manual-copy)
-                            (n.inc idx)))
-                        +0
-                        original)
-                (:: (&;Eq<Array> number;Eq<Nat>) = original manual-copy)))
-      (assert "Transformations between (full) arrays and lists shouldn't cause lose or change any values."
-              (|> original
-                  &;to-list &;from-list
-                  (:: (&;Eq<Array> number;Eq<Nat>) = original)))
+      (test "Size function must correctly return size of array."
+            (n.= size (&;size original)))
+      (test "Cloning an array should yield and identical array, but not the same one."
+            (and (:: (&;Eq<Array> number;Eq<Nat>) = original clone)
+                 (not (is original clone))))
+      (test "Full-range manual copies should give the same result as cloning."
+            (exec (&;copy size +0 original +0 copy)
+              (and (:: (&;Eq<Array> number;Eq<Nat>) = original copy)
+                   (not (is original copy)))))
+      (test "Array folding should go over all values."
+            (exec (:: &;Fold<Array> fold
+                      (function [x idx]
+                        (exec (&;put idx x manual-copy)
+                          (n.inc idx)))
+                      +0
+                      original)
+              (:: (&;Eq<Array> number;Eq<Nat>) = original manual-copy)))
+      (test "Transformations between (full) arrays and lists shouldn't cause lose or change any values."
+            (|> original
+                &;to-list &;from-list
+                (:: (&;Eq<Array> number;Eq<Nat>) = original)))
       ))
 
-(test: "Array mutation"
+(context: "Array mutation"
   [size bounded-size
    idx (:: @ map (n.% size) R;nat)
    array (|> (R;array size R;nat)
@@ -54,59 +54,59 @@
    #let [value (default (undefined)
                  (&;get idx array))]]
   ($_ seq
-      (assert "Shouldn't be able to find a value in an unoccupied cell."
-              (case (&;get idx (&;remove idx array))
-                (#;Some _) false
-                #;None     true))
-      (assert "You should be able to access values put into the array."
-              (case (&;get idx (&;put idx value array))
-                (#;Some value') (n.= value' value)
-                #;None          false))
-      (assert "All cells should be occupied on a full array."
-              (and (n.= size (&;occupied array))
-                   (n.= +0 (&;vacant array))))
-      (assert "Filtering mutates the array to remove invalid values."
-              (exec (&;filter n.even? array)
-                (and (n.< size (&;occupied array))
-                     (n.> +0 (&;vacant array))
-                     (n.= size (n.+ (&;occupied array)
-                                    (&;vacant array))))))
+      (test "Shouldn't be able to find a value in an unoccupied cell."
+            (case (&;get idx (&;remove idx array))
+              (#;Some _) false
+              #;None     true))
+      (test "You should be able to access values put into the array."
+            (case (&;get idx (&;put idx value array))
+              (#;Some value') (n.= value' value)
+              #;None          false))
+      (test "All cells should be occupied on a full array."
+            (and (n.= size (&;occupied array))
+                 (n.= +0 (&;vacant array))))
+      (test "Filtering mutates the array to remove invalid values."
+            (exec (&;filter n.even? array)
+              (and (n.< size (&;occupied array))
+                   (n.> +0 (&;vacant array))
+                   (n.= size (n.+ (&;occupied array)
+                                  (&;vacant array))))))
       ))
 
-(test: "Finding values."
+(context: "Finding values."
   [size bounded-size
    array (|> (R;array size R;nat)
              (R;filter (|>. &;to-list (list;any? n.even?))))]
   ($_ seq
-      (assert "Can find values inside arrays."
-              (|> (&;find n.even? array)
-                  (case> (#;Some _) true
-                         #;None     false)))
-      (assert "Can find values inside arrays (with access to indices)."
-              (|> (&;find+ (function [idx n]
-                             (and (n.even? n)
-                                  (n.< size idx)))
-                           array)
-                  (case> (#;Some _) true
-                         #;None     false)))))
+      (test "Can find values inside arrays."
+            (|> (&;find n.even? array)
+                (case> (#;Some _) true
+                       #;None     false)))
+      (test "Can find values inside arrays (with access to indices)."
+            (|> (&;find+ (function [idx n]
+                           (and (n.even? n)
+                                (n.< size idx)))
+                         array)
+                (case> (#;Some _) true
+                       #;None     false)))))
 
-(test: "Functor"
+(context: "Functor"
   [size bounded-size
    array (R;array size R;nat)]
   (let [(^open) &;Functor<Array>
         (^open) (&;Eq<Array> number;Eq<Nat>)]
     ($_ seq
-        (assert "Functor shouldn't alter original array."
-                (let [copy (map id array)]
-                  (and (= array copy)
-                       (not (is array copy)))))
-        (assert "Functor should go over all available array elements."
-                (let [there (map n.inc array)
-                      back-again (map n.dec there)]
-                  (and (not (= array there))
-                       (= array back-again)))))))
+        (test "Functor shouldn't alter original array."
+              (let [copy (map id array)]
+                (and (= array copy)
+                     (not (is array copy)))))
+        (test "Functor should go over all available array elements."
+              (let [there (map n.inc array)
+                    back-again (map n.dec there)]
+                (and (not (= array there))
+                     (= array back-again)))))))
 
-(test: "Monoid"
+(context: "Monoid"
   [sizeL bounded-size
    sizeR bounded-size
    left (R;array sizeL R;nat)
@@ -115,16 +115,16 @@
          (^open) (&;Eq<Array> number;Eq<Nat>)
          fusion (append left right)]]
   ($_ seq
-      (assert "Appending two arrays should produce a new one twice as large."
-              (n.= (n.+ sizeL sizeR) (&;size fusion)))
-      (assert "First elements of fused array should equal the first array."
-              (|> (: (&;Array Nat)
-                     (&;new sizeL))
-                  (&;copy sizeL +0 fusion +0)
-                  (= left)))
-      (assert "Last elements of fused array should equal the second array."
-              (|> (: (&;Array Nat)
-                     (&;new sizeR))
-                  (&;copy sizeR sizeL fusion +0)
-                  (= right)))
+      (test "Appending two arrays should produce a new one twice as large."
+            (n.= (n.+ sizeL sizeR) (&;size fusion)))
+      (test "First elements of fused array should equal the first array."
+            (|> (: (&;Array Nat)
+                   (&;new sizeL))
+                (&;copy sizeL +0 fusion +0)
+                (= left)))
+      (test "Last elements of fused array should equal the second array."
+            (|> (: (&;Array Nat)
+                   (&;new sizeR))
+                (&;copy sizeR sizeL fusion +0)
+                (= right)))
       ))
diff --git a/stdlib/test/test/lux/data/coll/dict.lux b/stdlib/test/test/lux/data/coll/dict.lux
index ee54f9204..0153e8049 100644
--- a/stdlib/test/test/lux/data/coll/dict.lux
+++ b/stdlib/test/test/lux/data/coll/dict.lux
@@ -12,7 +12,7 @@
        ["R" math/random])
   lux/test)
 
-(test: "Dictionaries."
+(context: "Dictionaries."
   [#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)
@@ -21,110 +21,110 @@
    test-val (|> R;nat
                 (R;filter (function [val] (not (list;member? number;Eq<Nat> (&;values dict) val)))))]
   ($_ seq
-      (assert "Size function should correctly represent Dict size."
-              (n.= size (&;size dict)))
+      (test "Size function should correctly represent Dict size."
+            (n.= size (&;size dict)))
       
-      (assert "Dicts of size 0 should be considered empty."
-              (if (n.= +0 size)
-                (&;empty? dict)
-                (not (&;empty? dict))))
+      (test "Dicts of size 0 should be considered empty."
+            (if (n.= +0 size)
+              (&;empty? dict)
+              (not (&;empty? dict))))
       
-      (assert "The functions 'entries', 'keys' and 'values' should be synchronized."
-              (:: (list;Eq<List> (eq;conj char;Eq<Char> number;Eq<Nat>)) =
-                  (&;entries dict)
-                  (list;zip2 (&;keys dict)
-                             (&;values dict))))
+      (test "The functions 'entries', 'keys' and 'values' should be synchronized."
+            (:: (list;Eq<List> (eq;conj char;Eq<Char> number;Eq<Nat>)) =
+                (&;entries dict)
+                (list;zip2 (&;keys dict)
+                           (&;values dict))))
       
-      (assert "Dict should be able to recognize it's own keys."
-              (list;every? (function [key] (&;contains? key dict))
-                           (&;keys dict)))
+      (test "Dict should be able to recognize it's own keys."
+            (list;every? (function [key] (&;contains? key dict))
+                         (&;keys dict)))
       
-      (assert "Should be able to get every key."
-              (list;every? (function [key] (case (&;get key dict)
-                                             (#;Some _) true
-                                             _          false))
-                           (&;keys dict)))
+      (test "Should be able to get every key."
+            (list;every? (function [key] (case (&;get key dict)
+                                           (#;Some _) true
+                                           _          false))
+                         (&;keys dict)))
       
-      (assert "Shouldn't be able to access non-existant keys."
-              (case (&;get non-key dict)
-                (#;Some _) false
-                _          true))
+      (test "Shouldn't be able to access non-existant keys."
+            (case (&;get non-key dict)
+              (#;Some _) false
+              _          true))
       
-      (assert "Should be able to put and then get a value."
-              (case (&;get non-key (&;put non-key test-val dict))
-                (#;Some v) (n.= test-val v)
-                _          true))
+      (test "Should be able to put and then get a value."
+            (case (&;get non-key (&;put non-key test-val dict))
+              (#;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) (n.= test-val v)
-                _          true))
+      (test "Should be able to put~ and then get a value."
+            (case (&;get non-key (&;put~ non-key test-val dict))
+              (#;Some v) (n.= test-val v)
+              _          true))
       
-      (assert "Shouldn't be able to put~ an existing key."
-              (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 (n.= test-val v))
-                      _          true))))
+      (test "Shouldn't be able to put~ an existing key."
+            (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 (n.= test-val v))
+                    _          true))))
       
-      (assert "Removing a key should make it's value inaccessible."
-              (let [base (&;put non-key test-val dict)]
-                (and (&;contains? non-key base)
-                     (not (&;contains? non-key (&;remove non-key base))))))
+      (test "Removing a key should make it's value inaccessible."
+            (let [base (&;put non-key test-val dict)]
+              (and (&;contains? non-key base)
+                   (not (&;contains? non-key (&;remove non-key base))))))
       
-      (assert "Should be possible to update values via their keys."
-              (let [base (&;put non-key test-val dict)
-                    updt (&;update non-key n.inc base)]
-                (case [(&;get non-key base) (&;get non-key updt)]
-                  [(#;Some x) (#;Some y)]
-                  (n.= (n.inc x) y)
+      (test "Should be possible to update values via their keys."
+            (let [base (&;put non-key test-val dict)
+                  updt (&;update non-key n.inc base)]
+              (case [(&;get non-key base) (&;get non-key updt)]
+                [(#;Some x) (#;Some y)]
+                (n.= (n.inc x) y)
 
-                  _
-                  false)))
+                _
+                false)))
       
-      (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 (n.= (n.inc (&;size dict)) (&;size plus))
-                     (n.= (n.dec (&;size plus)) (&;size base)))))
+      (test "Additions and removals to a Dict should affect its size."
+            (let [plus (&;put non-key test-val dict)
+                  base (&;remove non-key plus)]
+              (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>)]
-                (and (= dict dict)
-                     (|> dict &;entries (&;from-list char;Hash<Char>) (= dict)))))
+      (test "A Dict should equal itself & going to<->from lists shouldn't change that."
+            (let [(^open) (&;Eq<Dict> number;Eq<Nat>)]
+              (and (= dict dict)
+                   (|> dict &;entries (&;from-list char;Hash<Char>) (= dict)))))
 
-      (assert "Merging a Dict to itself changes nothing."
-              (let [(^open) (&;Eq<Dict> number;Eq<Nat>)]
-                (= dict (&;merge dict dict))))
+      (test "Merging a Dict to itself changes nothing."
+            (let [(^open) (&;Eq<Dict> number;Eq<Nat>)]
+              (= dict (&;merge dict dict))))
 
-      (assert "If you merge, and the second dict has overlapping keys, it should overwrite yours."
-              (let [dict' (|> dict &;entries
-                              (List/map (function [[k v]] [k (n.inc v)]))
-                              (&;from-list char;Hash<Char>))
-                    (^open) (&;Eq<Dict> number;Eq<Nat>)]
-                (= dict' (&;merge dict' dict))))
+      (test "If you merge, and the second dict has overlapping keys, it should overwrite yours."
+            (let [dict' (|> dict &;entries
+                            (List/map (function [[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? (function [[x x*2]] (n.= (n.* +2 x) x*2))
-                           (list;zip2 (&;values dict)
-                                      (&;values (&;merge-with n.+ dict dict)))))
+      (test "Can merge values in such a way that they become combined."
+            (list;every? (function [[x x*2]] (n.= (n.* +2 x) x*2))
+                         (list;zip2 (&;values 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
-                  (n.= +1)))
+      (test "Should be able to select subset of keys from dict."
+            (|> dict
+                (&;put non-key test-val)
+                (&;select (list non-key))
+                &;size
+                (n.= +1)))
 
-      (assert "Should be able to re-bind existing values to different keys."
-              (or (n.= +0 size)
-                  (let [first-key (|> dict &;keys list;head (default (undefined)))
-                        rebound (&;re-bind first-key non-key dict)]
-                    (and (n.= (&;size dict) (&;size rebound))
-                         (&;contains? non-key rebound)
-                         (not (&;contains? first-key rebound))
-                         (n.= (default (undefined)
-                                (&;get first-key dict))
-                              (default (undefined)
-                                (&;get non-key rebound)))))))
+      (test "Should be able to re-bind existing values to different keys."
+            (or (n.= +0 size)
+                (let [first-key (|> dict &;keys list;head (default (undefined)))
+                      rebound (&;re-bind first-key non-key dict)]
+                  (and (n.= (&;size dict) (&;size rebound))
+                       (&;contains? non-key rebound)
+                       (not (&;contains? first-key rebound))
+                       (n.= (default (undefined)
+                              (&;get first-key dict))
+                            (default (undefined)
+                              (&;get non-key rebound)))))))
       ))
diff --git a/stdlib/test/test/lux/data/coll/list.lux b/stdlib/test/test/lux/data/coll/list.lux
index 0840b11e3..7e91ed06c 100644
--- a/stdlib/test/test/lux/data/coll/list.lux
+++ b/stdlib/test/test/lux/data/coll/list.lux
@@ -16,7 +16,7 @@
   (|> R;nat
       (:: R;Monad<Random> map (|>. (n.% +100) (n.+ +10)))))
 
-(test: "Lists: Part 1"
+(context: "Lists: Part 1"
   [size bounded-size
    idx (:: @ map (n.% size) R;nat)
    sample (R;list size R;nat)
@@ -26,42 +26,42 @@
    #let [(^open) (&;Eq<List> number;Eq<Nat>)
          (^open "&/") &;Functor<List>]]
   ($_ seq
-      (assert "The size function should correctly portray the size of the list."
-              (n.= size (&;size sample)))
+      (test "The size function should correctly portray the size of the list."
+            (n.= size (&;size sample)))
 
-      (assert "The repeat function should produce as many elements as asked of it."
-              (n.= size (&;size (&;repeat size []))))
+      (test "The repeat function should produce as many elements as asked of it."
+            (n.= size (&;size (&;repeat size []))))
 
-      (assert "Reversing a list does not change it's size."
-              (n.= (&;size sample)
-                   (&;size (&;reverse sample))))
+      (test "Reversing a list does not change it's size."
+            (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 (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? 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 its member."
-              (let [elem (default (undefined)
-                           (&;nth idx sample))]
-                (&;member? number;Eq<Nat> sample elem)))
+      (test "Reversing a list twice results in the original list."
+            (= sample
+               (&;reverse (&;reverse sample))))
+
+      (test "Filtering by a predicate and its complement should result in a number of elements equal to the original list."
+            (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))))))
+
+      (test "If every element in a list satisfies a predicate, there can't be any that satisfy its complement."
+            (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)))
+
+      (test "Any element of the list can be considered its member."
+            (let [elem (default (undefined)
+                         (&;nth idx sample))]
+              (&;member? number;Eq<Nat> sample elem)))
       ))
 
-(test: "Lists: Part 2"
+(context: "Lists: Part 2"
   [size bounded-size
    idx (:: @ map (n.% size) R;nat)
    sample (R;list size R;nat)
@@ -71,60 +71,60 @@
    #let [(^open) (&;Eq<List> number;Eq<Nat>)
          (^open "&/") &;Functor<List>]]
   ($_ seq
-      (assert "Appending the head and the tail should yield the original list."
-              (let [head (default (undefined)
-                           (&;head sample))
-                    tail (default (undefined)
-                           (&;tail sample))]
-                (= sample
-                   (#;Cons head tail))))
-
-      (assert "Appending the inits and the last should yield the original list."
-              (let [(^open) &;Monoid<List>
-                    inits (default (undefined)
-                            (&;inits sample))
-                    last (default (undefined)
-                           (&;last sample))]
-                (= sample
-                   (append inits (list last)))))
-
-      (assert "Functor should go over every element of the list."
-              (let [(^open) &;Functor<List>
-                    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 n.even? sample)]
-                (and (= sample
-                        (append left right))
-                     (= sample
-                        (append left' right'))
-                     (= sample
-                        (append (&;take idx sample)
-                                (&;drop idx sample)))
-                     (= 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."
-              (n.= (n./ +2 size)
-                   (&;size (&;as-pairs sample))))
-
-      (assert "Sorting a list shouldn't change it's size."
-              (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 n.< sample)
-                 (&;reverse (&;sort n.> sample))))
+      (test "Appending the head and the tail should yield the original list."
+            (let [head (default (undefined)
+                         (&;head sample))
+                  tail (default (undefined)
+                         (&;tail sample))]
+              (= sample
+                 (#;Cons head tail))))
+
+      (test "Appending the inits and the last should yield the original list."
+            (let [(^open) &;Monoid<List>
+                  inits (default (undefined)
+                          (&;inits sample))
+                  last (default (undefined)
+                         (&;last sample))]
+              (= sample
+                 (append inits (list last)))))
+
+      (test "Functor should go over every element of the list."
+            (let [(^open) &;Functor<List>
+                  there (map n.inc sample)
+                  back-again (map n.dec there)]
+              (and (not (= sample there))
+                   (= sample back-again))))
+
+      (test "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 n.even? sample)]
+              (and (= sample
+                      (append left right))
+                   (= sample
+                      (append left' right'))
+                   (= sample
+                      (append (&;take idx sample)
+                              (&;drop idx sample)))
+                   (= sample
+                      (append (&;take-while n.even? sample)
+                              (&;drop-while n.even? sample)))
+                   )))
+
+      (test "Segmenting the list in pairs should yield as many elements as N/2."
+            (n.= (n./ +2 size)
+                 (&;size (&;as-pairs sample))))
+
+      (test "Sorting a list shouldn't change it's size."
+            (n.= (&;size sample)
+                 (&;size (&;sort n.< sample))))
+
+      (test "Sorting a list with one order should yield the reverse of sorting it with the opposite order."
+            (= (&;sort n.< sample)
+               (&;reverse (&;sort n.> sample))))
       ))
 
-(test: "Lists: Part 3"
+(context: "Lists: Part 3"
   [size bounded-size
    idx (:: @ map (n.% size) R;nat)
    sample (R;list size R;nat)
@@ -134,88 +134,88 @@
    #let [(^open) (&;Eq<List> number;Eq<Nat>)
          (^open "&/") &;Functor<List>]]
   ($_ seq
-      (assert "If you zip 2 lists, the result's size will be that of the smaller list."
-              (n.= (&;size (&;zip2 sample other-sample))
-                   (n.min (&;size sample) (&;size other-sample))))
+      (test "If you zip 2 lists, the result's size will be that of the smaller list."
+            (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>
-                    zipped (&;zip2 sample other-sample)
-                    num-zipper (&;size zipped)]
-                (and (|> zipped (map product;left) (= (&;take num-zipper sample)))
-                     (|> zipped (map product;right) (= (&;take num-zipper other-sample))))))
+      (test "I can pair-up elements of a list in order."
+            (let [(^open) &;Functor<List>
+                  zipped (&;zip2 sample other-sample)
+                  num-zipper (&;size zipped)]
+              (and (|> zipped (map product;left) (= (&;take num-zipper sample)))
+                   (|> zipped (map product;right) (= (&;take num-zipper other-sample))))))
       
-      (assert "You can generate indices for any size, and they will be in ascending order."
-              (let [(^open) &;Functor<List>
-                    indices (&;indices size)]
-                (and (n.= size (&;size indices))
-                     (= indices
-                        (&;sort n.< indices))
-                     (&;every? (n.= (n.dec size))
-                               (&;zip2-with n.+
-                                            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 (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>]
-                (and (= sample (append unit sample))
-                     (= sample (append sample unit))
-                     (let [[left right] (&;split size (append sample other-sample))]
-                       (and (= sample left)
-                            (= other-sample right))))))
-
-      (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 n.inc sample)
-                        (apply (wrap n.inc) sample)))))
-
-      (assert "List concatenation is a monad."
-              (let [(^open) &;Monad<List>
-                    (^open) &;Monoid<List>]
-                (= (append sample other-sample)
-                   (join (list sample other-sample)))))
-
-      (assert "You can find any value that satisfies some criterium, if such values exist in the list."
-              (case (&;find n.even? sample)
-                (#;Some found)
-                (and (n.even? found)
-                     (&;any? n.even? sample)
-                     (not (&;every? (bool;complement n.even?) sample)))
-
-                #;None
-                (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."
-              (= (&;n.range +0 (n.dec size))
-                 (&;iterate (function [n] (if (n.< size n) (#;Some (n.inc n)) #;None))
-                            +0)))
-
-      (assert "Can enumerate all elements in a list."
-              (let [enum-sample (&;enumerate sample)]
-                (and (= (&;indices (&;size enum-sample))
-                        (&/map product;left enum-sample))
-                     (= sample
-                        (&/map product;right enum-sample)))))
+      (test "You can generate indices for any size, and they will be in ascending order."
+            (let [(^open) &;Functor<List>
+                  indices (&;indices size)]
+              (and (n.= size (&;size indices))
+                   (= indices
+                      (&;sort n.< indices))
+                   (&;every? (n.= (n.dec size))
+                             (&;zip2-with n.+
+                                          indices
+                                          (&;sort n.> indices)))
+                   )))
+
+      (test "The 'interpose' function places a value between every member of a list."
+            (let [(^open) &;Functor<List>
+                  sample+ (&;interpose separator sample)]
+              (and (n.= (|> size (n.* +2) n.dec)
+                        (&;size sample+))
+                   (|> sample+ &;as-pairs (map product;right) (&;every? (n.= separator))))))
+
+      (test "List append is a monoid."
+            (let [(^open) &;Monoid<List>]
+              (and (= sample (append unit sample))
+                   (= sample (append sample unit))
+                   (let [[left right] (&;split size (append sample other-sample))]
+                     (and (= sample left)
+                          (= other-sample right))))))
+
+      (test "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 n.inc sample)
+                      (apply (wrap n.inc) sample)))))
+
+      (test "List concatenation is a monad."
+            (let [(^open) &;Monad<List>
+                  (^open) &;Monoid<List>]
+              (= (append sample other-sample)
+                 (join (list sample other-sample)))))
+
+      (test "You can find any value that satisfies some criterium, if such values exist in the list."
+            (case (&;find n.even? sample)
+              (#;Some found)
+              (and (n.even? found)
+                   (&;any? n.even? sample)
+                   (not (&;every? (bool;complement n.even?) sample)))
+
+              #;None
+              (and (not (&;any? n.even? sample))
+                   (&;every? (bool;complement n.even?) sample))))
+
+      (test "You can iteratively construct a list, generating values until you're done."
+            (= (&;n.range +0 (n.dec size))
+               (&;iterate (function [n] (if (n.< size n) (#;Some (n.inc n)) #;None))
+                          +0)))
+
+      (test "Can enumerate all elements in a list."
+            (let [enum-sample (&;enumerate sample)]
+              (and (= (&;indices (&;size enum-sample))
+                      (&/map product;left enum-sample))
+                   (= sample
+                      (&/map product;right enum-sample)))))
       ))
 
-(test: "Monad transformer"
+(context: "Monad transformer"
   (let [lift (&;lift-list io;Monad<IO>)
         (^open "io/") io;Monad<IO>]
-    (assert "Can add list functionality to any monad."
-            (|> (io;run (do (&;ListT io;Monad<IO>)
-                          [a (lift (io/wrap 123))
-                           b (wrap 456)]
-                          (wrap (i.+ a b))))
-                (case> (^ (list 579)) true
-                       _              false)))
+    (test "Can add list functionality to any monad."
+          (|> (io;run (do (&;ListT io;Monad<IO>)
+                        [a (lift (io/wrap 123))
+                         b (wrap 456)]
+                        (wrap (i.+ a b))))
+              (case> (^ (list 579)) true
+                     _              false)))
     ))
diff --git a/stdlib/test/test/lux/data/coll/ordered.lux b/stdlib/test/test/lux/data/coll/ordered.lux
index c1f5c9944..0ee02dea6 100644
--- a/stdlib/test/test/lux/data/coll/ordered.lux
+++ b/stdlib/test/test/lux/data/coll/ordered.lux
@@ -15,7 +15,7 @@
   (|> R;nat
       (:: R;Monad<Random> map (n.% +100))))
 
-(test: "Sets"
+(context: "Sets"
   [sizeL gen-nat
    sizeR gen-nat
    setL (|> (R;set number;Hash<Nat> sizeL gen-nat)
@@ -24,44 +24,44 @@
             (:: @ map (|>. S;to-list (&;from-list number;Order<Nat>))))
    #let [(^open "&/") &;Eq<Set>]]
   ($_ seq
-      (assert "I can query the size of a set."
-              (n.= sizeL (&;size setL)))
+      (test "I can query the size of a set."
+            (n.= sizeL (&;size setL)))
 
-      (assert "Converting sets to/from lists can't change their values."
-              (|> setL
-                  &;to-list (&;from-list number;Order<Nat>)
-                  (&/= setL)))
+      (test "Converting sets to/from lists can't change their values."
+            (|> setL
+                &;to-list (&;from-list number;Order<Nat>)
+                (&/= setL)))
 
-      (assert "Order is preserved."
-              (let [listL (&;to-list setL)
-                    (^open "L/") (list;Eq<List> number;Eq<Nat>)]
-                (L/= listL
-                     (list;sort n.< listL))))
+      (test "Order is preserved."
+            (let [listL (&;to-list setL)
+                  (^open "L/") (list;Eq<List> number;Eq<Nat>)]
+              (L/= listL
+                   (list;sort n.< listL))))
 
-      (assert "Every set is a sub-set of the union of itself with another."
-              (let [setLR (&;union setL setR)]
-                (and (&;sub? setLR setL)
-                     (&;sub? setLR setR))))
+      (test "Every set is a sub-set of the union of itself with another."
+            (let [setLR (&;union setL setR)]
+              (and (&;sub? setLR setL)
+                   (&;sub? setLR setR))))
 
-      (assert "Every set is a super-set of the intersection of itself with another."
-              (let [setLR (&;intersection setL setR)]
-                (and (&;super? setLR setL)
-                     (&;super? setLR setR))))
+      (test "Every set is a super-set of the intersection of itself with another."
+            (let [setLR (&;intersection setL setR)]
+              (and (&;super? setLR setL)
+                   (&;super? setLR setR))))
 
-      (assert "Union with the empty set leaves a set unchanged."
-              (&/= setL
-                   (&;union (&;new number;Order<Nat>)
-                            setL)))
+      (test "Union with the empty set leaves a set unchanged."
+            (&/= setL
+                 (&;union (&;new number;Order<Nat>)
+                          setL)))
 
-      (assert "Intersection with the empty set results in the empty set."
-              (let [empty-set (&;new number;Order<Nat>)]
-                (&/= empty-set
-                     (&;intersection empty-set setL))))
+      (test "Intersection with the empty set results in the empty set."
+            (let [empty-set (&;new number;Order<Nat>)]
+              (&/= empty-set
+                   (&;intersection empty-set setL))))
 
-      (assert "After substracting a set A from another B, no member of A can be a member of B."
-              (let [sub (&;difference setR setL)]
-                (not (list;any? (&;member? sub) (&;to-list setR)))))
+      (test "After substracting a set A from another B, no member of A can be a member of B."
+            (let [sub (&;difference setR setL)]
+              (not (list;any? (&;member? sub) (&;to-list setR)))))
 
-      (assert "Every member of a set must be identifiable."
-              (list;every? (&;member? setL) (&;to-list setL)))
+      (test "Every member of a set must be identifiable."
+            (list;every? (&;member? setL) (&;to-list setL)))
       ))
diff --git a/stdlib/test/test/lux/data/coll/priority-queue.lux b/stdlib/test/test/lux/data/coll/priority-queue.lux
index f82216f54..fede1766a 100644
--- a/stdlib/test/test/lux/data/coll/priority-queue.lux
+++ b/stdlib/test/test/lux/data/coll/priority-queue.lux
@@ -18,32 +18,32 @@
            &;empty
            inputs)))
 
-(test: "Queues"
+(context: "Queues"
   [size (|> R;nat (:: @ map (n.% +100)))
    sample (gen-queue size)
    non-member-priority R;nat
    non-member (|> R;nat (R;filter (|>. (&;member? number;Eq<Nat> sample) not)))]
   ($_ seq
-      (assert "I can query the size of a queue (and empty queues have size 0)."
-              (n.= size (&;size sample)))
+      (test "I can query the size of a queue (and empty queues have size 0)."
+            (n.= size (&;size sample)))
 
-      (assert "Enqueueing and dequeing affects the size of queues."
-              (and (n.= (n.inc size)
-                        (&;size (&;push non-member-priority non-member sample)))
-                   (or (n.= +0 (&;size sample))
-                       (n.= (n.dec size)
-                            (&;size (&;pop sample))))))
+      (test "Enqueueing and dequeing affects the size of queues."
+            (and (n.= (n.inc size)
+                      (&;size (&;push non-member-priority non-member sample)))
+                 (or (n.= +0 (&;size sample))
+                     (n.= (n.dec size)
+                          (&;size (&;pop sample))))))
 
-      (assert "I can query whether an element belongs to a queue."
-              (and (and (not (&;member? number;Eq<Nat> sample non-member))
-                        (&;member? number;Eq<Nat>
-                                   (&;push non-member-priority non-member sample)
-                                   non-member))
-                   (or (n.= +0 (&;size sample))
-                       (and (&;member? number;Eq<Nat>
-                                       sample
-                                       (default (undefined) (&;peek sample)))
-                            (not (&;member? number;Eq<Nat>
-                                            (&;pop sample)
-                                            (default (undefined) (&;peek sample))))))))
+      (test "I can query whether an element belongs to a queue."
+            (and (and (not (&;member? number;Eq<Nat> sample non-member))
+                      (&;member? number;Eq<Nat>
+                                 (&;push non-member-priority non-member sample)
+                                 non-member))
+                 (or (n.= +0 (&;size sample))
+                     (and (&;member? number;Eq<Nat>
+                                     sample
+                                     (default (undefined) (&;peek sample)))
+                          (not (&;member? number;Eq<Nat>
+                                          (&;pop sample)
+                                          (default (undefined) (&;peek sample))))))))
       ))
diff --git a/stdlib/test/test/lux/data/coll/queue.lux b/stdlib/test/test/lux/data/coll/queue.lux
index 44123f8e3..1fdcbd25a 100644
--- a/stdlib/test/test/lux/data/coll/queue.lux
+++ b/stdlib/test/test/lux/data/coll/queue.lux
@@ -7,43 +7,43 @@
        ["R" math/random])
   lux/test)
 
-(test: "Queues"
+(context: "Queues"
   [size (:: @ map (n.% +100) R;nat)
    sample (R;queue size R;nat)
    non-member (|> R;nat
                   (R;filter (. not (&;member? number;Eq<Nat> sample))))]
   ($_ seq
-      (assert "I can query the size of a queue (and empty queues have size 0)."
-              (if (n.= +0 size)
-                (&;empty? sample)
-                (n.= size (&;size sample))))
+      (test "I can query the size of a queue (and empty queues have size 0)."
+            (if (n.= +0 size)
+              (&;empty? sample)
+              (n.= size (&;size sample))))
 
-      (assert "Enqueueing and dequeing affects the size of queues."
-              (and (n.= (n.inc size) (&;size (&;push non-member sample)))
-                   (or (&;empty? sample)
-                       (n.= (n.dec size) (&;size (&;pop sample))))
-                   (n.= size (&;size (&;pop (&;push non-member sample))))))
+      (test "Enqueueing and dequeing affects the size of queues."
+            (and (n.= (n.inc size) (&;size (&;push non-member sample)))
+                 (or (&;empty? sample)
+                     (n.= (n.dec size) (&;size (&;pop sample))))
+                 (n.= size (&;size (&;pop (&;push non-member sample))))))
 
-      (assert "Transforming to/from list can't change the queue."
-              (let [(^open "&/") (&;Eq<Queue> number;Eq<Nat>)]
-                (|> sample
-                    &;to-list &;from-list
-                    (&/= sample))))
+      (test "Transforming to/from list can't change the queue."
+            (let [(^open "&/") (&;Eq<Queue> number;Eq<Nat>)]
+              (|> sample
+                  &;to-list &;from-list
+                  (&/= sample))))
 
-      (assert "I can always peek at a non-empty queue."
-              (case (&;peek sample)
-                #;None     (&;empty? sample)
-                (#;Some _) true))
+      (test "I can always peek at a non-empty queue."
+            (case (&;peek sample)
+              #;None     (&;empty? sample)
+              (#;Some _) true))
 
-      (assert "I can query whether an element belongs to a queue."
-              (and (not (&;member? number;Eq<Nat> sample non-member))
-                   (&;member? number;Eq<Nat> (&;push non-member sample)
-                              non-member)
-                   (case (&;peek sample)
-                     #;None
-                     (&;empty? sample)
-                     
-                     (#;Some first)
-                     (and (&;member? number;Eq<Nat> sample first)
-                          (not (&;member? number;Eq<Nat> (&;pop sample) first))))))
+      (test "I can query whether an element belongs to a queue."
+            (and (not (&;member? number;Eq<Nat> sample non-member))
+                 (&;member? number;Eq<Nat> (&;push non-member sample)
+                            non-member)
+                 (case (&;peek sample)
+                   #;None
+                   (&;empty? sample)
+                   
+                   (#;Some first)
+                   (and (&;member? number;Eq<Nat> sample first)
+                        (not (&;member? number;Eq<Nat> (&;pop sample) first))))))
       ))
diff --git a/stdlib/test/test/lux/data/coll/seq.lux b/stdlib/test/test/lux/data/coll/seq.lux
index a111ecb0e..f6d221180 100644
--- a/stdlib/test/test/lux/data/coll/seq.lux
+++ b/stdlib/test/test/lux/data/coll/seq.lux
@@ -19,7 +19,7 @@
   (|> R;nat
       (:: R;Monad<Random> map (|>. (n.% +100) (n.+ +10) (n.max +1)))))
 
-(test: "Seqs: Part 1"
+(context: "Seqs: Part 1"
   [size bounded-size
    idx (:: @ map (n.% size) R;nat)
    sample (|> (R;list size R;nat)
@@ -27,75 +27,75 @@
    extra R;nat
    #let [(^open "&/") (&;Eq<Seq> number;Eq<Nat>)]]
   ($_ seq
-      (assert "Can convert to/from list."
-              (|> sample
-                  &;to-list &;from-list
-                  (&/= sample)))
+      (test "Can convert to/from list."
+            (|> sample
+                &;to-list &;from-list
+                (&/= sample)))
       
-      (assert "The size function should correctly portray the size of the seq."
-              (n.= size (&;size sample)))
+      (test "The size function should correctly portray the size of the seq."
+            (n.= size (&;size sample)))
 
-      (assert "Reversing a seq does not change it's size."
-              (n.= (&;size sample)
-                   (&;size (&;reverse sample))))
+      (test "Reversing a seq does not change it's size."
+            (n.= (&;size sample)
+                 (&;size (&;reverse sample))))
       
-      (assert "Reversing a seq twice results in the original seq."
-              (&/= sample
-                   (&;reverse (&;reverse sample))))
+      (test "Reversing a seq twice results in the original seq."
+            (&/= sample
+                 (&;reverse (&;reverse sample))))
 
-      (assert "If every element in a list satisfies a predicate, there can't be any that satisfy its complement."
-              (if (&;every? n.even? sample)
-                (not (&;any? (bool;complement n.even?) sample))
-                (&;any? (bool;complement n.even?) sample)))
+      (test "If every element in a list satisfies a predicate, there can't be any that satisfy its complement."
+            (if (&;every? n.even? sample)
+              (not (&;any? (bool;complement n.even?) sample))
+              (&;any? (bool;complement n.even?) sample)))
 
-      (assert "Any element of the list can be considered its member."
-              (and (&;member? number;Eq<Nat>
-                              (&;prepend extra sample)
-                              extra)
-                   (&;member? number;Eq<Nat>
-                              (&;append extra sample)
-                              extra)))
+      (test "Any element of the list can be considered its member."
+            (and (&;member? number;Eq<Nat>
+                            (&;prepend extra sample)
+                            extra)
+                 (&;member? number;Eq<Nat>
+                            (&;append extra sample)
+                            extra)))
       
-      (assert "Can do random access to seq elements."
-              (and (|> (&;prepend extra sample)
-                       (&;nth +0)
-                       (case> (#;Some reference)
-                              (n.= reference extra)
+      (test "Can do random access to seq elements."
+            (and (|> (&;prepend extra sample)
+                     (&;nth +0)
+                     (case> (#;Some reference)
+                            (n.= reference extra)
 
-                              _
-                              false))
-                   (|> (&;append extra sample)
-                       (&;nth size)
-                       (case> (#;Some reference)
-                              (n.= reference extra)
+                            _
+                            false))
+                 (|> (&;append extra sample)
+                     (&;nth size)
+                     (case> (#;Some reference)
+                            (n.= reference extra)
 
-                              _
-                              false))))
+                            _
+                            false))))
       ))
 
-(test: "Seqs: Part 2"
+(context: "Seqs: Part 2"
   [size bounded-size
    sample (|> (R;list size R;nat)
               (:: @ map &;from-list))
    #let [(^open "&/") (&;Eq<Seq> number;Eq<Nat>)
          (^open "&/") &;Functor<Seq>]]
   ($_ seq
-      (assert "Functor should go over every element of the seq."
-              (let [there (&/map n.inc sample)
-                    back-again (&/map n.dec there)]
-                (and (not (&/= sample there))
-                     (&/= sample back-again))))
+      (test "Functor should go over every element of the seq."
+            (let [there (&/map n.inc sample)
+                  back-again (&/map n.dec there)]
+              (and (not (&/= sample there))
+                   (&/= sample back-again))))
 
-      (assert "Sorting a seq shouldn't change it's size."
-              (n.= (&;size sample)
-                   (&;size (&;sort n.< sample))))
+      (test "Sorting a seq shouldn't change it's size."
+            (n.= (&;size sample)
+                 (&;size (&;sort n.< sample))))
 
-      (assert "Sorting a seq with one order should yield the reverse of sorting it with the opposite order."
-              (&/= (&;sort n.< sample)
-                   (&;reverse (&;sort n.> sample))))
+      (test "Sorting a seq with one order should yield the reverse of sorting it with the opposite order."
+            (&/= (&;sort n.< sample)
+                 (&;reverse (&;sort n.> sample))))
       ))
 
-(test: "Seqs: Part 3"
+(context: "Seqs: Part 3"
   [size bounded-size
    idx (:: @ map (n.% size) R;nat)
    sample (|> (R;list size R;nat)
@@ -107,23 +107,23 @@
    #let [(^open "&/") (&;Eq<Seq> number;Eq<Nat>)
          (^open "&/") &;Monad<Seq>]]
   ($_ seq
-      (assert "Applicative allows you to create singleton seqs, and apply seqs of functions to seqs of values."
-              (and (&/= (&;seq elem) (&/wrap elem))
-                   (&/= (&/map n.inc sample)
-                        (&/apply (&/wrap n.inc) sample))))
+      (test "Applicative allows you to create singleton seqs, and apply seqs of functions to seqs of values."
+            (and (&/= (&;seq elem) (&/wrap elem))
+                 (&/= (&/map n.inc sample)
+                      (&/apply (&/wrap n.inc) sample))))
 
-      (assert "Seq concatenation is a monad."
-              (&/= (&;concat sample other-sample)
-                   (&/join (&;seq sample other-sample))))
+      (test "Seq concatenation is a monad."
+            (&/= (&;concat sample other-sample)
+                 (&/join (&;seq sample other-sample))))
 
-      (assert "You can find any value that satisfies some criterium, if such values exist in the seq."
-              (case (&;find n.even? sample)
-                (#;Some found)
-                (and (n.even? found)
-                     (&;any? n.even? sample)
-                     (not (&;every? (bool;complement n.even?) sample)))
+      (test "You can find any value that satisfies some criterium, if such values exist in the seq."
+            (case (&;find n.even? sample)
+              (#;Some found)
+              (and (n.even? found)
+                   (&;any? n.even? sample)
+                   (not (&;every? (bool;complement n.even?) sample)))
 
-                #;None
-                (and (not (&;any? n.even? sample))
-                     (&;every? (bool;complement n.even?) sample))))
+              #;None
+              (and (not (&;any? n.even? sample))
+                   (&;every? (bool;complement n.even?) sample))))
       ))
diff --git a/stdlib/test/test/lux/data/coll/set.lux b/stdlib/test/test/lux/data/coll/set.lux
index a91813675..23f23121a 100644
--- a/stdlib/test/test/lux/data/coll/set.lux
+++ b/stdlib/test/test/lux/data/coll/set.lux
@@ -13,7 +13,7 @@
   (|> R;nat
       (:: R;Monad<Random> map (n.% +100))))
 
-(test: "Sets"
+(context: "Sets"
   [sizeL gen-nat
    sizeR gen-nat
    setL (R;set number;Hash<Nat> sizeL gen-nat)
@@ -22,41 +22,41 @@
                   (R;filter (. not (&;member? setL))))
    #let [(^open "&/") &;Eq<Set>]]
   ($_ seq
-      (assert "I can query the size of a set."
-              (and (n.= sizeL (&;size setL))
-                   (n.= sizeR (&;size setR))))
-
-      (assert "Converting sets to/from lists can't change their values."
-              (|> setL
-                  &;to-list (&;from-list number;Hash<Nat>)
-                  (&/= setL)))
-
-      (assert "Every set is a sub-set of the union of itself with another."
-              (let [setLR (&;union setL setR)]
-                (and (&;sub? setLR setL)
-                     (&;sub? setLR setR))))
-
-      (assert "Every set is a super-set of the intersection of itself with another."
-              (let [setLR (&;intersection setL setR)]
-                (and (&;super? setLR setL)
-                     (&;super? setLR setR))))
-
-      (assert "Union with the empty set leaves a set unchanged."
-              (&/= setL
-                   (&;union (&;new number;Hash<Nat>)
-                            setL)))
-
-      (assert "Intersection with the empty set results in the empty set."
-              (let [empty-set (&;new number;Hash<Nat>)]
-                (&/= empty-set
-                     (&;intersection empty-set setL))))
-
-      (assert "After substracting a set A from another B, no member of A can be a member of B."
-              (let [sub (&;difference setR setL)]
-                (not (list;any? (&;member? sub) (&;to-list setR)))))
-
-      (assert "Every member of a set must be identifiable."
-              (and (not (&;member? setL non-member))
-                   (&;member? (&;add non-member setL) non-member)
-                   (not (&;member? (&;remove non-member (&;add non-member setL)) non-member))))
+      (test "I can query the size of a set."
+            (and (n.= sizeL (&;size setL))
+                 (n.= sizeR (&;size setR))))
+
+      (test "Converting sets to/from lists can't change their values."
+            (|> setL
+                &;to-list (&;from-list number;Hash<Nat>)
+                (&/= setL)))
+
+      (test "Every set is a sub-set of the union of itself with another."
+            (let [setLR (&;union setL setR)]
+              (and (&;sub? setLR setL)
+                   (&;sub? setLR setR))))
+
+      (test "Every set is a super-set of the intersection of itself with another."
+            (let [setLR (&;intersection setL setR)]
+              (and (&;super? setLR setL)
+                   (&;super? setLR setR))))
+
+      (test "Union with the empty set leaves a set unchanged."
+            (&/= setL
+                 (&;union (&;new number;Hash<Nat>)
+                          setL)))
+
+      (test "Intersection with the empty set results in the empty set."
+            (let [empty-set (&;new number;Hash<Nat>)]
+              (&/= empty-set
+                   (&;intersection empty-set setL))))
+
+      (test "After substracting a set A from another B, no member of A can be a member of B."
+            (let [sub (&;difference setR setL)]
+              (not (list;any? (&;member? sub) (&;to-list setR)))))
+
+      (test "Every member of a set must be identifiable."
+            (and (not (&;member? setL non-member))
+                 (&;member? (&;add non-member setL) non-member)
+                 (not (&;member? (&;remove non-member (&;add non-member setL)) non-member))))
       ))
diff --git a/stdlib/test/test/lux/data/coll/stack.lux b/stdlib/test/test/lux/data/coll/stack.lux
index 6d26c569d..78921b83a 100644
--- a/stdlib/test/test/lux/data/coll/stack.lux
+++ b/stdlib/test/test/lux/data/coll/stack.lux
@@ -13,30 +13,30 @@
   (|> R;nat
       (:: R;Monad<Random> map (n.% +100))))
 
-(test: "Stacks"
+(context: "Stacks"
   [size gen-nat
    sample (R;stack size gen-nat)
    new-top gen-nat]
   ($_ seq
-      (assert "Can query the size of a stack."
-              (n.= size (&;size sample)))
+      (test "Can query the size of a stack."
+            (n.= size (&;size sample)))
 
-      (assert "Can peek inside non-empty stacks."
-              (case (&;peek sample)
-                #;None     (&;empty? sample)
-                (#;Some _) (not (&;empty? sample))))
+      (test "Can peek inside non-empty stacks."
+            (case (&;peek sample)
+              #;None     (&;empty? sample)
+              (#;Some _) (not (&;empty? sample))))
 
-      (assert "Popping empty stacks doesn't change anything.
+      (test "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 (n.= (&;size sample) (n.inc (&;size sample')))
-                    (and (&;empty? sample) (&;empty? sample')))
-                ))
+            (let [sample' (&;pop 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 (is sample
-                       (&;pop (&;push new-top sample)))
-                   (n.= (n.inc (&;size sample)) (&;size (&;push new-top sample)))
-                   (|> (&;push new-top sample) &;peek (default (undefined))
-                       (is new-top))))
+      (test "Pushing onto a stack always increases it by 1, adding a new value at the top."
+            (and (is sample
+                     (&;pop (&;push new-top sample)))
+                 (n.= (n.inc (&;size sample)) (&;size (&;push new-top sample)))
+                 (|> (&;push new-top sample) &;peek (default (undefined))
+                     (is new-top))))
       ))
diff --git a/stdlib/test/test/lux/data/coll/stream.lux b/stdlib/test/test/lux/data/coll/stream.lux
index f68ae60f3..e12293fa7 100644
--- a/stdlib/test/test/lux/data/coll/stream.lux
+++ b/stdlib/test/test/lux/data/coll/stream.lux
@@ -12,7 +12,7 @@
        ["R" math/random])
   lux/test)
 
-(test: "Streams"
+(context: "Streams"
   [size (|> R;nat (:: @ map (|>. (n.% +100) (n.max +2))))
    offset (|> R;nat (:: @ map (n.% +100)))
    factor (|> R;nat (:: @ map (|>. (n.% +100) (n.max +2))))
@@ -23,77 +23,77 @@
          sample0 (&;iterate n.inc +0)
          sample1 (&;iterate n.inc offset)]]
   ($_ seq
-      (assert "Can move along a stream and take slices off it."
-              (and (and (List/= (list;n.range +0 (n.dec size))
-                                (&;take size sample0))
-                        (List/= (list;n.range offset (n.dec (n.+ offset size)))
-                                (&;take size (&;drop offset sample0)))
-                        (let [[drops takes...] (&;split size sample0)]
-                          (and (List/= (list;n.range +0 (n.dec size))
-                                       drops)
-                               (List/= (list;n.range size (n.dec (n.* +2 size)))
-                                       (&;take size takes...)))))
-                   (and (List/= (list;n.range +0 (n.dec size))
-                                (&;take-while (n.< size) sample0))
-                        (List/= (list;n.range offset (n.dec (n.+ offset size)))
-                                (&;take-while (n.< (n.+ offset size))
-                                              (&;drop-while (n.< offset) sample0)))
-                        (let [[drops takes...] (&;split-while (n.< size) sample0)]
-                          (and (List/= (list;n.range +0 (n.dec size))
-                                       drops)
-                               (List/= (list;n.range size (n.dec (n.* +2 size)))
-                                       (&;take-while (n.< (n.* +2 size)) takes...)))))
-                   ))
+      (test "Can move along a stream and take slices off it."
+            (and (and (List/= (list;n.range +0 (n.dec size))
+                              (&;take size sample0))
+                      (List/= (list;n.range offset (n.dec (n.+ offset size)))
+                              (&;take size (&;drop offset sample0)))
+                      (let [[drops takes...] (&;split size sample0)]
+                        (and (List/= (list;n.range +0 (n.dec size))
+                                     drops)
+                             (List/= (list;n.range size (n.dec (n.* +2 size)))
+                                     (&;take size takes...)))))
+                 (and (List/= (list;n.range +0 (n.dec size))
+                              (&;take-while (n.< size) sample0))
+                      (List/= (list;n.range offset (n.dec (n.+ offset size)))
+                              (&;take-while (n.< (n.+ offset size))
+                                            (&;drop-while (n.< offset) sample0)))
+                      (let [[drops takes...] (&;split-while (n.< size) sample0)]
+                        (and (List/= (list;n.range +0 (n.dec size))
+                                     drops)
+                             (List/= (list;n.range size (n.dec (n.* +2 size)))
+                                     (&;take-while (n.< (n.* +2 size)) takes...)))))
+                 ))
 
-      (assert "Can repeat any element and infinite number of times."
-              (n.= elem (&;nth offset (&;repeat elem))))
+      (test "Can repeat any element and infinite number of times."
+            (n.= elem (&;nth offset (&;repeat elem))))
 
-      (assert "Can obtain the head & tail of a stream."
-              (and (n.= offset (&;head sample1))
-                   (List/= (list;n.range (n.inc offset) (n.+ offset size))
-                           (&;take size (&;tail sample1)))))
+      (test "Can obtain the head & tail of a stream."
+            (and (n.= offset (&;head sample1))
+                 (List/= (list;n.range (n.inc offset) (n.+ offset size))
+                         (&;take size (&;tail sample1)))))
 
-      (assert "Can filter streams."
-              (and (n.= (n.* +2 offset)
-                        (&;nth offset
-                               (&;filter n.even? sample0)))
-                   (let [[evens odds] (&;partition n.even? (&;iterate n.inc +0))]
-                     (and (n.= (n.* +2 offset)
-                               (&;nth offset evens))
-                          (n.= (n.inc (n.* +2 offset))
-                               (&;nth offset odds))))))
+      (test "Can filter streams."
+            (and (n.= (n.* +2 offset)
+                      (&;nth offset
+                             (&;filter n.even? sample0)))
+                 (let [[evens odds] (&;partition n.even? (&;iterate n.inc +0))]
+                   (and (n.= (n.* +2 offset)
+                             (&;nth offset evens))
+                        (n.= (n.inc (n.* +2 offset))
+                             (&;nth offset odds))))))
 
-      (assert "Functor goes over 'all' elements in a stream."
-              (let [(^open "&/") &;Functor<Stream>
-                    there (&/map (n.* factor) sample0)
-                    back-again (&/map (n./ factor) there)]
-                (and (not (List/= (&;take size sample0)
-                                  (&;take size there)))
-                     (List/= (&;take size sample0)
-                             (&;take size back-again)))))
+      (test "Functor goes over 'all' elements in a stream."
+            (let [(^open "&/") &;Functor<Stream>
+                  there (&/map (n.* factor) sample0)
+                  back-again (&/map (n./ factor) there)]
+              (and (not (List/= (&;take size sample0)
+                                (&;take size there)))
+                   (List/= (&;take size sample0)
+                           (&;take size back-again)))))
 
-      (assert "CoMonad produces a value for every element in a stream."
-              (let [(^open "&/") &;Functor<Stream>]
-                (List/= (&;take size (&/map (n.* factor) sample1))
-                        (&;take size
-                                (be &;CoMonad<Stream>
-                                  [inputs sample1]
-                                  (n.* factor (&;head inputs)))))))
+      (test "CoMonad produces a value for every element in a stream."
+            (let [(^open "&/") &;Functor<Stream>]
+              (List/= (&;take size (&/map (n.* factor) sample1))
+                      (&;take size
+                              (be &;CoMonad<Stream>
+                                [inputs sample1]
+                                (n.* factor (&;head inputs)))))))
 
-      (assert "'unfold' generalizes 'iterate'."
-              (let [(^open "&/") &;Functor<Stream>
-                    (^open "List/") (list;Eq<List> text;Eq<Text>)]
-                (List/= (&;take size
-                                (&/map Nat/encode (&;iterate n.inc offset)))
-                        (&;take size
-                                (&;unfold (function [n] [(n.inc n) (Nat/encode n)])
-                                          offset)))))
+      (test "'unfold' generalizes 'iterate'."
+            (let [(^open "&/") &;Functor<Stream>
+                  (^open "List/") (list;Eq<List> text;Eq<Text>)]
+              (List/= (&;take size
+                              (&/map Nat/encode (&;iterate n.inc offset)))
+                      (&;take size
+                              (&;unfold (function [n] [(n.inc n) (Nat/encode n)])
+                                        offset)))))
 
-      (assert "Can cycle over the same elements as an infinite stream."
-              (|> (&;cycle cycle-seed)
-                  (default (undefined))
-                  (&;nth cycle-sample-idx)
-                  (n.= (default (undefined)
-                         (list;nth (n.% size cycle-sample-idx)
-                                   cycle-seed)))))
+      (test "Can cycle over the same elements as an infinite stream."
+            (|> (&;cycle cycle-seed)
+                (default (undefined))
+                (&;nth cycle-sample-idx)
+                (n.= (default (undefined)
+                       (list;nth (n.% size cycle-sample-idx)
+                                 cycle-seed)))))
       ))
diff --git a/stdlib/test/test/lux/data/coll/tree/rose.lux b/stdlib/test/test/lux/data/coll/tree/rose.lux
index a4839c2a5..2933452f6 100644
--- a/stdlib/test/test/lux/data/coll/tree/rose.lux
+++ b/stdlib/test/test/lux/data/coll/tree/rose.lux
@@ -13,7 +13,7 @@
   (|> R;nat
       (:: R;Monad<Random> map (n.% +100))))
 
-(test: "Trees"
+(context: "Trees"
   [leaf (:: @ map &;leaf R;nat)
    branchS gen-nat
    branchV R;nat
@@ -22,13 +22,13 @@
    #let [(^open "&/") (&;Eq<Tree> number;Eq<Nat>)
          (^open "List/") (list;Eq<List> number;Eq<Nat>)]]
   ($_ seq
-      (assert "Can compare trees for equality."
-              (and (&/= leaf leaf)
-                   (&/= branch branch)
-                   (not (&/= leaf branch))
-                   (not (&/= leaf (&;branch branchV (List/map &;leaf (list;reverse branchC)))))))
+      (test "Can compare trees for equality."
+            (and (&/= leaf leaf)
+                 (&/= branch branch)
+                 (not (&/= leaf branch))
+                 (not (&/= leaf (&;branch branchV (List/map &;leaf (list;reverse branchC)))))))
 
-      (assert "Can flatten a tree to get all the nodes as a flat tree."
-              (List/= (list& branchV branchC)
-                      (&;flatten branch)))
+      (test "Can flatten a tree to get all the nodes as a flat tree."
+            (List/= (list& branchV branchC)
+                    (&;flatten branch)))
       ))
diff --git a/stdlib/test/test/lux/data/coll/tree/zipper.lux b/stdlib/test/test/lux/data/coll/tree/zipper.lux
index a6799d302..38dd55b99 100644
--- a/stdlib/test/test/lux/data/coll/tree/zipper.lux
+++ b/stdlib/test/test/lux/data/coll/tree/zipper.lux
@@ -28,7 +28,7 @@
       zipper
       (recur (&;next zipper)))))
 
-(test: "Zippers"
+(context: "Zippers"
   [sample gen-tree
    new-val R;nat
    pre-val R;nat
@@ -36,87 +36,87 @@
    #let [(^open "Tree/") (rose;Eq<Tree> number;Eq<Nat>)
          (^open "List/") (list;Eq<List> number;Eq<Nat>)]]
   ($_ seq
-      (assert "Trees can be converted to/from zippers."
-              (|> sample
-                  &;from-tree &;to-tree
-                  (Tree/= sample)))
+      (test "Trees can be converted to/from zippers."
+            (|> sample
+                &;from-tree &;to-tree
+                (Tree/= sample)))
 
-      (assert "Creating a zipper gives you a root node."
-              (|> sample &;from-tree &;root?))
+      (test "Creating a zipper gives you a root node."
+            (|> sample &;from-tree &;root?))
       
-      (assert "Can move down inside branches. Can move up from lower nodes."
-              (let [zipper (&;from-tree sample)]
-                (if (&;branch? zipper)
-                  (let [child (|> zipper &;down)]
-                    (and (not (Tree/= sample (&;to-tree child)))
-                         (|> child &;parent (default (undefined)) (is zipper))
-                         (|> child &;up (is zipper) not)
-                         (|> child &;root (is zipper) not)))
-                  (and (&;leaf? zipper)
-                       (|> zipper (&;prepend-child new-val) &;branch?)))))
+      (test "Can move down inside branches. Can move up from lower nodes."
+            (let [zipper (&;from-tree sample)]
+              (if (&;branch? zipper)
+                (let [child (|> zipper &;down)]
+                  (and (not (Tree/= sample (&;to-tree child)))
+                       (|> child &;parent (default (undefined)) (is zipper))
+                       (|> child &;up (is zipper) not)
+                       (|> child &;root (is zipper) not)))
+                (and (&;leaf? zipper)
+                     (|> zipper (&;prepend-child new-val) &;branch?)))))
 
-      (assert "Can prepend and append children."
-              (let [zipper (&;from-tree sample)]
-                (if (&;branch? zipper)
-                  (let [mid-val (|> zipper &;down &;value)
-                        zipper (|> zipper
-                                   (&;prepend-child pre-val)
-                                   (&;append-child post-val))]
-                    (and (|> zipper &;down &;value (is pre-val))
-                         (|> zipper &;down &;right &;value (is mid-val))
-                         (|> zipper &;down &;right &;right &;value (is post-val))
-                         (|> zipper &;down &;rightmost &;leftmost &;value (is pre-val))
-                         (|> zipper &;down &;right &;left &;value (is pre-val))
-                         (|> zipper &;down &;rightmost &;value (is post-val))))
-                  true)))
+      (test "Can prepend and append children."
+            (let [zipper (&;from-tree sample)]
+              (if (&;branch? zipper)
+                (let [mid-val (|> zipper &;down &;value)
+                      zipper (|> zipper
+                                 (&;prepend-child pre-val)
+                                 (&;append-child post-val))]
+                  (and (|> zipper &;down &;value (is pre-val))
+                       (|> zipper &;down &;right &;value (is mid-val))
+                       (|> zipper &;down &;right &;right &;value (is post-val))
+                       (|> zipper &;down &;rightmost &;leftmost &;value (is pre-val))
+                       (|> zipper &;down &;right &;left &;value (is pre-val))
+                       (|> zipper &;down &;rightmost &;value (is post-val))))
+                true)))
 
-      (assert "Can insert children around a node (unless it's root)."
-              (let [zipper (&;from-tree sample)]
-                (if (&;branch? zipper)
-                  (let [mid-val (|> zipper &;down &;value)
-                        zipper (|> zipper
-                                   &;down
-                                   (&;insert-left pre-val)
-                                   (default (undefined))
-                                   (&;insert-right post-val)
-                                   (default (undefined))
-                                   &;up)]
-                    (and (|> zipper &;down &;value (is pre-val))
-                         (|> zipper &;down &;right &;value (is mid-val))
-                         (|> zipper &;down &;right &;right &;value (is post-val))
-                         (|> zipper &;down &;rightmost &;leftmost &;value (is pre-val))
-                         (|> zipper &;down &;right &;left &;value (is pre-val))
-                         (|> zipper &;down &;rightmost &;value (is post-val))))
-                  (and (|> zipper (&;insert-left pre-val) (case> (#;Some _) false
-                                                                 #;None     true))
-                       (|> zipper (&;insert-right post-val) (case> (#;Some _) false
-                                                                   #;None     true))))))
+      (test "Can insert children around a node (unless it's root)."
+            (let [zipper (&;from-tree sample)]
+              (if (&;branch? zipper)
+                (let [mid-val (|> zipper &;down &;value)
+                      zipper (|> zipper
+                                 &;down
+                                 (&;insert-left pre-val)
+                                 (default (undefined))
+                                 (&;insert-right post-val)
+                                 (default (undefined))
+                                 &;up)]
+                  (and (|> zipper &;down &;value (is pre-val))
+                       (|> zipper &;down &;right &;value (is mid-val))
+                       (|> zipper &;down &;right &;right &;value (is post-val))
+                       (|> zipper &;down &;rightmost &;leftmost &;value (is pre-val))
+                       (|> zipper &;down &;right &;left &;value (is pre-val))
+                       (|> zipper &;down &;rightmost &;value (is post-val))))
+                (and (|> zipper (&;insert-left pre-val) (case> (#;Some _) false
+                                                               #;None     true))
+                     (|> zipper (&;insert-right post-val) (case> (#;Some _) false
+                                                                 #;None     true))))))
       
-      (assert "Can set and update the value of a node."
-              (|> sample &;from-tree (&;set new-val) &;value (n.= new-val)))
+      (test "Can set and update the value of a node."
+            (|> sample &;from-tree (&;set new-val) &;value (n.= new-val)))
 
-      (assert "Zipper traversal follows the outline of the tree depth-first."
-              (List/= (rose;flatten sample)
-                      (loop [zipper (&;from-tree sample)]
-                        (if (&;end? zipper)
-                          (list (&;value zipper))
-                          (#;Cons (&;value zipper)
-                                  (recur (&;next zipper)))))))
+      (test "Zipper traversal follows the outline of the tree depth-first."
+            (List/= (rose;flatten sample)
+                    (loop [zipper (&;from-tree sample)]
+                      (if (&;end? zipper)
+                        (list (&;value zipper))
+                        (#;Cons (&;value zipper)
+                                (recur (&;next zipper)))))))
 
-      (assert "Backwards zipper traversal yield reverse tree flatten."
-              (List/= (list;reverse (rose;flatten sample))
-                      (loop [zipper (to-end (&;from-tree sample))]
-                        (if (&;root? zipper)
-                          (list (&;value zipper))
-                          (#;Cons (&;value zipper)
-                                  (recur (&;prev zipper)))))))
+      (test "Backwards zipper traversal yield reverse tree flatten."
+            (List/= (list;reverse (rose;flatten sample))
+                    (loop [zipper (to-end (&;from-tree sample))]
+                      (if (&;root? zipper)
+                        (list (&;value zipper))
+                        (#;Cons (&;value zipper)
+                                (recur (&;prev zipper)))))))
 
-      (assert "Can remove nodes (except root nodes)."
-              (let [zipper (&;from-tree sample)]
-                (if (&;branch? zipper)
-                  (and (|> zipper &;down &;root? not)
-                       (|> zipper &;down &;remove (case> #;None false
-                                                         (#;Some node) (&;root? node))))
-                  (|> zipper &;remove (case> #;None     true
-                                             (#;Some _) false)))))
+      (test "Can remove nodes (except root nodes)."
+            (let [zipper (&;from-tree sample)]
+              (if (&;branch? zipper)
+                (and (|> zipper &;down &;root? not)
+                     (|> zipper &;down &;remove (case> #;None false
+                                                       (#;Some node) (&;root? node))))
+                (|> zipper &;remove (case> #;None     true
+                                           (#;Some _) false)))))
       ))
diff --git a/stdlib/test/test/lux/data/coll/vector.lux b/stdlib/test/test/lux/data/coll/vector.lux
index 6ad6934db..2816c904e 100644
--- a/stdlib/test/test/lux/data/coll/vector.lux
+++ b/stdlib/test/test/lux/data/coll/vector.lux
@@ -10,7 +10,7 @@
        ["R" math/random])
   lux/test)
 
-(test: "Vectors"
+(context: "Vectors"
   [size (|> R;nat (:: @ map (|>. (n.% +100) (n.max +1))))
    idx (|> R;nat (:: @ map (n.% size)))
    sample (R;vector size R;nat)
@@ -21,51 +21,51 @@
          (^open "&/") &;Fold<Vector>
          (^open "&/") &;Monoid<Vector>]]
   ($_ seq
-      (assert "Can query size of vector."
-              (if (&;empty? sample)
-                (and (n.= +0 size)
-                     (n.= +0 (&;size sample)))
-                (n.= size (&;size sample))))
+      (test "Can query size of vector."
+            (if (&;empty? sample)
+              (and (n.= +0 size)
+                   (n.= +0 (&;size sample)))
+              (n.= size (&;size sample))))
 
-      (assert "Can add and remove elements to vectors."
-              (and (n.= (n.inc size) (&;size (&;add non-member sample)))
-                   (n.= (n.dec size) (&;size (&;pop sample)))))
+      (test "Can add and remove elements to vectors."
+            (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
-                  (&;put idx non-member)
-                  (&;nth idx)
-                  (default (undefined))
-                  (is non-member)))
+      (test "Can put and get elements into vectors."
+            (|> sample
+                (&;put idx non-member)
+                (&;nth idx)
+                (default (undefined))
+                (is non-member)))
 
-      (assert "Can update elements of vectors."
-              (|> sample
-                  (&;put idx non-member) (&;update idx n.inc)
-                  (&;nth idx) (default (undefined))
-                  (n.= (n.inc non-member))))
+      (test "Can update elements of vectors."
+            (|> sample
+                (&;put idx non-member) (&;update idx n.inc)
+                (&;nth idx) (default (undefined))
+                (n.= (n.inc non-member))))
 
-      (assert "Can safely transform to/from lists."
-              (|> sample &;to-list &;from-list (&/= sample)))
+      (test "Can safely transform to/from lists."
+            (|> sample &;to-list &;from-list (&/= sample)))
 
-      (assert "Can identify members of a vector."
-              (and (not (&;member? number;Eq<Nat> sample non-member))
-                   (&;member? number;Eq<Nat> (&;add non-member sample) non-member)))
+      (test "Can identify members of a vector."
+            (and (not (&;member? number;Eq<Nat> sample non-member))
+                 (&;member? number;Eq<Nat> (&;add non-member sample) non-member)))
 
-      (assert "Can fold over elements of vector."
-              (n.= (List/fold n.+ +0 (&;to-list sample))
-                   (&/fold n.+ +0 sample)))
+      (test "Can fold over elements of vector."
+            (n.= (List/fold n.+ +0 (&;to-list sample))
+                 (&/fold n.+ +0 sample)))
       
-      (assert "Functor goes over every element."
-              (let [there (&/map n.inc sample)
-                    back-again (&/map n.dec there)]
-                (and (not (&/= sample there))
-                     (&/= sample back-again))))
+      (test "Functor goes over every element."
+            (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 n.inc sample)  (&/apply (&/wrap n.inc) sample))))
+      (test "Applicative allows you to create singleton vectors, and apply vectors of functions to vectors of values."
+            (and (&/= (&;vector non-member) (&/wrap non-member))
+                 (&/= (&/map n.inc sample)  (&/apply (&/wrap n.inc) sample))))
 
-      (assert "Vector concatenation is a monad."
-              (&/= (&/append sample other-sample)
-                   (&/join (&;vector sample other-sample))))
+      (test "Vector concatenation is a monad."
+            (&/= (&/append sample other-sample)
+                 (&/join (&;vector sample other-sample))))
       ))
diff --git a/stdlib/test/test/lux/data/format/json.lux b/stdlib/test/test/lux/data/format/json.lux
index 88e4603d8..e133ef87d 100644
--- a/stdlib/test/test/lux/data/format/json.lux
+++ b/stdlib/test/test/lux/data/format/json.lux
@@ -38,21 +38,21 @@
                  (r;dict text;Hash<Text> size (r;text size) gen-json)
                  )))))
 
-(test: "JSON"
+(context: "JSON"
   [sample gen-json
    #let [(^open "&/") &;Eq<JSON>
          (^open "&/") &;Codec<Text,JSON>]]
   ($_ seq
-      (assert "Every JSON is equal to itself."
-              (&/= sample sample))
+      (test "Every JSON is equal to itself."
+            (&/= sample sample))
 
-      (assert "Can encode/decode JSON."
-              (|> sample &/encode &/decode
-                  (case> (#;Right result)
-                         (&/= sample result)
+      (test "Can encode/decode JSON."
+            (|> sample &/encode &/decode
+                (case> (#;Right result)
+                       (&/= sample result)
 
-                         (#;Left _)
-                         false)))
+                       (#;Left _)
+                       false)))
       ))
 
 (type: Variant
@@ -125,14 +125,14 @@
            (:: (d;Eq<Dict> i.=) = (get@ #dict recL) (get@ #dict recR))
            ))))
 
-(test: "Polytypism"
+(context: "Polytypism"
   [sample gen-record
    #let [(^open "&/") Eq<Record>
          (^open "&/") Codec<JSON,Record>]]
-  (assert "Can encode/decode arbitrary types."
-          (|> sample &/encode &/decode
-              (case> (#;Right result)
-                     (&/= sample result)
+  (test "Can encode/decode arbitrary types."
+        (|> sample &/encode &/decode
+            (case> (#;Right result)
+                   (&/= sample result)
 
-                     (#;Left _)
-                     false))))
+                   (#;Left _)
+                   false))))
diff --git a/stdlib/test/test/lux/data/format/xml.lux b/stdlib/test/test/lux/data/format/xml.lux
index 16c586d63..414f19941 100644
--- a/stdlib/test/test/lux/data/format/xml.lux
+++ b/stdlib/test/test/lux/data/format/xml.lux
@@ -48,19 +48,19 @@
                         (R;dict ident;Hash<Ident> size xml-identifier^ (xml-text^ +0 +10))
                         (R;list size gen-xml)))))))
 
-(test: "XML"
+(context: "XML"
   [sample gen-xml
    #let [(^open "&/") &;Eq<XML>
          (^open "&/") &;Codec<Text,XML>]]
   ($_ seq
-      (assert "Every XML is equal to itself."
-              (&/= sample sample))
+      (test "Every XML is equal to itself."
+            (&/= sample sample))
 
-      (assert "Can encode/decode XML."
-              (|> sample &/encode &/decode
-                  (case> (#;Right result)
-                         (&/= sample result)
+      (test "Can encode/decode XML."
+            (|> sample &/encode &/decode
+                (case> (#;Right result)
+                       (&/= sample result)
 
-                         (#;Left error)
-                         false)))
+                       (#;Left error)
+                       false)))
       ))
diff --git a/stdlib/test/test/lux/data/ident.lux b/stdlib/test/test/lux/data/ident.lux
index 07aaf8d0a..060007607 100644
--- a/stdlib/test/test/lux/data/ident.lux
+++ b/stdlib/test/test/lux/data/ident.lux
@@ -13,7 +13,7 @@
   (-> Nat (R;Random Text))
   (|> (R;text size) (R;filter (. not (text;contains? ";")))))
 
-(test: "Idents"
+(context: "Idents"
   [## First Ident
    sizeM1 (|> R;nat (:: @ map (n.% +100)))
    sizeN1 (|> R;nat (:: @ map (|>. (n.% +100) (n.max +1))))
@@ -29,41 +29,41 @@
    #let [(^open "&/") &;Eq<Ident>
          (^open "&/") &;Codec<Text,Ident>]]
   ($_ seq
-      (assert "Can get the module & name parts of an ident."
-              (and (is module1 (&;module ident1))
-                   (is name1 (&;name ident1))))
+      (test "Can get the module & name parts of an ident."
+            (and (is module1 (&;module ident1))
+                 (is name1 (&;name ident1))))
 
-      (assert "Can compare idents for equality."
-              (and (&/= ident1 ident1)
-                   (if (&/= ident1 ident2)
-                     (and (Text/= module1 module2)
-                          (Text/= name1 name2))
-                     (or (not (Text/= module1 module2))
-                         (not (Text/= name1 name2))))))
+      (test "Can compare idents for equality."
+            (and (&/= ident1 ident1)
+                 (if (&/= ident1 ident2)
+                   (and (Text/= module1 module2)
+                        (Text/= name1 name2))
+                   (or (not (Text/= module1 module2))
+                       (not (Text/= name1 name2))))))
 
-      (assert "Can encode idents as text."
-              (|> ident1
-                  &/encode &/decode
-                  (case> (#;Right dec-ident) (&/= ident1 dec-ident)
-                         _ false)))
+      (test "Can encode idents as text."
+            (|> ident1
+                &/encode &/decode
+                (case> (#;Right dec-ident) (&/= ident1 dec-ident)
+                       _ false)))
 
-      (assert "Encoding an ident without a module component results in text equal to the name of the ident."
-              (if (text;empty? module1)
-                (Text/= name1 (&/encode ident1))
-                true))
+      (test "Encoding an ident without a module component results in text equal to the name of the ident."
+            (if (text;empty? module1)
+              (Text/= name1 (&/encode ident1))
+              true))
       ))
 
-(test: "Ident-related macros."
+(context: "Ident-related macros."
   (let [(^open "&/") &;Eq<Ident>]
     ($_ seq
-        (assert "Can obtain Ident from symbol."
-                (and (&/= ["lux" "yolo"] (ident-for ;yolo))
-                     (&/= ["test/lux/data/ident" "yolo"] (ident-for ;;yolo))
-                     (&/= ["" "yolo"] (ident-for yolo))
-                     (&/= ["lux/test" "yolo"] (ident-for lux/test;yolo))))
+        (test "Can obtain Ident from symbol."
+              (and (&/= ["lux" "yolo"] (ident-for ;yolo))
+                   (&/= ["test/lux/data/ident" "yolo"] (ident-for ;;yolo))
+                   (&/= ["" "yolo"] (ident-for yolo))
+                   (&/= ["lux/test" "yolo"] (ident-for lux/test;yolo))))
         
-        (assert "Can obtain Ident from tag."
-                (and (&/= ["lux" "yolo"] (ident-for #;yolo))
-                     (&/= ["test/lux/data/ident" "yolo"] (ident-for #;;yolo))
-                     (&/= ["" "yolo"] (ident-for #yolo))
-                     (&/= ["lux/test" "yolo"] (ident-for #lux/test;yolo)))))))
+        (test "Can obtain Ident from tag."
+              (and (&/= ["lux" "yolo"] (ident-for #;yolo))
+                   (&/= ["test/lux/data/ident" "yolo"] (ident-for #;;yolo))
+                   (&/= ["" "yolo"] (ident-for #yolo))
+                   (&/= ["lux/test" "yolo"] (ident-for #lux/test;yolo)))))))
diff --git a/stdlib/test/test/lux/data/identity.lux b/stdlib/test/test/lux/data/identity.lux
index 227072da2..5995f1ae2 100644
--- a/stdlib/test/test/lux/data/identity.lux
+++ b/stdlib/test/test/lux/data/identity.lux
@@ -7,29 +7,29 @@
              [text "Text/" Monoid<Text> Eq<Text>]))
   lux/test)
 
-(test: "Identity"
+(context: "Identity"
   (let [(^open "&/") &;Monad<Identity>
         (^open "&/") &;CoMonad<Identity>]
     ($_ seq
-        (assert "Functor does not affect values."
-                (Text/= "yololol" (&/map (Text/append "yolo") "lol")))
+        (test "Functor does not affect values."
+              (Text/= "yololol" (&/map (Text/append "yolo") "lol")))
         
-        (assert "Applicative does not affect values."
-                (and (Text/= "yolo" (&/wrap "yolo"))
-                     (Text/= "yololol" (&/apply (&/wrap (Text/append "yolo")) (&/wrap "lol")))))
+        (test "Applicative does not affect values."
+              (and (Text/= "yolo" (&/wrap "yolo"))
+                   (Text/= "yololol" (&/apply (&/wrap (Text/append "yolo")) (&/wrap "lol")))))
         
-        (assert "Monad does not affect values."
-                (Text/= "yololol" (do &;Monad<Identity>
-                                    [f (wrap Text/append)
-                                     a (wrap "yolo")
-                                     b (wrap "lol")]
-                                    (wrap (f a b)))))
+        (test "Monad does not affect values."
+              (Text/= "yololol" (do &;Monad<Identity>
+                                  [f (wrap Text/append)
+                                   a (wrap "yolo")
+                                   b (wrap "lol")]
+                                  (wrap (f a b)))))
         
-        (assert "CoMonad does not affect values."
-                (and (Text/= "yololol" (&/unwrap "yololol"))
-                     (Text/= "yololol" (be &;CoMonad<Identity>
-                                         [f Text/append
-                                          a "yolo"
-                                          b "lol"]
-                                         (f a b)))))
+        (test "CoMonad does not affect values."
+              (and (Text/= "yololol" (&/unwrap "yololol"))
+                   (Text/= "yololol" (be &;CoMonad<Identity>
+                                       [f Text/append
+                                        a "yolo"
+                                        b "lol"]
+                                       (f a b)))))
         )))
diff --git a/stdlib/test/test/lux/data/log.lux b/stdlib/test/test/lux/data/log.lux
index ea174fc6b..959d1a65f 100644
--- a/stdlib/test/test/lux/data/log.lux
+++ b/stdlib/test/test/lux/data/log.lux
@@ -9,35 +9,35 @@
              [product]))
   lux/test)
 
-(test: "Logs"
+(context: "Logs"
   (let [(^open "&/") (&;Monad<Log> text;Monoid<Text>)]
     ($_ seq
-        (assert "Functor respects Log."
-                (i.= 11 (product;right (&/map i.inc ["" 10]))))
+        (test "Functor respects Log."
+              (i.= 11 (product;right (&/map i.inc ["" 10]))))
         
-        (assert "Applicative respects Log."
-                (and (i.= 20 (product;right (&/wrap 20)))
-                     (i.= 30 (product;right (&/apply (&/wrap (i.+ 10)) (&/wrap 20))))))
+        (test "Applicative respects Log."
+              (and (i.= 20 (product;right (&/wrap 20)))
+                   (i.= 30 (product;right (&/apply (&/wrap (i.+ 10)) (&/wrap 20))))))
         
-        (assert "Monad respects Log."
-                (i.= 30 (product;right (do (&;Monad<Log> text;Monoid<Text>)
-                                         [f (wrap i.+)
-                                          a (wrap 10)
-                                          b (wrap 20)]
-                                         (wrap (f a b))))))
+        (test "Monad respects Log."
+              (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"))))
+        (test "Can log any value."
+              (Text/= "YOLO" (product;left (&;log "YOLO"))))
         )))
 
-(test: "Monad transformer"
+(context: "Monad transformer"
   (let [lift (&;lift-log text;Monoid<Text> io;Monad<IO>)
         (^open "io/") io;Monad<IO>]
-    (assert "Can add log functionality to any monad."
-            (|> (io;run (do (&;LogT text;Monoid<Text> io;Monad<IO>)
-                          [a (lift (io/wrap 123))
-                           b (wrap 456)]
-                          (wrap (i.+ a b))))
-                (case> ["" 579] true
-                       _ false)))
+    (test "Can add log functionality to any monad."
+          (|> (io;run (do (&;LogT text;Monoid<Text> io;Monad<IO>)
+                        [a (lift (io/wrap 123))
+                         b (wrap 456)]
+                        (wrap (i.+ a b))))
+              (case> ["" 579] true
+                     _ false)))
     ))
diff --git a/stdlib/test/test/lux/data/maybe.lux b/stdlib/test/test/lux/data/maybe.lux
index 8cfb4c38f..85ce7be83 100644
--- a/stdlib/test/test/lux/data/maybe.lux
+++ b/stdlib/test/test/lux/data/maybe.lux
@@ -8,49 +8,49 @@
              [number]))
   lux/test)
 
-(test: "Maybe"
+(context: "Maybe"
   (let [(^open "&/") &;Monoid<Maybe>
         (^open "&/") &;Monad<Maybe>
         (^open "Maybe/") (&;Eq<Maybe> text;Eq<Text>)]
     ($_ seq
-        (assert "Can compare Maybe values."
-                (and (Maybe/= #;None #;None)
-                     (Maybe/= (#;Some "yolo") (#;Some "yolo"))
-                     (not (Maybe/= (#;Some "yolo") (#;Some "lol")))
-                     (not (Maybe/= (#;Some "yolo") #;None))))
+        (test "Can compare Maybe values."
+              (and (Maybe/= #;None #;None)
+                   (Maybe/= (#;Some "yolo") (#;Some "yolo"))
+                   (not (Maybe/= (#;Some "yolo") (#;Some "lol")))
+                   (not (Maybe/= (#;Some "yolo") #;None))))
 
-        (assert "Monoid respects Maybe."
-                (and (Maybe/= #;None &/unit)
-                     (Maybe/= (#;Some "yolo") (&/append (#;Some "yolo") (#;Some "lol")))
-                     (Maybe/= (#;Some "yolo") (&/append (#;Some "yolo") #;None))
-                     (Maybe/= (#;Some "lol") (&/append #;None (#;Some "lol")))
-                     (Maybe/= #;None (: (Maybe Text) (&/append #;None #;None)))))
+        (test "Monoid respects Maybe."
+              (and (Maybe/= #;None &/unit)
+                   (Maybe/= (#;Some "yolo") (&/append (#;Some "yolo") (#;Some "lol")))
+                   (Maybe/= (#;Some "yolo") (&/append (#;Some "yolo") #;None))
+                   (Maybe/= (#;Some "lol") (&/append #;None (#;Some "lol")))
+                   (Maybe/= #;None (: (Maybe Text) (&/append #;None #;None)))))
         
-        (assert "Functor respects Maybe."
-                (and (Maybe/= #;None (&/map (Text/append "yolo") #;None))
-                     (Maybe/= (#;Some "yololol") (&/map (Text/append "yolo") (#;Some "lol")))))
+        (test "Functor respects Maybe."
+              (and (Maybe/= #;None (&/map (Text/append "yolo") #;None))
+                   (Maybe/= (#;Some "yololol") (&/map (Text/append "yolo") (#;Some "lol")))))
         
-        (assert "Applicative respects Maybe."
-                (and (Maybe/= (#;Some "yolo") (&/wrap "yolo"))
-                     (Maybe/= (#;Some "yololol")
-                              (&/apply (&/wrap (Text/append "yolo")) (&/wrap "lol")))))
+        (test "Applicative respects Maybe."
+              (and (Maybe/= (#;Some "yolo") (&/wrap "yolo"))
+                   (Maybe/= (#;Some "yololol")
+                            (&/apply (&/wrap (Text/append "yolo")) (&/wrap "lol")))))
         
-        (assert "Monad respects Maybe."
-                (Maybe/= (#;Some "yololol")
-                         (do &;Monad<Maybe>
-                           [f (wrap Text/append)
-                            a (wrap "yolo")
-                            b (wrap "lol")]
-                           (wrap (f a b)))))
+        (test "Monad respects Maybe."
+              (Maybe/= (#;Some "yololol")
+                       (do &;Monad<Maybe>
+                         [f (wrap Text/append)
+                          a (wrap "yolo")
+                          b (wrap "lol")]
+                         (wrap (f a b)))))
         )))
 
-(test: "Monad transformer"
+(context: "Monad transformer"
   (let [lift (&;lift-maybe io;Monad<IO>)
         (^open "io/") io;Monad<IO>]
-    (assert "Can add maybe functionality to any monad."
-            (|> (io;run (do (&;MaybeT io;Monad<IO>)
-                          [a (lift (io/wrap 123))
-                           b (wrap 456)]
-                          (wrap (i.+ a b))))
-                (case> (#;Some 579) true
-                       _ false)))))
+    (test "Can add maybe functionality to any monad."
+          (|> (io;run (do (&;MaybeT io;Monad<IO>)
+                        [a (lift (io/wrap 123))
+                         b (wrap 456)]
+                        (wrap (i.+ a b))))
+              (case> (#;Some 579) true
+                     _ false)))))
diff --git a/stdlib/test/test/lux/data/number.lux b/stdlib/test/test/lux/data/number.lux
index 378731fbf..5e8f9a384 100644
--- a/stdlib/test/test/lux/data/number.lux
+++ b/stdlib/test/test/lux/data/number.lux
@@ -10,13 +10,13 @@
   lux/test)
 
 (do-template [category rand-gen <Eq> <Order>]
-  [(test: (format "[" category "] " "Eq & Order")
+  [(context: (format "[" category "] " "Eq & Order")
      [x rand-gen
       y rand-gen]
-     (assert "" (and (:: <Eq> = x x)
-                     (or (:: <Eq> = x y)
-                         (:: <Order> < y x)
-                         (:: <Order> > y x)))))]
+     (test "" (and (:: <Eq> = x x)
+                   (or (:: <Eq> = x y)
+                       (:: <Order> < y x)
+                       (:: <Order> > y x)))))]
 
   ["Nat"  R;nat  Eq<Nat>  Order<Nat>]
   ["Int"  R;int  Eq<Int>  Order<Int>]
@@ -25,19 +25,19 @@
   )
 
 (do-template [category rand-gen <Number> <Order>]
-  [(test: (format "[" category "] " "Number")
+  [(context: (format "[" category "] " "Number")
      [x rand-gen
       #let [(^open) <Number>
             (^open) <Order>]]
-     (assert "" (and (>= x (abs x))
-                     ## abs(0.0) == 0.0 && negate(abs(0.0)) == -0.0
-                     (or (Text/= "Real" category)
-                         (not (= x (negate x))))
-                     (= x (negate (negate x)))
-                     ## There is loss of precision when multiplying
-                     (or (Text/= "Deg" category)
-                         (= x (* (signum x)
-                                 (abs x)))))))]
+     (test "" (and (>= x (abs x))
+                   ## abs(0.0) == 0.0 && negate(abs(0.0)) == -0.0
+                   (or (Text/= "Real" category)
+                       (not (= x (negate x))))
+                   (= x (negate (negate x)))
+                   ## There is loss of precision when multiplying
+                   (or (Text/= "Deg" category)
+                       (= x (* (signum x)
+                               (abs x)))))))]
 
   ## ["Nat"  R;nat  Number<Nat>]
   ["Int"  R;int  Number<Int>  Order<Int>]
@@ -46,32 +46,32 @@
   )
 
 (do-template [category rand-gen <Enum> <Number> <Order>]
-  [(test: (format "[" category "] " "Enum")
+  [(context: (format "[" category "] " "Enum")
      [x rand-gen]
-     (assert "" (let [(^open) <Number>
-                      (^open) <Order>]
-                  (and (> x
-                          (:: <Enum> succ x))
-                       (< x
-                          (:: <Enum> pred x))
-                       
-                       (= x
-                          (|> x (:: <Enum> pred) (:: <Enum> succ)))
-                       (= x
-                          (|> x (:: <Enum> succ) (:: <Enum> pred)))
-                       ))))]
+     (test "" (let [(^open) <Number>
+                    (^open) <Order>]
+                (and (> x
+                        (:: <Enum> succ x))
+                     (< x
+                        (:: <Enum> pred x))
+                     
+                     (= x
+                        (|> x (:: <Enum> pred) (:: <Enum> succ)))
+                     (= x
+                        (|> x (:: <Enum> succ) (:: <Enum> pred)))
+                     ))))]
 
   ["Nat"  R;nat Enum<Nat> Number<Nat> Order<Nat>]
   ["Int"  R;int Enum<Int> Number<Int> Order<Int>]
   )
 
 (do-template [category rand-gen <Number> <Order> <Interval> <test>]
-  [(test: (format "[" category "] " "Interval")
+  [(context: (format "[" category "] " "Interval")
      [x (|> rand-gen (R;filter <test>))
       #let [(^open) <Number>
             (^open) <Order>]]
-     (assert "" (and (<= x (:: <Interval> bottom))
-                     (>= x (:: <Interval> top)))))]
+     (test "" (and (<= x (:: <Interval> bottom))
+                   (>= x (:: <Interval> top)))))]
 
   ["Nat"  R;nat  Number<Nat>  Order<Nat>  Interval<Nat>  (function [_] true)]
   ["Int"  R;int  Number<Int>  Order<Int>  Interval<Int>  (function [_] true)]
@@ -81,15 +81,15 @@
   )
 
 (do-template [category rand-gen <Number> <Order> <Monoid> <cap> <test>]
-  [(test: (format "[" category "] " "Monoid")
+  [(context: (format "[" category "] " "Monoid")
      [x (|> rand-gen (:: @ map (|>. (:: <Number> abs) <cap>)) (R;filter <test>))
       #let [(^open) <Number>
             (^open) <Order>
             (^open) <Monoid>]]
-     (assert "Appending to unit doesn't change the value."
-             (and (= x (append unit x))
-                  (= x (append x unit))
-                  (= unit (append unit unit)))))]
+     (test "Appending to unit doesn't change the value."
+           (and (= x (append unit x))
+                (= x (append x unit))
+                (= unit (append unit unit)))))]
 
   ["Nat/Add"  R;nat  Number<Nat>  Order<Nat>  Add@Monoid<Nat>  (n.% +1000)  (function [_] true)]
   ["Nat/Mul"  R;nat  Number<Nat>  Order<Nat>  Mul@Monoid<Nat>  (n.% +1000)  (function [_] true)]
@@ -110,17 +110,17 @@
   )
 
 (do-template [<category> <rand-gen> <Eq> <Codec>]
-  [(test: (format "[" <category> "] " "Alternative formats")
+  [(context: (format "[" <category> "] " "Alternative formats")
      [x <rand-gen>]
-     (assert "Can encode/decode values."
-             (|> x
-                 (:: <Codec> encode)
-                 (:: <Codec> decode)
-                 (case> (#;Right x')
-                        (:: <Eq> = x x')
+     (test "Can encode/decode values."
+           (|> x
+               (:: <Codec> encode)
+               (:: <Codec> decode)
+               (case> (#;Right x')
+                      (:: <Eq> = x x')
 
-                        (#;Left _)
-                        false))))]
+                      (#;Left _)
+                      false))))]
 
   ["Nat/Binary"   R;nat  Eq<Nat>  Binary@Codec<Text,Nat>]
   ["Nat/Octal"    R;nat  Eq<Nat>  Octal@Codec<Text,Nat>]
@@ -143,9 +143,9 @@
   ["Real/Hex"     R;real Eq<Real> Hex@Codec<Text,Real>]
   )
 
-(test: "Can convert real values to/from their bit patterns."
+(context: "Can convert real values to/from their bit patterns."
   [raw R;real
    factor (|> R;nat (:: @ map (|>. (n.% +1000) (n.max +1))))
    #let [sample (|> factor nat-to-int int-to-real (r.* raw))]]
-  (assert "Can convert real values to/from their bit patterns."
-          (|> sample real-to-bits bits-to-real (r.= sample))))
+  (test "Can convert real values to/from their bit patterns."
+        (|> sample real-to-bits bits-to-real (r.= sample))))
diff --git a/stdlib/test/test/lux/data/number/complex.lux b/stdlib/test/test/lux/data/number/complex.lux
index 9555c031e..ad5401270 100644
--- a/stdlib/test/test/lux/data/number/complex.lux
+++ b/stdlib/test/test/lux/data/number/complex.lux
@@ -43,157 +43,157 @@
      imaginary gen-dim]
     (wrap (&;complex real imaginary))))
 
-(test: "Construction"
+(context: "Construction"
   [real gen-dim
    imaginary gen-dim]
   ($_ seq
-      (assert "Can build and tear apart complex numbers"
-              (let [r+i (&;complex real imaginary)]
-                (and (r.= real (get@ #&;real r+i))
-                     (r.= imaginary (get@ #&;imaginary r+i)))))
-
-      (assert "If either the real part or the imaginary part is NaN, the composite is NaN."
-              (and (&;not-a-number? (&;complex number;not-a-number imaginary))
-                   (&;not-a-number? (&;complex real number;not-a-number))))
+      (test "Can build and tear apart complex numbers"
+            (let [r+i (&;complex real imaginary)]
+              (and (r.= real (get@ #&;real r+i))
+                   (r.= imaginary (get@ #&;imaginary r+i)))))
+
+      (test "If either the real part or the imaginary part is NaN, the composite is NaN."
+            (and (&;not-a-number? (&;complex number;not-a-number imaginary))
+                 (&;not-a-number? (&;complex real number;not-a-number))))
       ))
 
-(test: "Absolute value"
+(context: "Absolute value"
   [real gen-dim
    imaginary gen-dim]
   ($_ seq
-      (assert "Absolute value of complex >= absolute value of any of the parts."
-              (let [r+i (&;complex real imaginary)
-                    abs (get@ #&;real (&;c.abs r+i))]
-                (and (r.>= (r/abs real) abs)
-                     (r.>= (r/abs imaginary) abs))))
-
-      (assert "The absolute value of a complex number involving a NaN on either dimension, results in a NaN value."
-              (and (number;not-a-number? (get@ #&;real (&;c.abs (&;complex number;not-a-number imaginary))))
-                   (number;not-a-number? (get@ #&;real (&;c.abs (&;complex real number;not-a-number))))))
-
-      (assert "The absolute value of a complex number involving an infinity on either dimension, results in an infinite value."
-              (and (r.= number;positive-infinity (get@ #&;real (&;c.abs (&;complex number;positive-infinity imaginary))))
-                   (r.= number;positive-infinity (get@ #&;real (&;c.abs (&;complex real number;positive-infinity))))
-                   (r.= number;positive-infinity (get@ #&;real (&;c.abs (&;complex number;negative-infinity imaginary))))
-                   (r.= number;positive-infinity (get@ #&;real (&;c.abs (&;complex real number;negative-infinity))))))
+      (test "Absolute value of complex >= absolute value of any of the parts."
+            (let [r+i (&;complex real imaginary)
+                  abs (get@ #&;real (&;c.abs r+i))]
+              (and (r.>= (r/abs real) abs)
+                   (r.>= (r/abs imaginary) abs))))
+
+      (test "The absolute value of a complex number involving a NaN on either dimension, results in a NaN value."
+            (and (number;not-a-number? (get@ #&;real (&;c.abs (&;complex number;not-a-number imaginary))))
+                 (number;not-a-number? (get@ #&;real (&;c.abs (&;complex real number;not-a-number))))))
+
+      (test "The absolute value of a complex number involving an infinity on either dimension, results in an infinite value."
+            (and (r.= number;positive-infinity (get@ #&;real (&;c.abs (&;complex number;positive-infinity imaginary))))
+                 (r.= number;positive-infinity (get@ #&;real (&;c.abs (&;complex real number;positive-infinity))))
+                 (r.= number;positive-infinity (get@ #&;real (&;c.abs (&;complex number;negative-infinity imaginary))))
+                 (r.= number;positive-infinity (get@ #&;real (&;c.abs (&;complex real number;negative-infinity))))))
       ))
 
-(test: "Addidion, substraction, multiplication and division"
+(context: "Addidion, substraction, multiplication and division"
   [x gen-complex
    y gen-complex
    factor gen-dim]
   ($_ seq
-      (assert "Adding 2 complex numbers is the same as adding their parts."
-              (let [z (&;c.+ y x)]
-                (and (&;c.= z
-                            (&;complex (r.+ (get@ #&;real y)
-                                            (get@ #&;real x))
-                                       (r.+ (get@ #&;imaginary y)
-                                            (get@ #&;imaginary x)))))))
-
-      (assert "Subtracting 2 complex numbers is the same as adding their parts."
-              (let [z (&;c.- y x)]
-                (and (&;c.= z
-                            (&;complex (r.- (get@ #&;real y)
-                                            (get@ #&;real x))
-                                       (r.- (get@ #&;imaginary y)
-                                            (get@ #&;imaginary x)))))))
-
-      (assert "Subtraction is the inverse of addition."
-              (and (|> x (&;c.+ y) (&;c.- y) (within? margin-of-error x))
-                   (|> x (&;c.- y) (&;c.+ y) (within? margin-of-error x))))
-
-      (assert "Division is the inverse of multiplication."
-              (|> x (&;c.* y) (&;c./ y) (within? margin-of-error x)))
-
-      (assert "Scalar division is the inverse of scalar multiplication."
-              (|> x (&;c.*' factor) (&;c./' factor) (within? margin-of-error x)))
-
-      (assert "If you subtract the remainder, all divisions must be exact."
-              (let [rem (&;c.% y x)
-                    quotient (|> x (&;c.- rem) (&;c./ y))
-                    floored (|> quotient
-                                (update@ #&;real math;floor)
-                                (update@ #&;imaginary math;floor))
-                    (^open "&/") &;Codec<Text,Complex>]
-                (within? 0.000000000001
-                         x
-                         (|> quotient (&;c.* y) (&;c.+ rem)))))
+      (test "Adding 2 complex numbers is the same as adding their parts."
+            (let [z (&;c.+ y x)]
+              (and (&;c.= z
+                          (&;complex (r.+ (get@ #&;real y)
+                                          (get@ #&;real x))
+                                     (r.+ (get@ #&;imaginary y)
+                                          (get@ #&;imaginary x)))))))
+
+      (test "Subtracting 2 complex numbers is the same as adding their parts."
+            (let [z (&;c.- y x)]
+              (and (&;c.= z
+                          (&;complex (r.- (get@ #&;real y)
+                                          (get@ #&;real x))
+                                     (r.- (get@ #&;imaginary y)
+                                          (get@ #&;imaginary x)))))))
+
+      (test "Subtraction is the inverse of addition."
+            (and (|> x (&;c.+ y) (&;c.- y) (within? margin-of-error x))
+                 (|> x (&;c.- y) (&;c.+ y) (within? margin-of-error x))))
+
+      (test "Division is the inverse of multiplication."
+            (|> x (&;c.* y) (&;c./ y) (within? margin-of-error x)))
+
+      (test "Scalar division is the inverse of scalar multiplication."
+            (|> x (&;c.*' factor) (&;c./' factor) (within? margin-of-error x)))
+
+      (test "If you subtract the remainder, all divisions must be exact."
+            (let [rem (&;c.% y x)
+                  quotient (|> x (&;c.- rem) (&;c./ y))
+                  floored (|> quotient
+                              (update@ #&;real math;floor)
+                              (update@ #&;imaginary math;floor))
+                  (^open "&/") &;Codec<Text,Complex>]
+              (within? 0.000000000001
+                       x
+                       (|> quotient (&;c.* y) (&;c.+ rem)))))
       ))
 
-(test: "Conjugate, reciprocal, signum, negation"
+(context: "Conjugate, reciprocal, signum, negation"
   [x gen-complex]
   ($_ seq
-      (assert "Conjugate has same real part as original, and opposite of imaginary part."
-              (let [cx (&;conjugate x)]
-                (and (r.= (get@ #&;real x)
-                          (get@ #&;real cx))
-                     (r.= (r/negate (get@ #&;imaginary x))
-                          (get@ #&;imaginary cx)))))
-
-      (assert "The reciprocal functions is its own inverse."
-              (|> x &;reciprocal &;reciprocal (within? margin-of-error x)))
-
-      (assert "x*(x^-1) = 1"
-              (|> x (&;c.* (&;reciprocal x)) (within? margin-of-error &;one)))
-
-      (assert "Absolute value of signum is always root2(2), 1 or 0."
-              (let [signum-abs (|> x &;c.signum &;c.abs (get@ #&;real))]
-                (or (r.= 0.0 signum-abs)
-                    (r.= 1.0 signum-abs)
-                    (r.= (math;root2 2.0) signum-abs))))
-
-      (assert "Negation is its own inverse."
-              (let [there (&;c.negate x)
-                    back-again (&;c.negate there)]
-                (and (not (&;c.= there x))
-                     (&;c.= back-again x))))
-
-      (assert "Negation doesn't change the absolute value."
-              (r.= (get@ #&;real (&;c.abs x))
-                   (get@ #&;real (&;c.abs (&;c.negate x)))))
+      (test "Conjugate has same real part as original, and opposite of imaginary part."
+            (let [cx (&;conjugate x)]
+              (and (r.= (get@ #&;real x)
+                        (get@ #&;real cx))
+                   (r.= (r/negate (get@ #&;imaginary x))
+                        (get@ #&;imaginary cx)))))
+
+      (test "The reciprocal functions is its own inverse."
+            (|> x &;reciprocal &;reciprocal (within? margin-of-error x)))
+
+      (test "x*(x^-1) = 1"
+            (|> x (&;c.* (&;reciprocal x)) (within? margin-of-error &;one)))
+
+      (test "Absolute value of signum is always root2(2), 1 or 0."
+            (let [signum-abs (|> x &;c.signum &;c.abs (get@ #&;real))]
+              (or (r.= 0.0 signum-abs)
+                  (r.= 1.0 signum-abs)
+                  (r.= (math;root2 2.0) signum-abs))))
+
+      (test "Negation is its own inverse."
+            (let [there (&;c.negate x)
+                  back-again (&;c.negate there)]
+              (and (not (&;c.= there x))
+                   (&;c.= back-again x))))
+
+      (test "Negation doesn't change the absolute value."
+            (r.= (get@ #&;real (&;c.abs x))
+                 (get@ #&;real (&;c.abs (&;c.negate x)))))
       ))
 
 ## ## Don't know how to test complex trigonometry properly.
-## (test: "Trigonometry"
+## (context: "Trigonometry"
 ##   [x gen-complex]
 ##   ($_ seq
-##       (assert "Arc-sine is the inverse of sine."
-##               (|> x &;sin &;asin (within? margin-of-error x)))
+##       (test "Arc-sine is the inverse of sine."
+##             (|> x &;sin &;asin (within? margin-of-error x)))
 
-##       (assert "Arc-cosine is the inverse of cosine."
-##               (|> x &;cos &;acos (within? margin-of-error x)))
+##       (test "Arc-cosine is the inverse of cosine."
+##             (|> x &;cos &;acos (within? margin-of-error x)))
 
-##       (assert "Arc-tangent is the inverse of tangent."
-##               (|> x &;tan &;atan (within? margin-of-error x))))
+##       (test "Arc-tangent is the inverse of tangent."
+##             (|> x &;tan &;atan (within? margin-of-error x))))
 ##   )
 
-(test: "Power 2 and exponential/logarithm"
+(context: "Power 2 and exponential/logarithm"
   [x gen-complex]
   ($_ seq
-      (assert "Square root is inverse of power 2.0"
-              (|> x (&;pow' 2.0) &;root2 (within? margin-of-error x)))
+      (test "Square root is inverse of power 2.0"
+            (|> x (&;pow' 2.0) &;root2 (within? margin-of-error x)))
 
-      (assert "Logarithm is inverse of exponentiation."
-              (|> x &;log &;exp (within? margin-of-error x)))
+      (test "Logarithm is inverse of exponentiation."
+            (|> x &;log &;exp (within? margin-of-error x)))
       ))
 
-(test: "Complex roots"
+(context: "Complex roots"
   [sample gen-complex
    degree (|> R;nat (:: @ map (|>. (n.max +1) (n.% +5))))]
-  (assert "Can calculate the N roots for any complex number."
-          (|> sample
-              (&;nth-roots degree)
-              (List/map (&;pow' (|> degree nat-to-int int-to-real)))
-              (list;every? (within? margin-of-error sample)))))
+  (test "Can calculate the N roots for any complex number."
+        (|> sample
+            (&;nth-roots degree)
+            (List/map (&;pow' (|> degree nat-to-int int-to-real)))
+            (list;every? (within? margin-of-error sample)))))
 
-(test: "Codec"
+(context: "Codec"
   [sample gen-complex
    #let [(^open "c/") &;Codec<Text,Complex>]]
-  (assert "Can encode/decode complex numbers."
-          (|> sample c/encode c/decode
-              (case> (#;Right output)
-                     (&;c.= sample output)
+  (test "Can encode/decode complex numbers."
+        (|> sample c/encode c/decode
+            (case> (#;Right output)
+                   (&;c.= sample output)
 
-                     _
-                     false))))
+                   _
+                   false))))
diff --git a/stdlib/test/test/lux/data/number/ratio.lux b/stdlib/test/test/lux/data/number/ratio.lux
index 7ae36e573..31a3407bf 100644
--- a/stdlib/test/test/lux/data/number/ratio.lux
+++ b/stdlib/test/test/lux/data/number/ratio.lux
@@ -26,81 +26,81 @@
                      (R;filter (. not (n.= numerator))))]
     (wrap (&;ratio numerator denominator))))
 
-(test: "Normalization"
+(context: "Normalization"
   [denom1 gen-part
    denom2 gen-part
    sample gen-ratio]
   ($_ seq
-      (assert "All zeroes are the same."
-              (&;q.= (&;ratio +0 denom1)
-                     (&;ratio +0 denom2)))
+      (test "All zeroes are the same."
+            (&;q.= (&;ratio +0 denom1)
+                   (&;ratio +0 denom2)))
 
-      (assert "All ratios are built normalized."
-              (|> sample &;normalize (&;q.= sample)))
+      (test "All ratios are built normalized."
+            (|> sample &;normalize (&;q.= sample)))
       ))
 
-(test: "Arithmetic"
+(context: "Arithmetic"
   [x gen-ratio
    y gen-ratio
    #let [min (&;q.min x y)
          max (&;q.max x y)]]
   ($_ seq
-      (assert "Addition and subtraction are opposites."
-              (and (|> max (&;q.- min) (&;q.+ min) (&;q.= max))
-                   (|> max (&;q.+ min) (&;q.- min) (&;q.= max))))
+      (test "Addition and subtraction are opposites."
+            (and (|> max (&;q.- min) (&;q.+ min) (&;q.= max))
+                 (|> max (&;q.+ min) (&;q.- min) (&;q.= max))))
 
-      (assert "Multiplication and division are opposites."
-              (and (|> max (&;q./ min) (&;q.* min) (&;q.= max))
-                   (|> max (&;q.* min) (&;q./ min) (&;q.= max))))
+      (test "Multiplication and division are opposites."
+            (and (|> max (&;q./ min) (&;q.* min) (&;q.= max))
+                 (|> max (&;q.* min) (&;q./ min) (&;q.= max))))
 
-      (assert "Modulus by a larger ratio doesn't change the value."
-              (|> min (&;q.% max) (&;q.= min)))
+      (test "Modulus by a larger ratio doesn't change the value."
+            (|> min (&;q.% max) (&;q.= min)))
 
-      (assert "Modulus by a smaller ratio results in a value smaller than the limit."
-              (|> max (&;q.% min) (&;q.< min)))
+      (test "Modulus by a smaller ratio results in a value smaller than the limit."
+            (|> max (&;q.% min) (&;q.< min)))
 
-      (assert "Can get the remainder of a division."
-              (let [remainder (&;q.% min max)
-                    multiple (&;q.- remainder max)
-                    factor (&;q./ min multiple)]
-                (and (|> factor (get@ #&;denominator) (n.= +1))
-                     (|> factor (&;q.* min) (&;q.+ remainder) (&;q.= max)))))
+      (test "Can get the remainder of a division."
+            (let [remainder (&;q.% min max)
+                  multiple (&;q.- remainder max)
+                  factor (&;q./ min multiple)]
+              (and (|> factor (get@ #&;denominator) (n.= +1))
+                   (|> factor (&;q.* min) (&;q.+ remainder) (&;q.= max)))))
       ))
 
-(test: "Negation, absolute value and signum"
+(context: "Negation, absolute value and signum"
   [sample gen-ratio]
   ($_ seq
-      (assert "Negation is it's own inverse."
-              (let [there (&/negate sample)
-                    back-again (&/negate there)]
-                (and (not (&;q.= there sample))
-                     (&;q.= back-again sample))))
+      (test "Negation is it's own inverse."
+            (let [there (&/negate sample)
+                  back-again (&/negate there)]
+              (and (not (&;q.= there sample))
+                   (&;q.= back-again sample))))
 
-      (assert "All ratios are already at their absolute value."
-              (|> sample &/abs (&;q.= sample)))
+      (test "All ratios are already at their absolute value."
+            (|> sample &/abs (&;q.= sample)))
       
-      (assert "Signum is the identity."
-              (|> sample (&;q.* (&/signum sample)) (&;q.= sample)))
+      (test "Signum is the identity."
+            (|> sample (&;q.* (&/signum sample)) (&;q.= sample)))
       ))
 
-(test: "Order"
+(context: "Order"
   [x gen-ratio
    y gen-ratio]
   ($_ seq
-      (assert "Can compare ratios."
-              (and (or (&;q.<= y x)
-                       (&;q.> y x))
-                   (or (&;q.>= y x)
-                       (&;q.< y x))))
+      (test "Can compare ratios."
+            (and (or (&;q.<= y x)
+                     (&;q.> y x))
+                 (or (&;q.>= y x)
+                     (&;q.< y x))))
       ))
 
-(test: "Codec"
+(context: "Codec"
   [sample gen-ratio
    #let [(^open "&/") &;Codec<Text,Ratio>]]
-  (assert "Can encode/decode ratios."
-          (|> sample &/encode &/decode
-              (case> (#;Right output)
-                     (&;q.= sample output)
-                     
-                     _
-                     false))))
+  (test "Can encode/decode ratios."
+        (|> sample &/encode &/decode
+            (case> (#;Right output)
+                   (&;q.= sample output)
+                   
+                   _
+                   false))))
diff --git a/stdlib/test/test/lux/data/product.lux b/stdlib/test/test/lux/data/product.lux
index 00337ebfb..53340c072 100644
--- a/stdlib/test/test/lux/data/product.lux
+++ b/stdlib/test/test/lux/data/product.lux
@@ -7,14 +7,14 @@
              [number]))
   lux/test)
 
-(test: "Products"
+(context: "Products"
   ($_ seq
-      (assert "Can access the sides of a pair."
-              (and (i.= 1 (left [1 2]))
-                   (i.= 2 (right [1 2]))))
+      (test "Can access the sides of a pair."
+            (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 (i.= 2 _left)
-                     (i.= 1 _right))))
+      (test "Can swap the sides of a pair."
+            (let [[_left _right] (swap [1 2])]
+              (and (i.= 2 _left)
+                   (i.= 1 _right))))
       ))
diff --git a/stdlib/test/test/lux/data/result.lux b/stdlib/test/test/lux/data/result.lux
index aee931279..485f56a13 100644
--- a/stdlib/test/test/lux/data/result.lux
+++ b/stdlib/test/test/lux/data/result.lux
@@ -7,50 +7,50 @@
              ["&" result]))
   lux/test)
 
-(test: "Results"
+(context: "Results"
   (let [(^open "&/") &;Monad<Result>]
     ($_ seq
-        (assert "Functor correctly handles both cases."
-                (and (|> (: (&;Result Int) (#&;Success 10))
-                         (&/map i.inc)
-                         (case> (#&;Success 11) true _ false))
+        (test "Functor correctly handles both cases."
+              (and (|> (: (&;Result Int) (#&;Success 10))
+                       (&/map i.inc)
+                       (case> (#&;Success 11) true _ false))
 
-                     (|> (: (&;Result Int) (#&;Error "YOLO"))
-                         (&/map i.inc)
-                         (case> (#&;Error "YOLO") true _ false))
-                     ))
+                   (|> (: (&;Result Int) (#&;Error "YOLO"))
+                       (&/map i.inc)
+                       (case> (#&;Error "YOLO") true _ false))
+                   ))
         
-        (assert "Applicative correctly handles both cases."
-                (and (|> (&/wrap 20)
-                         (case> (#&;Success 20) true _ false))
-                     (|> (&/apply (&/wrap i.inc) (&/wrap 10))
-                         (case> (#&;Success 11) true _ false))
-                     (|> (&/apply (&/wrap i.inc) (#&;Error "YOLO"))
-                         (case> (#&;Error "YOLO") true _ false))))
+        (test "Applicative correctly handles both cases."
+              (and (|> (&/wrap 20)
+                       (case> (#&;Success 20) true _ false))
+                   (|> (&/apply (&/wrap i.inc) (&/wrap 10))
+                       (case> (#&;Success 11) true _ false))
+                   (|> (&/apply (&/wrap i.inc) (#&;Error "YOLO"))
+                       (case> (#&;Error "YOLO") true _ false))))
         
-        (assert "Monad correctly handles both cases."
-                (and (|> (do &;Monad<Result>
-                           [f (wrap i.+)
-                            a (wrap 10)
-                            b (wrap 20)]
-                           (wrap (f a b)))
-                         (case> (#&;Success 30) true _ false))
-                     (|> (do &;Monad<Result>
-                           [f (wrap i.+)
-                            a (#&;Error "YOLO")
-                            b (wrap 20)]
-                           (wrap (f a b)))
-                         (case> (#&;Error "YOLO") true _ false))
-                     ))
+        (test "Monad correctly handles both cases."
+              (and (|> (do &;Monad<Result>
+                         [f (wrap i.+)
+                          a (wrap 10)
+                          b (wrap 20)]
+                         (wrap (f a b)))
+                       (case> (#&;Success 30) true _ false))
+                   (|> (do &;Monad<Result>
+                         [f (wrap i.+)
+                          a (#&;Error "YOLO")
+                          b (wrap 20)]
+                         (wrap (f a b)))
+                       (case> (#&;Error "YOLO") true _ false))
+                   ))
         )))
 
-(test: "Monad transformer"
+(context: "Monad transformer"
   (let [lift (&;lift-result io;Monad<IO>)
         (^open "io/") io;Monad<IO>]
-    (assert "Can add result functionality to any monad."
-            (|> (io;run (do (&;ResultT io;Monad<IO>)
-                          [a (lift (io/wrap 123))
-                           b (wrap 456)]
-                          (wrap (i.+ a b))))
-                (case> (#&;Success 579) true
-                       _ false)))))
+    (test "Can add result functionality to any monad."
+          (|> (io;run (do (&;ResultT io;Monad<IO>)
+                        [a (lift (io/wrap 123))
+                         b (wrap 456)]
+                        (wrap (i.+ a b))))
+              (case> (#&;Success 579) true
+                     _ false)))))
diff --git a/stdlib/test/test/lux/data/sum.lux b/stdlib/test/test/lux/data/sum.lux
index 6e88e6b07..26f30f4e4 100644
--- a/stdlib/test/test/lux/data/sum.lux
+++ b/stdlib/test/test/lux/data/sum.lux
@@ -9,29 +9,29 @@
              (coll [list])))
   lux/test)
 
-(test: "Sum operations"
+(context: "Sum operations"
   (let [(^open "List/") (list;Eq<List> text;Eq<Text>)]
     ($_ seq
-        (assert "Can inject values into Either."
-                (and (|> (left "Hello") (case> (+0 "Hello") true _ false))
-                     (|> (right "World") (case> (+1 "World") true _ false))))
+        (test "Can inject values into Either."
+              (and (|> (left "Hello") (case> (+0 "Hello") true _ false))
+                   (|> (right "World") (case> (+1 "World") true _ false))))
 
-        (assert "Can discriminate eithers based on their cases."
-                (let [[_lefts _rights] (partition (: (List (| Text Text))
-                                                     (list (+0 "0") (+1 "1") (+0 "2"))))]
-                  (and (List/= _lefts
-                               (lefts (: (List (| Text Text))
-                                         (list (+0 "0") (+1 "1") (+0 "2")))))
+        (test "Can discriminate eithers based on their cases."
+              (let [[_lefts _rights] (partition (: (List (| Text Text))
+                                                   (list (+0 "0") (+1 "1") (+0 "2"))))]
+                (and (List/= _lefts
+                             (lefts (: (List (| Text Text))
+                                       (list (+0 "0") (+1 "1") (+0 "2")))))
 
-                       (List/= _rights
-                               (rights (: (List (| Text Text))
-                                          (list (+0 "0") (+1 "1") (+0 "2"))))))))
+                     (List/= _rights
+                             (rights (: (List (| Text Text))
+                                        (list (+0 "0") (+1 "1") (+0 "2"))))))))
 
-        (assert "Can apply a function to an Either value depending on the case."
-                (and (i.= 10 (either (function [_] 10)
-                                     (function [_] 20)
-                                     (: (| Text Text) (+0 ""))))
-                     (i.= 20 (either (function [_] 10)
-                                     (function [_] 20)
-                                     (: (| Text Text) (+1 ""))))))
+        (test "Can apply a function to an Either value depending on the case."
+              (and (i.= 10 (either (function [_] 10)
+                                   (function [_] 20)
+                                   (: (| Text Text) (+0 ""))))
+                   (i.= 20 (either (function [_] 10)
+                                   (function [_] 20)
+                                   (: (| Text Text) (+1 ""))))))
         )))
diff --git a/stdlib/test/test/lux/data/text.lux b/stdlib/test/test/lux/data/text.lux
index aa316a7ad..fafba01e2 100644
--- a/stdlib/test/test/lux/data/text.lux
+++ b/stdlib/test/test/lux/data/text.lux
@@ -11,46 +11,46 @@
        ["R" math/random])
   lux/test)
 
-(test: "Size"
+(context: "Size"
   [size (:: @ map (n.% +100) R;nat)
    sample (R;text size)]
-  (assert "" (or (and (n.= +0 size)
-                      (&;empty? sample))
-                 (n.= size (&;size sample)))))
+  (test "" (or (and (n.= +0 size)
+                    (&;empty? sample))
+               (n.= size (&;size sample)))))
 
 (def: bounded-size
   (R;Random Nat)
   (|> R;nat
       (:: R;Monad<Random> map (|>. (n.% +20) (n.+ +1)))))
 
-(test: "Locations"
+(context: "Locations"
   [size bounded-size
    idx (:: @ map (n.% size) R;nat)
    sample (R;text size)]
-  (assert "" (|> sample
-                 (&;nth idx)
-                 (case> (^multi (#;Some char)
-                                [(char;as-text char) char']
-                                [[(&;index-of' char' sample)
-                                  (&;last-index-of' char' sample)
-                                  (&;index-of char' idx sample)
-                                  (&;last-index-of char' idx sample)]
-                                 [(#;Some io) (#;Some lio)
-                                  (#;Some io') (#;Some lio')]])
-                        (and (n.<= idx io)
-                             (n.>= idx lio)
+  (test "" (|> sample
+               (&;nth idx)
+               (case> (^multi (#;Some char)
+                              [(char;as-text char) char']
+                              [[(&;index-of' char' sample)
+                                (&;last-index-of' char' sample)
+                                (&;index-of char' idx sample)
+                                (&;last-index-of char' idx sample)]
+                               [(#;Some io) (#;Some lio)
+                                (#;Some io') (#;Some lio')]])
+                      (and (n.<= idx io)
+                           (n.>= idx lio)
 
-                             (n.= idx io')
-                             (n.>= idx lio')
+                           (n.= idx io')
+                           (n.>= idx lio')
 
-                             (&;contains? char' sample))
+                           (&;contains? char' sample))
 
-                        _
-                        false
-                        ))
-          ))
+                      _
+                      false
+                      ))
+        ))
 
-(test: "Text functions"
+(context: "Text functions"
   [sizeL bounded-size
    sizeR bounded-size
    sampleL (R;text sizeL)
@@ -60,38 +60,38 @@
          dup-sample (&;join-with "" (list sampleL sampleR))
          enclosed-sample (&;enclose [sampleR sampleR] sampleL)
          (^open) &;Eq<Text>]]
-  (assert "" (and (not (= sample fake-sample))
-                  (= sample dup-sample)
-                  (&;starts-with? sampleL sample)
-                  (&;ends-with? sampleR sample)
-                  (= enclosed-sample
-                     (&;enclose' sampleR sampleL))
-                  
-                  (|> (&;split sizeL sample)
-                      (case> (#;Right [_l _r])
-                             (and (= sampleL _l)
-                                  (= sampleR _r)
-                                  (= sample (&;concat (list _l _r))))
+  (test "" (and (not (= sample fake-sample))
+                (= sample dup-sample)
+                (&;starts-with? sampleL sample)
+                (&;ends-with? sampleR sample)
+                (= enclosed-sample
+                   (&;enclose' sampleR sampleL))
+                
+                (|> (&;split sizeL sample)
+                    (case> (#;Right [_l _r])
+                           (and (= sampleL _l)
+                                (= sampleR _r)
+                                (= sample (&;concat (list _l _r))))
 
-                             _
-                             false))
-                  
-                  (|> [(&;clip +0 sizeL sample)
-                       (&;clip sizeL (&;size sample) sample)
-                       (&;clip' sizeL sample)
-                       (&;clip' +0 sample)]
-                      (case> [(#;Right _l) (#;Right _r) (#;Right _r') (#;Right _f)]
-                             (and (= sampleL _l)
-                                  (= sampleR _r)
-                                  (= _r _r')
-                                  (= sample _f))
+                           _
+                           false))
+                
+                (|> [(&;clip +0 sizeL sample)
+                     (&;clip sizeL (&;size sample) sample)
+                     (&;clip' sizeL sample)
+                     (&;clip' +0 sample)]
+                    (case> [(#;Right _l) (#;Right _r) (#;Right _r') (#;Right _f)]
+                           (and (= sampleL _l)
+                                (= sampleR _r)
+                                (= _r _r')
+                                (= sample _f))
 
-                             _
-                             false))
-                  )
-          ))
+                           _
+                           false))
+                )
+        ))
 
-(test: "More text functions"
+(context: "More text functions"
   [sizeP bounded-size
    sizeL bounded-size
    #let [## The wider unicode charset includes control characters that
@@ -107,50 +107,50 @@
          sample2 (&;concat (list;interpose sep2 parts))
          (^open "&/") &;Eq<Text>]]
   ($_ seq
-      (assert "Can split text through a separator."
-              (n.= (list;size parts)
-                   (list;size (&;split-all-with sep1 sample1))))
+      (test "Can split text through a separator."
+            (n.= (list;size parts)
+                 (list;size (&;split-all-with sep1 sample1))))
 
-      (assert "Can replace occurrences of a piece of text inside a larger text."
-              (&/= sample2
-                   (&;replace-all sep1 sep2 sample1)))
+      (test "Can replace occurrences of a piece of text inside a larger text."
+            (&/= sample2
+                 (&;replace-all sep1 sep2 sample1)))
       ))
 
-(test: "Other text functions"
+(context: "Other text functions"
   (let [(^open "&/") &;Eq<Text>]
     ($_ seq
-        (assert "Can transform texts in certain ways."
-                (and (&/= "abc" (&;lower-case "ABC"))
-                     (&/= "ABC" (&;upper-case "abc"))
-                     (&/= "ABC" (&;trim " \tABC\n\r"))))
+        (test "Can transform texts in certain ways."
+              (and (&/= "abc" (&;lower-case "ABC"))
+                   (&/= "ABC" (&;upper-case "abc"))
+                   (&/= "ABC" (&;trim " \tABC\n\r"))))
         )))
 
-(test: "Structures"
+(context: "Structures"
   (let [(^open "&/") &;Order<Text>]
     ($_ seq
-        (assert "" (&/< "bcd" "abc"))
-        (assert "" (not (&/< "abc" "abc")))
-        (assert "" (not (&/< "abc" "bcd")))
-        (assert "" (&/<= "bcd" "abc"))
-        (assert "" (&/<= "abc" "abc"))
-        (assert "" (not (&/<= "abc" "bcd")))
-        (assert "" (&/> "abc" "bcd"))
-        (assert "" (not (&/> "abc" "abc")))
-        (assert "" (not (&/> "bcd" "abc")))
-        (assert "" (&/>= "abc" "bcd"))
-        (assert "" (&/>= "abc" "abc"))
-        (assert "" (not (&/>= "bcd" "abc")))
+        (test "" (&/< "bcd" "abc"))
+        (test "" (not (&/< "abc" "abc")))
+        (test "" (not (&/< "abc" "bcd")))
+        (test "" (&/<= "bcd" "abc"))
+        (test "" (&/<= "abc" "abc"))
+        (test "" (not (&/<= "abc" "bcd")))
+        (test "" (&/> "abc" "bcd"))
+        (test "" (not (&/> "abc" "abc")))
+        (test "" (not (&/> "bcd" "abc")))
+        (test "" (&/>= "abc" "bcd"))
+        (test "" (&/>= "abc" "abc"))
+        (test "" (not (&/>= "bcd" "abc")))
         )))
 
-(test: "Codec"
+(context: "Codec"
   [size bounded-size
    sample (R;text size)
    #let [(^open) &;Eq<Text>]]
-  (assert "" (|> sample
-                 (:: &;Codec<Text,Text> encode)
-                 (:: &;Codec<Text,Text> decode)
-                 (case> (#;Right decoded)
-                        (= sample decoded)
+  (test "" (|> sample
+               (:: &;Codec<Text,Text> encode)
+               (:: &;Codec<Text,Text> decode)
+               (case> (#;Right decoded)
+                      (= sample decoded)
 
-                        _
-                        false))))
+                      _
+                      false))))
diff --git a/stdlib/test/test/lux/data/text/format.lux b/stdlib/test/test/lux/data/text/format.lux
index 97b955e20..afd788fa0 100644
--- a/stdlib/test/test/lux/data/text/format.lux
+++ b/stdlib/test/test/lux/data/text/format.lux
@@ -7,14 +7,14 @@
              [number]))
   lux/test)
 
-(test: "Formatters"
+(context: "Formatters"
   (let [(^open "&/") text;Eq<Text>]
     ($_ seq
-        (assert "Can format common values simply."
-                (and (&/= "true" (%b true))
-                     (&/= "123" (%i 123))
-                     (&/= "123.456" (%r 123.456))
-                     (&/= "#\"t\"" (%c #"t"))
-                     (&/= "\"YOLO\"" (%t "YOLO"))
-                     (&/= "User-id: 123 -- Active: true" (format "User-id: " (%i 123) " -- Active: " (%b true)))))
+        (test "Can format common values simply."
+              (and (&/= "true" (%b true))
+                   (&/= "123" (%i 123))
+                   (&/= "123.456" (%r 123.456))
+                   (&/= "#\"t\"" (%c #"t"))
+                   (&/= "\"YOLO\"" (%t "YOLO"))
+                   (&/= "User-id: 123 -- Active: true" (format "User-id: " (%i 123) " -- Active: " (%b true)))))
         )))
diff --git a/stdlib/test/test/lux/data/text/lexer.lux b/stdlib/test/test/lux/data/text/lexer.lux
index df77f804a..8f1d94185 100644
--- a/stdlib/test/test/lux/data/text/lexer.lux
+++ b/stdlib/test/test/lux/data/text/lexer.lux
@@ -55,251 +55,251 @@
     false))
 
 ## [Tests]
-(test: "End"
+(context: "End"
   ($_ seq
-      (assert "Can detect the end of the input."
-              (|> (&;run ""
-                         &;end)
-                  (case> (#;Right _) true _ false)))
+      (test "Can detect the end of the input."
+            (|> (&;run ""
+                       &;end)
+                (case> (#;Right _) true _ false)))
       
-      (assert "Won't mistake non-empty text for no more input."
-              (|> (&;run "YOLO"
-                         &;end)
-                  (case> (#;Left _) true _ false)))
+      (test "Won't mistake non-empty text for no more input."
+            (|> (&;run "YOLO"
+                       &;end)
+                (case> (#;Left _) true _ false)))
       ))
 
-(test: "Literals"
+(context: "Literals"
   [size (|> r;nat (:: @ map (|>. (n.% +100) (n.max +10))))
    pre (r;text size)
    post (|> (r;text size)
             (r;filter (|>. (text;starts-with? pre) not)))]
   ($_ seq
-      (assert "Can find literal text fragments."
-              (and (|> (&;run (format pre post)
-                              (&;this pre))
-                       (case> (#;Right []) true _ false))
-                   (|> (&;run post
-                              (&;this pre))
-                       (case> (#;Left _) true _ false))))
+      (test "Can find literal text fragments."
+            (and (|> (&;run (format pre post)
+                            (&;this pre))
+                     (case> (#;Right []) true _ false))
+                 (|> (&;run post
+                            (&;this pre))
+                     (case> (#;Left _) true _ false))))
       ))
 
-(test: "Char lexers"
+(context: "Char lexers"
   ($_ seq
-      (assert "Can lex characters."
-              (and (|> (&;run "YOLO"
-                              (&;this "Y"))
-                       (case> (#;Right []) true _ false))
-                   (|> (&;run "MEME"
-                              (&;this "Y"))
-                       (case> (#;Left _) true _ false))))
+      (test "Can lex characters."
+            (and (|> (&;run "YOLO"
+                            (&;this "Y"))
+                     (case> (#;Right []) true _ false))
+                 (|> (&;run "MEME"
+                            (&;this "Y"))
+                     (case> (#;Left _) true _ false))))
 
-      (assert "Can lex characters ranges."
-              (and (should-passT "Y" (&;run "YOLO"
-                                            (&;char-range #"X" #"Z")))
-                   (should-fail (&;run "MEME"
-                                       (&;char-range #"X" #"Z")))))
+      (test "Can lex characters ranges."
+            (and (should-passT "Y" (&;run "YOLO"
+                                          (&;char-range #"X" #"Z")))
+                 (should-fail (&;run "MEME"
+                                     (&;char-range #"X" #"Z")))))
       ))
 
-(test: "Custom lexers"
+(context: "Custom lexers"
   ($_ seq
-      (assert "Can lex anything"
-              (and (should-passT "A" (&;run "A"
-                                            &;any))
-                   (should-fail (&;run ""
-                                       &;any))))
+      (test "Can lex anything"
+            (and (should-passT "A" (&;run "A"
+                                          &;any))
+                 (should-fail (&;run ""
+                                     &;any))))
       
-      (assert "Can lex upper-case and &;lower-case letters."
-              (and (should-passT "Y" (&;run "YOLO"
-                                            &;upper))
-                   (should-fail (&;run "meme"
-                                       &;upper))
-                   
-                   (should-passT "y" (&;run "yolo"
-                                            &;lower))
-                   (should-fail (&;run "MEME"
-                                       &;lower))))
+      (test "Can lex upper-case and &;lower-case letters."
+            (and (should-passT "Y" (&;run "YOLO"
+                                          &;upper))
+                 (should-fail (&;run "meme"
+                                     &;upper))
+                 
+                 (should-passT "y" (&;run "yolo"
+                                          &;lower))
+                 (should-fail (&;run "MEME"
+                                     &;lower))))
 
-      (assert "Can lex numbers."
-              (and (should-passT "1" (&;run "1"
-                                            &;digit))
-                   (should-fail (&;run " "
-                                       &;digit))
+      (test "Can lex numbers."
+            (and (should-passT "1" (&;run "1"
+                                          &;digit))
+                 (should-fail (&;run " "
+                                     &;digit))
 
-                   (should-passT "7" (&;run "7"
-                                            &;oct-digit))
-                   (should-fail (&;run "8"
-                                       &;oct-digit))
+                 (should-passT "7" (&;run "7"
+                                          &;oct-digit))
+                 (should-fail (&;run "8"
+                                     &;oct-digit))
 
-                   (should-passT "1" (&;run "1"
-                                            &;hex-digit))
-                   (should-passT "a" (&;run "a"
-                                            &;hex-digit))
-                   (should-passT "A" (&;run "A"
-                                            &;hex-digit))
-                   (should-fail (&;run " "
-                                       &;hex-digit))
-                   ))
+                 (should-passT "1" (&;run "1"
+                                          &;hex-digit))
+                 (should-passT "a" (&;run "a"
+                                          &;hex-digit))
+                 (should-passT "A" (&;run "A"
+                                          &;hex-digit))
+                 (should-fail (&;run " "
+                                     &;hex-digit))
+                 ))
 
-      (assert "Can lex alphabetic characters."
-              (and (should-passT "A" (&;run "A"
-                                            &;alpha))
-                   (should-passT "a" (&;run "a"
-                                            &;alpha))
-                   (should-fail (&;run "1"
-                                       &;alpha))))
+      (test "Can lex alphabetic characters."
+            (and (should-passT "A" (&;run "A"
+                                          &;alpha))
+                 (should-passT "a" (&;run "a"
+                                          &;alpha))
+                 (should-fail (&;run "1"
+                                     &;alpha))))
 
-      (assert "Can lex alphanumeric characters."
-              (and (should-passT "A" (&;run "A"
-                                            &;alpha-num))
-                   (should-passT "a" (&;run "a"
-                                            &;alpha-num))
-                   (should-passT "1" (&;run "1"
-                                            &;alpha-num))
-                   (should-fail (&;run " "
-                                       &;alpha-num))))
+      (test "Can lex alphanumeric characters."
+            (and (should-passT "A" (&;run "A"
+                                          &;alpha-num))
+                 (should-passT "a" (&;run "a"
+                                          &;alpha-num))
+                 (should-passT "1" (&;run "1"
+                                          &;alpha-num))
+                 (should-fail (&;run " "
+                                     &;alpha-num))))
 
-      (assert "Can lex white-space."
-              (and (should-passT " " (&;run " "
-                                            &;space))
-                   (should-fail (&;run "8"
-                                       &;space))))
+      (test "Can lex white-space."
+            (and (should-passT " " (&;run " "
+                                          &;space))
+                 (should-fail (&;run "8"
+                                     &;space))))
       ))
 
-(test: "Combinators"
+(context: "Combinators"
   ($_ seq
-      (assert "Can combine lexers sequentially."
-              (and (|> (&;run "YOLO"
-                              (&;seq &;any &;any))
-                       (case> (#;Right ["Y" "O"]) true
-                              _ false))
-                   (should-fail (&;run "Y"
-                                       (&;seq &;any &;any)))))
+      (test "Can combine lexers sequentially."
+            (and (|> (&;run "YOLO"
+                            (&;seq &;any &;any))
+                     (case> (#;Right ["Y" "O"]) true
+                            _ false))
+                 (should-fail (&;run "Y"
+                                     (&;seq &;any &;any)))))
       
-      (assert "Can combine lexers alternatively."
-              (and (should-passE (#;Left "0") (&;run "0"
-                                                     (&;alt &;digit &;upper)))
-                   (should-passE (#;Right "A") (&;run "A"
-                                                      (&;alt &;digit &;upper)))
-                   (should-fail (&;run "a"
-                                       (&;alt &;digit &;upper)))))
+      (test "Can combine lexers alternatively."
+            (and (should-passE (#;Left "0") (&;run "0"
+                                                   (&;alt &;digit &;upper)))
+                 (should-passE (#;Right "A") (&;run "A"
+                                                    (&;alt &;digit &;upper)))
+                 (should-fail (&;run "a"
+                                     (&;alt &;digit &;upper)))))
 
-      (assert "Can create the opposite of a lexer."
-              (and (should-passT "a" (&;run "a"
-                                            (&;not (&;alt &;digit &;upper))))
-                   (should-fail (&;run "A"
-                                       (&;not (&;alt &;digit &;upper))))))
+      (test "Can create the opposite of a lexer."
+            (and (should-passT "a" (&;run "a"
+                                          (&;not (&;alt &;digit &;upper))))
+                 (should-fail (&;run "A"
+                                     (&;not (&;alt &;digit &;upper))))))
       
-      (assert "Can use either lexer."
-              (and (should-passT "0" (&;run "0"
-                                            (&;either &;digit &;upper)))
-                   (should-passT "A" (&;run "A"
-                                            (&;either &;digit &;upper)))
-                   (should-fail (&;run "a"
-                                       (&;either &;digit &;upper)))))
+      (test "Can use either lexer."
+            (and (should-passT "0" (&;run "0"
+                                          (&;either &;digit &;upper)))
+                 (should-passT "A" (&;run "A"
+                                          (&;either &;digit &;upper)))
+                 (should-fail (&;run "a"
+                                     (&;either &;digit &;upper)))))
       
-      (assert "Can select from among a set of characters."
-              (and (should-passT "C" (&;run "C"
-                                            (&;one-of "ABC")))
-                   (should-fail (&;run "D"
-                                       (&;one-of "ABC")))))
+      (test "Can select from among a set of characters."
+            (and (should-passT "C" (&;run "C"
+                                          (&;one-of "ABC")))
+                 (should-fail (&;run "D"
+                                     (&;one-of "ABC")))))
 
-      (assert "Can avoid a set of characters."
-              (and (should-passT "D" (&;run "D"
-                                            (&;none-of "ABC")))
-                   (should-fail (&;run "C"
-                                       (&;none-of "ABC")))))
+      (test "Can avoid a set of characters."
+            (and (should-passT "D" (&;run "D"
+                                          (&;none-of "ABC")))
+                 (should-fail (&;run "C"
+                                     (&;none-of "ABC")))))
       
-      (assert "Can lex using arbitrary predicates."
-              (and (should-passT "D" (&;run "D"
-                                            (&;satisfies (function [c] true))))
-                   (should-fail (&;run "C"
-                                       (&;satisfies (function [c] false))))))
+      (test "Can lex using arbitrary predicates."
+            (and (should-passT "D" (&;run "D"
+                                          (&;satisfies (function [c] true))))
+                 (should-fail (&;run "C"
+                                     (&;satisfies (function [c] false))))))
       
-      (assert "Can apply a lexer multiple times."
-              (and (should-passT "0123456789ABCDEF" (&;run "0123456789ABCDEF yolo"
-                                                           (&;many' &;hex-digit)))
-                   (should-fail (&;run "yolo"
-                                       (&;many' &;hex-digit)))
+      (test "Can apply a lexer multiple times."
+            (and (should-passT "0123456789ABCDEF" (&;run "0123456789ABCDEF yolo"
+                                                         (&;many' &;hex-digit)))
+                 (should-fail (&;run "yolo"
+                                     (&;many' &;hex-digit)))
 
-                   (should-passT "" (&;run "yolo"
-                                           (&;some' &;hex-digit)))))
+                 (should-passT "" (&;run "yolo"
+                                         (&;some' &;hex-digit)))))
       ))
 
-(test: "Yet more combinators..."
+(context: "Yet more combinators..."
   ($_ seq
-      (assert "Can fail at will."
-              (should-fail (&;run "yolo"
-                                  (&;fail "Well, it really SHOULD fail..."))))
+      (test "Can fail at will."
+            (should-fail (&;run "yolo"
+                                (&;fail "Well, it really SHOULD fail..."))))
       
-      (assert "Can make assertions."
-              (and (should-fail (&;run "yolo"
-                                       (&;assert "Well, it really SHOULD fail..." false)))
-                   (|> (&;run "yolo"
-                              (&;assert "GO, GO, GO!" true))
-                       (case> (#;Right []) true
-                              _ false))))
+      (test "Can make assertions."
+            (and (should-fail (&;run "yolo"
+                                     (&;assert "Well, it really SHOULD fail..." false)))
+                 (|> (&;run "yolo"
+                            (&;assert "GO, GO, GO!" true))
+                     (case> (#;Right []) true
+                            _ false))))
 
-      (assert "Can apply a lexer multiple times."
-              (and (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
-                                 (&;run "0123456789ABCDEF yolo"
-                                        (&;many &;hex-digit)))
-                   (should-fail (&;run "yolo"
-                                       (&;many &;hex-digit)))
+      (test "Can apply a lexer multiple times."
+            (and (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
+                               (&;run "0123456789ABCDEF yolo"
+                                      (&;many &;hex-digit)))
+                 (should-fail (&;run "yolo"
+                                     (&;many &;hex-digit)))
 
-                   (should-passL (list)
-                                 (&;run "yolo"
-                                        (&;some &;hex-digit)))))
+                 (should-passL (list)
+                               (&;run "yolo"
+                                      (&;some &;hex-digit)))))
       
-      (assert "Can lex exactly N elements."
-              (and (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
-                                 (&;run "0123456789ABCDEF yolo"
-                                        (&;exactly +16 &;hex-digit)))
-                   (should-passL (list "0" "1" "2")
-                                 (&;run "0123456789ABCDEF yolo"
-                                        (&;exactly +3 &;hex-digit)))
-                   (should-fail (&;run "0123456789ABCDEF yolo"
-                                       (&;exactly +17 &;hex-digit)))))
+      (test "Can lex exactly N elements."
+            (and (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
+                               (&;run "0123456789ABCDEF yolo"
+                                      (&;exactly +16 &;hex-digit)))
+                 (should-passL (list "0" "1" "2")
+                               (&;run "0123456789ABCDEF yolo"
+                                      (&;exactly +3 &;hex-digit)))
+                 (should-fail (&;run "0123456789ABCDEF yolo"
+                                     (&;exactly +17 &;hex-digit)))))
       
-      (assert "Can lex at-most N elements."
-              (and (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
-                                 (&;run "0123456789ABCDEF yolo"
-                                        (&;at-most +16 &;hex-digit)))
-                   (should-passL (list "0" "1" "2")
-                                 (&;run "0123456789ABCDEF yolo"
-                                        (&;at-most +3 &;hex-digit)))
-                   (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
-                                 (&;run "0123456789ABCDEF yolo"
-                                        (&;at-most +17 &;hex-digit)))))
+      (test "Can lex at-most N elements."
+            (and (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
+                               (&;run "0123456789ABCDEF yolo"
+                                      (&;at-most +16 &;hex-digit)))
+                 (should-passL (list "0" "1" "2")
+                               (&;run "0123456789ABCDEF yolo"
+                                      (&;at-most +3 &;hex-digit)))
+                 (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
+                               (&;run "0123456789ABCDEF yolo"
+                                      (&;at-most +17 &;hex-digit)))))
       
-      (assert "Can lex tokens between lower and upper boundaries of quantity."
-              (and (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
-                                 (&;run "0123456789ABCDEF yolo"
-                                        (&;between +0 +16 &;hex-digit)))
-                   (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
-                                 (&;run "0123456789ABCDEF yolo"
-                                        (&;between +3 +16 &;hex-digit)))
-                   (should-fail (&;run "0123456789ABCDEF yolo"
-                                       (&;between +17 +100 &;hex-digit)))
-                   (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
-                                 (&;run "0123456789ABCDEF yolo"
-                                        (&;between +15 +20 &;hex-digit)))))
+      (test "Can lex tokens between lower and upper boundaries of quantity."
+            (and (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
+                               (&;run "0123456789ABCDEF yolo"
+                                      (&;between +0 +16 &;hex-digit)))
+                 (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
+                               (&;run "0123456789ABCDEF yolo"
+                                      (&;between +3 +16 &;hex-digit)))
+                 (should-fail (&;run "0123456789ABCDEF yolo"
+                                     (&;between +17 +100 &;hex-digit)))
+                 (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
+                               (&;run "0123456789ABCDEF yolo"
+                                      (&;between +15 +20 &;hex-digit)))))
 
-      (assert "Can optionally lex a token."
-              (and (|> (&;run "123abc"
-                              (&;opt &;hex-digit))
-                       (case> (#;Right (#;Some "1")) true
-                              _ false))
-                   (|> (&;run "yolo"
-                              (&;opt &;hex-digit))
-                       (case> (#;Right #;None) true
-                              _ false))))
+      (test "Can optionally lex a token."
+            (and (|> (&;run "123abc"
+                            (&;opt &;hex-digit))
+                     (case> (#;Right (#;Some "1")) true
+                            _ false))
+                 (|> (&;run "yolo"
+                            (&;opt &;hex-digit))
+                     (case> (#;Right #;None) true
+                            _ false))))
 
-      (assert "Can take into account separators during lexing."
-              (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "a" "b" "c" "d" "e" "f")
-                            (&;run "0 1 2 3 4 5 6 7 8 9 a b c d e f YOLO"
-                                   (&;sep-by &;space &;hex-digit))))
+      (test "Can take into account separators during lexing."
+            (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "a" "b" "c" "d" "e" "f")
+                          (&;run "0 1 2 3 4 5 6 7 8 9 a b c d e f YOLO"
+                                 (&;sep-by &;space &;hex-digit))))
       
-      (assert "Can obtain the whole of the remaining input."
-              (should-passT "yolo" (&;run "yolo"
-                                          &;get-input)))
+      (test "Can obtain the whole of the remaining input."
+            (should-passT "yolo" (&;run "yolo"
+                                        &;get-input)))
       ))
diff --git a/stdlib/test/test/lux/data/text/regex.lux b/stdlib/test/test/lux/data/text/regex.lux
index e4cfa2e10..bef24c0bf 100644
--- a/stdlib/test/test/lux/data/text/regex.lux
+++ b/stdlib/test/test/lux/data/text/regex.lux
@@ -47,238 +47,238 @@
                             false))))))
 
 ## [Tests]
-(test: "Regular Expressions [Basics]"
-  (assert "Can parse character literals."
-          (and (should-pass (&;regex "a") "a")
-               (should-fail (&;regex "a") ".")
-               (should-pass (&;regex "\\.") ".")
-               (should-fail (&;regex "\\.") "a"))))
-
-(test: "Regular Expressions [System character classes]"
+(context: "Regular Expressions [Basics]"
+  (test "Can parse character literals."
+        (and (should-pass (&;regex "a") "a")
+             (should-fail (&;regex "a") ".")
+             (should-pass (&;regex "\\.") ".")
+             (should-fail (&;regex "\\.") "a"))))
+
+(context: "Regular Expressions [System character classes]"
   ($_ seq
-      (assert "Can parse anything."
-              (should-pass (&;regex ".") "a"))
+      (test "Can parse anything."
+            (should-pass (&;regex ".") "a"))
 
-      (assert "Can parse digits."
-              (and (should-pass (&;regex "\\d") "0")
-                   (should-fail (&;regex "\\d") "m")))
+      (test "Can parse digits."
+            (and (should-pass (&;regex "\\d") "0")
+                 (should-fail (&;regex "\\d") "m")))
 
-      (assert "Can parse non digits."
-              (and (should-pass (&;regex "\\D") "m")
-                   (should-fail (&;regex "\\D") "0")))
+      (test "Can parse non digits."
+            (and (should-pass (&;regex "\\D") "m")
+                 (should-fail (&;regex "\\D") "0")))
 
-      (assert "Can parse white-space."
-              (and (should-pass (&;regex "\\s") " ")
-                   (should-fail (&;regex "\\s") "m")))
+      (test "Can parse white-space."
+            (and (should-pass (&;regex "\\s") " ")
+                 (should-fail (&;regex "\\s") "m")))
 
-      (assert "Can parse non white-space."
-              (and (should-pass (&;regex "\\S") "m")
-                   (should-fail (&;regex "\\S") " ")))
+      (test "Can parse non white-space."
+            (and (should-pass (&;regex "\\S") "m")
+                 (should-fail (&;regex "\\S") " ")))
 
-      (assert "Can parse word characters."
-              (and (should-pass (&;regex "\\w") "_")
-                   (should-fail (&;regex "\\w") "^")))
+      (test "Can parse word characters."
+            (and (should-pass (&;regex "\\w") "_")
+                 (should-fail (&;regex "\\w") "^")))
 
-      (assert "Can parse non word characters."
-              (and (should-pass (&;regex "\\W") ".")
-                   (should-fail (&;regex "\\W") "a")))
+      (test "Can parse non word characters."
+            (and (should-pass (&;regex "\\W") ".")
+                 (should-fail (&;regex "\\W") "a")))
       ))
 
-(test: "Regular Expressions [Special system character classes : Part 1]"
+(context: "Regular Expressions [Special system character classes : Part 1]"
   ($_ seq
-      (assert "Can parse using special character classes."
-              (and (and (should-pass (&;regex "\\p{Lower}") "m")
-                        (should-fail (&;regex "\\p{Lower}") "M"))
+      (test "Can parse using special character classes."
+            (and (and (should-pass (&;regex "\\p{Lower}") "m")
+                      (should-fail (&;regex "\\p{Lower}") "M"))
 
-                   (and (should-pass (&;regex "\\p{Upper}") "M")
-                        (should-fail (&;regex "\\p{Upper}") "m"))
+                 (and (should-pass (&;regex "\\p{Upper}") "M")
+                      (should-fail (&;regex "\\p{Upper}") "m"))
 
-                   (and (should-pass (&;regex "\\p{Alpha}") "M")
-                        (should-fail (&;regex "\\p{Alpha}") "0"))
+                 (and (should-pass (&;regex "\\p{Alpha}") "M")
+                      (should-fail (&;regex "\\p{Alpha}") "0"))
 
-                   (and (should-pass (&;regex "\\p{Digit}") "1")
-                        (should-fail (&;regex "\\p{Digit}") "n"))
+                 (and (should-pass (&;regex "\\p{Digit}") "1")
+                      (should-fail (&;regex "\\p{Digit}") "n"))
 
-                   (and (should-pass (&;regex "\\p{Alnum}") "1")
-                        (should-fail (&;regex "\\p{Alnum}") "."))
+                 (and (should-pass (&;regex "\\p{Alnum}") "1")
+                      (should-fail (&;regex "\\p{Alnum}") "."))
 
-                   (and (should-pass (&;regex "\\p{Space}") " ")
-                        (should-fail (&;regex "\\p{Space}") "."))
-                   ))
+                 (and (should-pass (&;regex "\\p{Space}") " ")
+                      (should-fail (&;regex "\\p{Space}") "."))
+                 ))
       ))
 
-(test: "Regular Expressions [Special system character classes : Part 2]"
+(context: "Regular Expressions [Special system character classes : Part 2]"
   ($_ seq
-      (assert "Can parse using special character classes."
-              (and (and (should-pass (&;regex "\\p{HexDigit}") "a")
-                        (should-fail (&;regex "\\p{HexDigit}") "."))
+      (test "Can parse using special character classes."
+            (and (and (should-pass (&;regex "\\p{HexDigit}") "a")
+                      (should-fail (&;regex "\\p{HexDigit}") "."))
 
-                   (and (should-pass (&;regex "\\p{OctDigit}") "6")
-                        (should-fail (&;regex "\\p{OctDigit}") "."))
+                 (and (should-pass (&;regex "\\p{OctDigit}") "6")
+                      (should-fail (&;regex "\\p{OctDigit}") "."))
 
-                   (and (should-pass (&;regex "\\p{Blank}") "\t")
-                        (should-fail (&;regex "\\p{Blank}") "."))
+                 (and (should-pass (&;regex "\\p{Blank}") "\t")
+                      (should-fail (&;regex "\\p{Blank}") "."))
 
-                   (and (should-pass (&;regex "\\p{ASCII}") "\t")
-                        (should-fail (&;regex "\\p{ASCII}") "\u1234"))
+                 (and (should-pass (&;regex "\\p{ASCII}") "\t")
+                      (should-fail (&;regex "\\p{ASCII}") "\u1234"))
 
-                   (and (should-pass (&;regex "\\p{Contrl}") "\u0012")
-                        (should-fail (&;regex "\\p{Contrl}") "a"))
+                 (and (should-pass (&;regex "\\p{Contrl}") "\u0012")
+                      (should-fail (&;regex "\\p{Contrl}") "a"))
 
-                   (and (should-pass (&;regex "\\p{Punct}") "@")
-                        (should-fail (&;regex "\\p{Punct}") "a"))
+                 (and (should-pass (&;regex "\\p{Punct}") "@")
+                      (should-fail (&;regex "\\p{Punct}") "a"))
 
-                   (and (should-pass (&;regex "\\p{Graph}") "@")
-                        (should-fail (&;regex "\\p{Graph}") " "))
+                 (and (should-pass (&;regex "\\p{Graph}") "@")
+                      (should-fail (&;regex "\\p{Graph}") " "))
 
-                   (and (should-pass (&;regex "\\p{Print}") "\u0020")
-                        (should-fail (&;regex "\\p{Print}") "\u1234"))
-                   ))
+                 (and (should-pass (&;regex "\\p{Print}") "\u0020")
+                      (should-fail (&;regex "\\p{Print}") "\u1234"))
+                 ))
       ))
 
-(test: "Regular Expressions [Custom character classes : Part 1]"
+(context: "Regular Expressions [Custom character classes : Part 1]"
   ($_ seq
-      (assert "Can parse using custom character classes."
-              (and (should-pass (&;regex "[abc]") "a")
-                   (should-fail (&;regex "[abc]") "m")))
-
-      (assert "Can parse using character ranges."
-              (and (should-pass (&;regex "[a-z]") "a")
-                   (should-pass (&;regex "[a-z]") "m")
-                   (should-pass (&;regex "[a-z]") "z")))
-
-      (assert "Can combine character ranges."
-              (and (should-pass (&;regex "[a-zA-Z]") "a")
-                   (should-pass (&;regex "[a-zA-Z]") "m")
-                   (should-pass (&;regex "[a-zA-Z]") "z")
-                   (should-pass (&;regex "[a-zA-Z]") "A")
-                   (should-pass (&;regex "[a-zA-Z]") "M")
-                   (should-pass (&;regex "[a-zA-Z]") "Z")))
+      (test "Can parse using custom character classes."
+            (and (should-pass (&;regex "[abc]") "a")
+                 (should-fail (&;regex "[abc]") "m")))
+
+      (test "Can parse using character ranges."
+            (and (should-pass (&;regex "[a-z]") "a")
+                 (should-pass (&;regex "[a-z]") "m")
+                 (should-pass (&;regex "[a-z]") "z")))
+
+      (test "Can combine character ranges."
+            (and (should-pass (&;regex "[a-zA-Z]") "a")
+                 (should-pass (&;regex "[a-zA-Z]") "m")
+                 (should-pass (&;regex "[a-zA-Z]") "z")
+                 (should-pass (&;regex "[a-zA-Z]") "A")
+                 (should-pass (&;regex "[a-zA-Z]") "M")
+                 (should-pass (&;regex "[a-zA-Z]") "Z")))
       ))
 
-(test: "Regular Expressions [Custom character classes : Part 2]"
+(context: "Regular Expressions [Custom character classes : Part 2]"
   ($_ seq
-      (assert "Can negate custom character classes."
-              (and (should-fail (&;regex "[^abc]") "a")
-                   (should-pass (&;regex "[^abc]") "m")))
+      (test "Can negate custom character classes."
+            (and (should-fail (&;regex "[^abc]") "a")
+                 (should-pass (&;regex "[^abc]") "m")))
 
-      (assert "Can negate character ranges.."
-              (and (should-fail (&;regex "[^a-z]") "a")
-                   (should-pass (&;regex "[^a-z]") "0")))
+      (test "Can negate character ranges.."
+            (and (should-fail (&;regex "[^a-z]") "a")
+                 (should-pass (&;regex "[^a-z]") "0")))
 
-      (assert "Can parse negate combinations of character ranges."
-              (and (should-fail (&;regex "[^a-zA-Z]") "a")
-                   (should-pass (&;regex "[^a-zA-Z]") "0")))
+      (test "Can parse negate combinations of character ranges."
+            (and (should-fail (&;regex "[^a-zA-Z]") "a")
+                 (should-pass (&;regex "[^a-zA-Z]") "0")))
       ))
 
-(test: "Regular Expressions [Custom character classes : Part 3]"
+(context: "Regular Expressions [Custom character classes : Part 3]"
   ($_ seq
-      (assert "Can make custom character classes more specific."
-              (and (let [RE (&;regex "[a-z&&[def]]")]
-                     (and (should-fail RE "a")
-                          (should-pass RE "d")))
-
-                   (let [RE (&;regex "[a-z&&[^bc]]")]
-                     (and (should-pass RE "a")
-                          (should-fail RE "b")))
-
-                   (let [RE (&;regex "[a-z&&[^m-p]]")]
-                     (and (should-pass RE "a")
-                          (should-fail RE "m")
-                          (should-fail RE "p")))))
+      (test "Can make custom character classes more specific."
+            (and (let [RE (&;regex "[a-z&&[def]]")]
+                   (and (should-fail RE "a")
+                        (should-pass RE "d")))
+
+                 (let [RE (&;regex "[a-z&&[^bc]]")]
+                   (and (should-pass RE "a")
+                        (should-fail RE "b")))
+
+                 (let [RE (&;regex "[a-z&&[^m-p]]")]
+                   (and (should-pass RE "a")
+                        (should-fail RE "m")
+                        (should-fail RE "p")))))
       ))
 
-(test: "Regular Expressions [Reference]"
+(context: "Regular Expressions [Reference]"
   (let [number (&;regex "\\d+")]
-    (assert "Can build complex regexs by combining simpler ones."
-            (should-check ["809-345-6789" "809" "345" "6789"] (&;regex "(\\@<number>)-(\\@<number>)-(\\@<number>)") "809-345-6789"))))
+    (test "Can build complex regexs by combining simpler ones."
+          (should-check ["809-345-6789" "809" "345" "6789"] (&;regex "(\\@<number>)-(\\@<number>)-(\\@<number>)") "809-345-6789"))))
 
-(test: "Regular Expressions [Fuzzy Quantifiers]"
+(context: "Regular Expressions [Fuzzy Quantifiers]"
   ($_ seq
-      (assert "Can sequentially combine patterns."
-              (should-passT "aa" (&;regex "aa") "aa"))
+      (test "Can sequentially combine patterns."
+            (should-passT "aa" (&;regex "aa") "aa"))
 
-      (assert "Can match patterns optionally."
-              (and (should-passT "a" (&;regex "a?") "a")
-                   (should-passT "" (&;regex "a?") "")))
+      (test "Can match patterns optionally."
+            (and (should-passT "a" (&;regex "a?") "a")
+                 (should-passT "" (&;regex "a?") "")))
 
-      (assert "Can match a pattern 0 or more times."
-              (and (should-passT "aaa" (&;regex "a*") "aaa")
-                   (should-passT "" (&;regex "a*") "")))
+      (test "Can match a pattern 0 or more times."
+            (and (should-passT "aaa" (&;regex "a*") "aaa")
+                 (should-passT "" (&;regex "a*") "")))
 
-      (assert "Can match a pattern 1 or more times."
-              (and (should-passT "aaa" (&;regex "a+") "aaa")
-                   (should-passT "a" (&;regex "a+") "a")
-                   (should-fail (&;regex "a+") "")))
+      (test "Can match a pattern 1 or more times."
+            (and (should-passT "aaa" (&;regex "a+") "aaa")
+                 (should-passT "a" (&;regex "a+") "a")
+                 (should-fail (&;regex "a+") "")))
       ))
 
-(test: "Regular Expressions [Crisp Quantifiers]"
+(context: "Regular Expressions [Crisp Quantifiers]"
   ($_ seq
-      (assert "Can match a pattern N times."
-              (and (should-passT "aa" (&;regex "a{2}") "aa")
-                   (should-passT "a" (&;regex "a{1}") "aa")
-                   (should-fail (&;regex "a{3}") "aa")))
-
-      (assert "Can match a pattern at-least N times."
-              (and (should-passT "aa" (&;regex "a{1,}") "aa")
-                   (should-passT "aa" (&;regex "a{2,}") "aa")
-                   (should-fail (&;regex "a{3,}") "aa")))
-
-      (assert "Can match a pattern at-most N times."
-              (and (should-passT "a" (&;regex "a{,1}") "aa")
-                   (should-passT "aa" (&;regex "a{,2}") "aa")
-                   (should-passT "aa" (&;regex "a{,3}") "aa")))
-
-      (assert "Can match a pattern between N and M times."
-              (and (should-passT "a" (&;regex "a{1,2}") "a")
-                   (should-passT "aa" (&;regex "a{1,2}") "aa")
-                   (should-passT "aa" (&;regex "a{1,2}") "aaa")))
+      (test "Can match a pattern N times."
+            (and (should-passT "aa" (&;regex "a{2}") "aa")
+                 (should-passT "a" (&;regex "a{1}") "aa")
+                 (should-fail (&;regex "a{3}") "aa")))
+
+      (test "Can match a pattern at-least N times."
+            (and (should-passT "aa" (&;regex "a{1,}") "aa")
+                 (should-passT "aa" (&;regex "a{2,}") "aa")
+                 (should-fail (&;regex "a{3,}") "aa")))
+
+      (test "Can match a pattern at-most N times."
+            (and (should-passT "a" (&;regex "a{,1}") "aa")
+                 (should-passT "aa" (&;regex "a{,2}") "aa")
+                 (should-passT "aa" (&;regex "a{,3}") "aa")))
+
+      (test "Can match a pattern between N and M times."
+            (and (should-passT "a" (&;regex "a{1,2}") "a")
+                 (should-passT "aa" (&;regex "a{1,2}") "aa")
+                 (should-passT "aa" (&;regex "a{1,2}") "aaa")))
       ))
 
-(test: "Regular Expressions [Groups]"
+(context: "Regular Expressions [Groups]"
   ($_ seq
-      (assert "Can extract groups of sub-matches specified in a pattern."
-              (and (should-check ["abc" "b"] (&;regex "a(.)c") "abc")
-                   (should-check ["abbbbbc" "bbbbb"] (&;regex "a(b+)c") "abbbbbc")
-                   (should-check ["809-345-6789" "809" "345" "6789"] (&;regex "(\\d{3})-(\\d{3})-(\\d{4})") "809-345-6789")
-                   (should-check ["809-345-6789" "809" "6789"] (&;regex "(\\d{3})-(?:\\d{3})-(\\d{4})") "809-345-6789")
-                   (should-check ["809-809-6789" "809" "6789"] (&;regex "(\\d{3})-\\0-(\\d{4})") "809-809-6789")
-                   (should-check ["809-809-6789" "809" "6789"] (&;regex "(?<code>\\d{3})-\\k<code>-(\\d{4})") "809-809-6789")
-                   (should-check ["809-809-6789-6789" "809" "6789"] (&;regex "(?<code>\\d{3})-\\k<code>-(\\d{4})-\\0") "809-809-6789-6789")))
-
-      (assert "Can specify groups within groups."
-              (should-check ["809-345-6789" "809" ["345-6789" "345" "6789"]] (&;regex "(\\d{3})-((\\d{3})-(\\d{4}))") "809-345-6789"))
+      (test "Can extract groups of sub-matches specified in a pattern."
+            (and (should-check ["abc" "b"] (&;regex "a(.)c") "abc")
+                 (should-check ["abbbbbc" "bbbbb"] (&;regex "a(b+)c") "abbbbbc")
+                 (should-check ["809-345-6789" "809" "345" "6789"] (&;regex "(\\d{3})-(\\d{3})-(\\d{4})") "809-345-6789")
+                 (should-check ["809-345-6789" "809" "6789"] (&;regex "(\\d{3})-(?:\\d{3})-(\\d{4})") "809-345-6789")
+                 (should-check ["809-809-6789" "809" "6789"] (&;regex "(\\d{3})-\\0-(\\d{4})") "809-809-6789")
+                 (should-check ["809-809-6789" "809" "6789"] (&;regex "(?<code>\\d{3})-\\k<code>-(\\d{4})") "809-809-6789")
+                 (should-check ["809-809-6789-6789" "809" "6789"] (&;regex "(?<code>\\d{3})-\\k<code>-(\\d{4})-\\0") "809-809-6789-6789")))
+
+      (test "Can specify groups within groups."
+            (should-check ["809-345-6789" "809" ["345-6789" "345" "6789"]] (&;regex "(\\d{3})-((\\d{3})-(\\d{4}))") "809-345-6789"))
       ))
 
-(test: "Regular Expressions [Alternation]"
+(context: "Regular Expressions [Alternation]"
   ($_ seq
-      (assert "Can specify alternative patterns."
-              (and (should-check ["a" (+0 [])] (&;regex "a|b") "a")
-                   (should-check ["b" (+1 [])] (&;regex "a|b") "b")
-                   (should-fail (&;regex "a|b") "c")))
-
-      (assert "Can have groups within alternations."
-              (and (should-check ["abc" (+0 ["b" "c"])] (&;regex "a(.)(.)|b(.)(.)") "abc")
-                   (should-check ["bcd" (+1 ["c" "d"])] (&;regex "a(.)(.)|b(.)(.)") "bcd")
-                   (should-fail (&;regex "a(.)(.)|b(.)(.)") "cde")
-
-                   (should-check ["809-345-6789" (+0 ["809" "345-6789" "345" "6789"])]
-                                 (&;regex "(\\d{3})-((\\d{3})-(\\d{4}))|b(.)d")
-                                 "809-345-6789")))
+      (test "Can specify alternative patterns."
+            (and (should-check ["a" (+0 [])] (&;regex "a|b") "a")
+                 (should-check ["b" (+1 [])] (&;regex "a|b") "b")
+                 (should-fail (&;regex "a|b") "c")))
+
+      (test "Can have groups within alternations."
+            (and (should-check ["abc" (+0 ["b" "c"])] (&;regex "a(.)(.)|b(.)(.)") "abc")
+                 (should-check ["bcd" (+1 ["c" "d"])] (&;regex "a(.)(.)|b(.)(.)") "bcd")
+                 (should-fail (&;regex "a(.)(.)|b(.)(.)") "cde")
+
+                 (should-check ["809-345-6789" (+0 ["809" "345-6789" "345" "6789"])]
+                               (&;regex "(\\d{3})-((\\d{3})-(\\d{4}))|b(.)d")
+                               "809-345-6789")))
       ))
 
-(test: "Pattern-matching"
+(context: "Pattern-matching"
   [sample1 (R;text +3)
    sample2 (R;text +3)
    sample3 (R;text +4)]
   (case (format sample1 "-" sample2 "-" sample3)
     (&;^regex "(.{3})-(.{3})-(.{4})"
               [_ match1 match2 match3])
-    (assert "Can pattern-match using regular-expressions."
-            (and (T/= sample1 match1)
-                 (T/= sample2 match2)
-                 (T/= sample3 match3)))
+    (test "Can pattern-match using regular-expressions."
+          (and (T/= sample1 match1)
+               (T/= sample2 match2)
+               (T/= sample3 match3)))
 
     _
-    (assert "Cannot pattern-match using regular-expressions."
-            false)))
+    (test "Cannot pattern-match using regular-expressions."
+          false)))
diff --git a/stdlib/test/test/lux/host.js.lux b/stdlib/test/test/lux/host.js.lux
index b7dbe043f..f533a8fe6 100644
--- a/stdlib/test/test/lux/host.js.lux
+++ b/stdlib/test/test/lux/host.js.lux
@@ -7,25 +7,25 @@
        ["R" math/random])
   lux/test)
 
-(test: "JavaScript operations"
+(context: "JavaScript operations"
   ($_ seq
-      (assert "Null equals itself."
-              (is (&;null) (&;null)))
+      (test "Null equals itself."
+            (is (&;null) (&;null)))
 
-      (assert "Undefined equals itself."
-              (is (&;undef) (&;undef)))
+      (test "Undefined equals itself."
+            (is (&;undef) (&;undef)))
 
-      (assert "Can reference JavaScript objects."
-              (is (&;ref "Math") (&;ref "Math")))
+      (test "Can reference JavaScript objects."
+            (is (&;ref "Math") (&;ref "Math")))
 
-      (assert "Can create objects and access their fields."
-              (|> (&;object "foo" "BAR")
-                  (&;get "foo" Text)
-                  (is "BAR")))
+      (test "Can create objects and access their fields."
+            (|> (&;object "foo" "BAR")
+                (&;get "foo" Text)
+                (is "BAR")))
 
-      (assert "Can call JavaScript functions"
-              (and (is 124.0
-                       (&;call! (&;ref "Math.ceil" &;Function) [123.45] Real))
-                   (is 124.0
-                       (&;call! (&;ref "Math") "ceil" [123.45] Real))))
+      (test "Can call JavaScript functions"
+            (and (is 124.0
+                     (&;call! (&;ref "Math.ceil" &;Function) [123.45] Real))
+                 (is 124.0
+                     (&;call! (&;ref "Math") "ceil" [123.45] Real))))
       ))
diff --git a/stdlib/test/test/lux/host.jvm.lux b/stdlib/test/test/lux/host.jvm.lux
index ae12784af..a90db336c 100644
--- a/stdlib/test/test/lux/host.jvm.lux
+++ b/stdlib/test/test/lux/host.jvm.lux
@@ -52,14 +52,14 @@
 (interface: TestInterface
   ([] foo [boolean String] void #throws [Exception]))
 
-(test: "Conversions"
+(context: "Conversions"
   [sample R;int]
   (with-expansions
     [<int-convs> (do-template [<to> <from> <message>]
-                   [(assert <message>
-                            (or (|> sample <to> <from> (i.= sample))
-                                (let [capped-sample (|> sample <to> <from>)]
-                                  (|> capped-sample <to> <from> (i.= capped-sample)))))]
+                   [(test <message>
+                          (or (|> sample <to> <from> (i.= sample))
+                              (let [capped-sample (|> sample <to> <from>)]
+                                (|> capped-sample <to> <from> (i.= capped-sample)))))]
 
                    [&;l2b &;b2l "Can succesfully convert to/from byte."]
                    [&;l2s &;s2l "Can succesfully convert to/from short."]
@@ -72,42 +72,42 @@
         <int-convs>
         )))
 
-(test: "Miscellaneous"
+(context: "Miscellaneous"
   ($_ seq
-      (assert "Can check if an object is of a certain class."
-              (and (&;instance? String "")
-                   (not (&;instance? Long ""))
-                   (&;instance? Object "")
-                   (not (&;instance? Object (&;null)))))
-
-      (assert "Can run code in a \"synchronized\" block."
-              (&;synchronized "" true))
-
-      (assert "Can access Class instances."
-              (Text/= "java.lang.Class" (Class.getName [] (&;class-for java.lang.Class))))
-
-      (assert "Can check if a value is null."
-              (and (&;null? (&;null))
-                   (not (&;null? ""))))
-
-      (assert "Can safely convert nullable references into Maybe values."
-              (and (|> (: (Maybe Object) (&;??? (&;null)))
-                       (case> #;None true
-                              _ false))
-                   (|> (: (Maybe Object) (&;??? ""))
-                       (case> (#;Some _) true
-                              _ false))))
+      (test "Can check if an object is of a certain class."
+            (and (&;instance? String "")
+                 (not (&;instance? Long ""))
+                 (&;instance? Object "")
+                 (not (&;instance? Object (&;null)))))
+
+      (test "Can run code in a \"synchronized\" block."
+            (&;synchronized "" true))
+
+      (test "Can access Class instances."
+            (Text/= "java.lang.Class" (Class.getName [] (&;class-for java.lang.Class))))
+
+      (test "Can check if a value is null."
+            (and (&;null? (&;null))
+                 (not (&;null? ""))))
+
+      (test "Can safely convert nullable references into Maybe values."
+            (and (|> (: (Maybe Object) (&;??? (&;null)))
+                     (case> #;None true
+                            _ false))
+                 (|> (: (Maybe Object) (&;??? ""))
+                     (case> (#;Some _) true
+                            _ false))))
       ))
 
-(test: "Arrays"
+(context: "Arrays"
   [size (|> R;nat (:: @ map (|>. (n.% +100) (n.max +1))))
    idx (|> R;nat (:: @ map (n.% size)))
    value R;int]
   ($_ seq
-      (assert "Can create arrays of some length."
-              (n.= size (&;array-length (&;array Long size))))
+      (test "Can create arrays of some length."
+            (n.= size (&;array-length (&;array Long size))))
 
-      (assert "Can set and get array values."
-              (let [arr (&;array Long size)]
-                (exec (&;array-store idx value arr)
-                  (i.= value (&;array-load idx arr)))))))
+      (test "Can set and get array values."
+            (let [arr (&;array Long size)]
+              (exec (&;array-store idx value arr)
+                (i.= value (&;array-load idx arr)))))))
diff --git a/stdlib/test/test/lux/io.lux b/stdlib/test/test/lux/io.lux
index 839996e81..0347d75ec 100644
--- a/stdlib/test/test/lux/io.lux
+++ b/stdlib/test/test/lux/io.lux
@@ -7,15 +7,15 @@
              [number]))
   lux/test)
 
-(test: "I/O"
+(context: "I/O"
   ($_ seq
-      (assert "" (Text/= "YOLO" (&;run (&;io "YOLO"))))
-      (assert "" (i.= 11 (&;run (:: &;Functor<IO> map i.inc (&;io 10)))))
-      (assert "" (i.= 10 (&;run (:: &;Applicative<IO> wrap 10))))
-      (assert "" (i.= 30 (&;run (let [(^open "&/") &;Applicative<IO>]
-                                  (&/apply (&/wrap (i.+ 10)) (&/wrap 20))))))
-      (assert "" (i.= 30 (&;run (do &;Monad<IO>
-                                  [f (wrap i.+)
-                                   x (wrap 10)
-                                   y (wrap 20)]
-                                  (wrap (f x y))))))))
+      (test "" (Text/= "YOLO" (&;run (&;io "YOLO"))))
+      (test "" (i.= 11 (&;run (:: &;Functor<IO> map i.inc (&;io 10)))))
+      (test "" (i.= 10 (&;run (:: &;Applicative<IO> wrap 10))))
+      (test "" (i.= 30 (&;run (let [(^open "&/") &;Applicative<IO>]
+                                (&/apply (&/wrap (i.+ 10)) (&/wrap 20))))))
+      (test "" (i.= 30 (&;run (do &;Monad<IO>
+                                [f (wrap i.+)
+                                 x (wrap 10)
+                                 y (wrap 20)]
+                                (wrap (f x y))))))))
diff --git a/stdlib/test/test/lux/macro/code.lux b/stdlib/test/test/lux/macro/code.lux
index 2f05ad926..fd1d7415e 100644
--- a/stdlib/test/test/lux/macro/code.lux
+++ b/stdlib/test/test/lux/macro/code.lux
@@ -9,12 +9,12 @@
        (macro ["&" code]))
   lux/test)
 
-(test: "Code"
+(context: "Code"
   (with-expansions
     [<tests> (do-template [<expr> <text>]
-               [(assert (format "Can produce Code node: " <text>)
-                        (and (T/= <text> (&;to-text <expr>))
-                             (:: &;Eq<Code> = <expr> <expr>)))]
+               [(test (format "Can produce Code node: " <text>)
+                      (and (T/= <text> (&;to-text <expr>))
+                           (:: &;Eq<Code> = <expr> <expr>)))]
 
                [(&;bool true)                                 "true"]
                [(&;bool false)                                "false"]
diff --git a/stdlib/test/test/lux/macro/poly/eq.lux b/stdlib/test/test/lux/macro/poly/eq.lux
index 3cd515fc6..512a7633b 100644
--- a/stdlib/test/test/lux/macro/poly/eq.lux
+++ b/stdlib/test/test/lux/macro/poly/eq.lux
@@ -53,8 +53,8 @@
 (derived: (&;Eq<?> Record))
 
 ## [Tests]
-(test: "Eq polytypism"
+(context: "Eq polytypism"
   [sample gen-record
    #let [(^open "&/") Eq<Record>]]
-  (assert "Every instance equals itself."
-          (&/= sample sample)))
+  (test "Every instance equals itself."
+        (&/= sample sample)))
diff --git a/stdlib/test/test/lux/macro/poly/functor.lux b/stdlib/test/test/lux/macro/poly/functor.lux
index 3294556a4..ae0765a60 100644
--- a/stdlib/test/test/lux/macro/poly/functor.lux
+++ b/stdlib/test/test/lux/macro/poly/functor.lux
@@ -34,5 +34,5 @@
 (derived: (&;Functor<?> My-State))
 
 ## [Tests]
-(test: "Functor polytypism"
-  (assert "" true))
+(context: "Functor polytypism"
+  (test "" true))
diff --git a/stdlib/test/test/lux/macro/poly/text-encoder.lux b/stdlib/test/test/lux/macro/poly/text-encoder.lux
index ec392fc8e..240ad7ad4 100644
--- a/stdlib/test/test/lux/macro/poly/text-encoder.lux
+++ b/stdlib/test/test/lux/macro/poly/text-encoder.lux
@@ -53,5 +53,5 @@
 (derived: (&;Codec<Text,?>::encode Record))
 
 ## [Tests]
-(test: "Text-encoding polytypism"
-  (assert "" true))
+(context: "Text-encoding polytypism"
+  (test "" true))
diff --git a/stdlib/test/test/lux/macro/syntax.lux b/stdlib/test/test/lux/macro/syntax.lux
index 9982dc01b..5f84f5c26 100644
--- a/stdlib/test/test/lux/macro/syntax.lux
+++ b/stdlib/test/test/lux/macro/syntax.lux
@@ -62,13 +62,13 @@
                    false)))))
 
 ## [Tests]
-(test: "Simple value syntax."
+(context: "Simple value syntax."
   (with-expansions
     [<simple-tests> (do-template [<assertion> <value> <ctor> <Eq> <get>]
-                      [(assert <assertion>
-                               (and (is? <Eq> <value> <get> (list (<ctor> <value>)))
-                                    (found? (s;this? (<ctor> <value>)) (list (<ctor> <value>)))
-                                    (enforced? (s;this (<ctor> <value>)) (list (<ctor> <value>)))))]
+                      [(test <assertion>
+                             (and (is? <Eq> <value> <get> (list (<ctor> <value>)))
+                                  (found? (s;this? (<ctor> <value>)) (list (<ctor> <value>)))
+                                  (enforced? (s;this (<ctor> <value>)) (list (<ctor> <value>)))))]
 
                       ["Can parse Bool syntax."   true           code;bool   bool;Eq<Bool>   s;bool]
                       ["Can parse Nat syntax."    +123           code;nat    number;Eq<Nat>  s;nat]
@@ -83,172 +83,172 @@
     ($_ seq
         <simple-tests>
 
-        (assert "Can parse symbols belonging to the current namespace."
-                (and (match "yolo"
-                            (s;run (list (code;local-symbol "yolo"))
-                                   s;local-symbol))
-                     (fails? (s;run (list (code;symbol ["yolo" "lol"]))
-                                    s;local-symbol))))
+        (test "Can parse symbols belonging to the current namespace."
+              (and (match "yolo"
+                          (s;run (list (code;local-symbol "yolo"))
+                                 s;local-symbol))
+                   (fails? (s;run (list (code;symbol ["yolo" "lol"]))
+                                  s;local-symbol))))
         
-        (assert "Can parse tags belonging to the current namespace."
-                (and (match "yolo"
-                            (s;run (list (code;local-tag "yolo"))
-                                   s;local-tag))
-                     (fails? (s;run (list (code;tag ["yolo" "lol"]))
-                                    s;local-tag))))
+        (test "Can parse tags belonging to the current namespace."
+              (and (match "yolo"
+                          (s;run (list (code;local-tag "yolo"))
+                                 s;local-tag))
+                   (fails? (s;run (list (code;tag ["yolo" "lol"]))
+                                  s;local-tag))))
         )))
 
-(test: "Complex value syntax."
+(context: "Complex value syntax."
   (with-expansions
     [<group-tests> (do-template [<type> <parser> <ctor>]
-                     [(assert (format "Can parse " <type> " syntax.")
-                              (and (match [true 123]
-                                          (s;run (list (<ctor> (list (code;bool true) (code;int 123))))
-                                                 (<parser> (s;seq s;bool s;int))))
-                                   (match true
-                                          (s;run (list (<ctor> (list (code;bool true))))
-                                                 (<parser> s;bool)))
-                                   (fails? (s;run (list (<ctor> (list (code;bool true) (code;int 123))))
-                                                  (<parser> s;bool)))
-                                   (match (#;Left true)
-                                          (s;run (list (<ctor> (list (code;bool true))))
-                                                 (<parser> (s;alt s;bool s;int))))
-                                   (match (#;Right 123)
-                                          (s;run (list (<ctor> (list (code;int 123))))
-                                                 (<parser> (s;alt s;bool s;int))))
-                                   (fails? (s;run (list (<ctor> (list (code;real 123.0))))
-                                                  (<parser> (s;alt s;bool s;int))))))]
+                     [(test (format "Can parse " <type> " syntax.")
+                            (and (match [true 123]
+                                        (s;run (list (<ctor> (list (code;bool true) (code;int 123))))
+                                               (<parser> (s;seq s;bool s;int))))
+                                 (match true
+                                        (s;run (list (<ctor> (list (code;bool true))))
+                                               (<parser> s;bool)))
+                                 (fails? (s;run (list (<ctor> (list (code;bool true) (code;int 123))))
+                                                (<parser> s;bool)))
+                                 (match (#;Left true)
+                                        (s;run (list (<ctor> (list (code;bool true))))
+                                               (<parser> (s;alt s;bool s;int))))
+                                 (match (#;Right 123)
+                                        (s;run (list (<ctor> (list (code;int 123))))
+                                               (<parser> (s;alt s;bool s;int))))
+                                 (fails? (s;run (list (<ctor> (list (code;real 123.0))))
+                                                (<parser> (s;alt s;bool s;int))))))]
 
                      ["form"  s;form  code;form]
                      ["tuple" s;tuple code;tuple])]
     ($_ seq
         <group-tests>
 
-        (assert "Can parse record syntax."
-                (match [true 123]
-                       (s;run (list (code;record (list [(code;bool true) (code;int 123)])))
-                              (s;record (s;seq s;bool s;int)))))
+        (test "Can parse record syntax."
+              (match [true 123]
+                     (s;run (list (code;record (list [(code;bool true) (code;int 123)])))
+                            (s;record (s;seq s;bool s;int)))))
         )))
 
-(test: "Assertions"
-  (assert "Can make assertions while parsing."
-          (and (match []
-                      (s;run (list (code;bool true) (code;int 123))
-                             (s;assert "yolo" true)))
-               (fails? (s;run (list (code;bool true) (code;int 123))
-                              (s;assert "yolo" false))))))
+(context: "Assertions"
+  (test "Can make assertions while parsing."
+        (and (match []
+                    (s;run (list (code;bool true) (code;int 123))
+                           (s;assert "yolo" true)))
+             (fails? (s;run (list (code;bool true) (code;int 123))
+                            (s;assert "yolo" false))))))
 
-(test: "Combinators [Part 1]"
+(context: "Combinators [Part 1]"
   ($_ seq
-      (assert "Can parse any Code."
-              (match [_ (#;Bool true)]
-                     (s;run (list (code;bool true) (code;int 123))
-                            s;any)))
-
-      (assert "Can optionally succeed with some parser."
-              (and (match (#;Some +123)
-                          (s;run (list (code;nat +123))
-                                 (s;opt s;nat)))
-                   (match #;None
-                          (s;run (list (code;int -123))
-                                 (s;opt s;nat)))))
-
-      (assert "Can apply a parser 0 or more times."
-              (and (match (list +123 +456 +789)
-                          (s;run (list (code;nat +123) (code;nat +456) (code;nat +789))
-                                 (s;some s;nat)))
-                   (match (list)
-                          (s;run (list (code;int -123))
-                                 (s;some s;nat)))))
-
-      (assert "Can apply a parser 1 or more times."
-              (and (match (list +123 +456 +789)
-                          (s;run (list (code;nat +123) (code;nat +456) (code;nat +789))
-                                 (s;many s;nat)))
-                   (match (list +123)
-                          (s;run (list (code;nat +123))
-                                 (s;many s;nat)))
-                   (fails? (s;run (list (code;int -123))
-                                  (s;many s;nat)))))
-
-      (assert "Can use either parser."
-              (and (match 123
-                          (s;run (list (code;int 123) (code;int 456) (code;int 789))
-                                 (s;either s;pos-int s;int)))
-                   (match -123
-                          (s;run (list (code;int -123) (code;int 456) (code;int 789))
-                                 (s;either s;pos-int s;int)))
-                   (fails? (s;run (list (code;bool true) (code;int 456) (code;int 789))
-                                  (s;either s;pos-int s;int)))))
-
-      (assert "Can create the opposite/negation of any parser."
-              (and (fails? (s;run (list (code;int 123) (code;int 456) (code;int 789))
-                                  (s;not s;int)))
-                   (match []
-                          (s;run (list (code;bool true) (code;int 456) (code;int 789))
-                                 (s;not s;int)))))
+      (test "Can parse any Code."
+            (match [_ (#;Bool true)]
+                   (s;run (list (code;bool true) (code;int 123))
+                          s;any)))
+
+      (test "Can optionally succeed with some parser."
+            (and (match (#;Some +123)
+                        (s;run (list (code;nat +123))
+                               (s;opt s;nat)))
+                 (match #;None
+                        (s;run (list (code;int -123))
+                               (s;opt s;nat)))))
+
+      (test "Can apply a parser 0 or more times."
+            (and (match (list +123 +456 +789)
+                        (s;run (list (code;nat +123) (code;nat +456) (code;nat +789))
+                               (s;some s;nat)))
+                 (match (list)
+                        (s;run (list (code;int -123))
+                               (s;some s;nat)))))
+
+      (test "Can apply a parser 1 or more times."
+            (and (match (list +123 +456 +789)
+                        (s;run (list (code;nat +123) (code;nat +456) (code;nat +789))
+                               (s;many s;nat)))
+                 (match (list +123)
+                        (s;run (list (code;nat +123))
+                               (s;many s;nat)))
+                 (fails? (s;run (list (code;int -123))
+                                (s;many s;nat)))))
+
+      (test "Can use either parser."
+            (and (match 123
+                        (s;run (list (code;int 123) (code;int 456) (code;int 789))
+                               (s;either s;pos-int s;int)))
+                 (match -123
+                        (s;run (list (code;int -123) (code;int 456) (code;int 789))
+                               (s;either s;pos-int s;int)))
+                 (fails? (s;run (list (code;bool true) (code;int 456) (code;int 789))
+                                (s;either s;pos-int s;int)))))
+
+      (test "Can create the opposite/negation of any parser."
+            (and (fails? (s;run (list (code;int 123) (code;int 456) (code;int 789))
+                                (s;not s;int)))
+                 (match []
+                        (s;run (list (code;bool true) (code;int 456) (code;int 789))
+                               (s;not s;int)))))
       ))
 
-(test: "Combinators Part [2]"
+(context: "Combinators Part [2]"
   ($_ seq
-      (assert "Can check whether the end has been reached."
-              (and (match true
-                          (s;run (list)
-                                 s;end?))
-                   (match false
-                          (s;run (list (code;bool true))
-                                 s;end?))))
-
-      (assert "Can ensure the end has been reached."
-              (and (match []
-                          (s;run (list)
-                                 s;end!))
-                   (fails? (s;run (list (code;bool true))
-                                  s;end!))))
-
-      (assert "Can apply a parser N times."
-              (and (match (list 123 456 789)
-                          (s;run (list (code;int 123) (code;int 456) (code;int 789))
-                                 (s;exactly +3 s;int)))
-                   (match (list 123 456)
-                          (s;run (list (code;int 123) (code;int 456) (code;int 789))
-                                 (s;exactly +2 s;int)))
-                   (fails? (s;run (list (code;int 123) (code;int 456) (code;int 789))
-                                  (s;exactly +4 s;int)))))
-
-      (assert "Can apply a parser at-least N times."
-              (and (match (list 123 456 789)
-                          (s;run (list (code;int 123) (code;int 456) (code;int 789))
-                                 (s;at-least +3 s;int)))
-                   (match (list 123 456 789)
-                          (s;run (list (code;int 123) (code;int 456) (code;int 789))
-                                 (s;at-least +2 s;int)))
-                   (fails? (s;run (list (code;int 123) (code;int 456) (code;int 789))
-                                  (s;at-least +4 s;int)))))
-
-      (assert "Can apply a parser at-most N times."
-              (and (match (list 123 456 789)
-                          (s;run (list (code;int 123) (code;int 456) (code;int 789))
-                                 (s;at-most +3 s;int)))
-                   (match (list 123 456)
-                          (s;run (list (code;int 123) (code;int 456) (code;int 789))
-                                 (s;at-most +2 s;int)))
-                   (match (list 123 456 789)
-                          (s;run (list (code;int 123) (code;int 456) (code;int 789))
-                                 (s;at-most +4 s;int)))))
-
-      (assert "Can apply a parser between N and M times."
-              (and (match (list 123 456 789)
-                          (s;run (list (code;int 123) (code;int 456) (code;int 789))
-                                 (s;between +3 +10 s;int)))
-                   (fails? (s;run (list (code;int 123) (code;int 456) (code;int 789))
-                                  (s;between +4 +10 s;int)))))
-
-      (assert "Can parse while taking separators into account."
-              (and (match (list 123 456 789)
-                          (s;run (list (code;int 123) (code;text "YOLO") (code;int 456) (code;text "YOLO") (code;int 789))
-                                 (s;sep-by (s;this (' "YOLO")) s;int)))
-                   (match (list 123 456)
-                          (s;run (list (code;int 123) (code;text "YOLO") (code;int 456) (code;int 789))
-                                 (s;sep-by (s;this (' "YOLO")) s;int)))))
+      (test "Can check whether the end has been reached."
+            (and (match true
+                        (s;run (list)
+                               s;end?))
+                 (match false
+                        (s;run (list (code;bool true))
+                               s;end?))))
+
+      (test "Can ensure the end has been reached."
+            (and (match []
+                        (s;run (list)
+                               s;end!))
+                 (fails? (s;run (list (code;bool true))
+                                s;end!))))
+
+      (test "Can apply a parser N times."
+            (and (match (list 123 456 789)
+                        (s;run (list (code;int 123) (code;int 456) (code;int 789))
+                               (s;exactly +3 s;int)))
+                 (match (list 123 456)
+                        (s;run (list (code;int 123) (code;int 456) (code;int 789))
+                               (s;exactly +2 s;int)))
+                 (fails? (s;run (list (code;int 123) (code;int 456) (code;int 789))
+                                (s;exactly +4 s;int)))))
+
+      (test "Can apply a parser at-least N times."
+            (and (match (list 123 456 789)
+                        (s;run (list (code;int 123) (code;int 456) (code;int 789))
+                               (s;at-least +3 s;int)))
+                 (match (list 123 456 789)
+                        (s;run (list (code;int 123) (code;int 456) (code;int 789))
+                               (s;at-least +2 s;int)))
+                 (fails? (s;run (list (code;int 123) (code;int 456) (code;int 789))
+                                (s;at-least +4 s;int)))))
+
+      (test "Can apply a parser at-most N times."
+            (and (match (list 123 456 789)
+                        (s;run (list (code;int 123) (code;int 456) (code;int 789))
+                               (s;at-most +3 s;int)))
+                 (match (list 123 456)
+                        (s;run (list (code;int 123) (code;int 456) (code;int 789))
+                               (s;at-most +2 s;int)))
+                 (match (list 123 456 789)
+                        (s;run (list (code;int 123) (code;int 456) (code;int 789))
+                               (s;at-most +4 s;int)))))
+
+      (test "Can apply a parser between N and M times."
+            (and (match (list 123 456 789)
+                        (s;run (list (code;int 123) (code;int 456) (code;int 789))
+                               (s;between +3 +10 s;int)))
+                 (fails? (s;run (list (code;int 123) (code;int 456) (code;int 789))
+                                (s;between +4 +10 s;int)))))
+
+      (test "Can parse while taking separators into account."
+            (and (match (list 123 456 789)
+                        (s;run (list (code;int 123) (code;text "YOLO") (code;int 456) (code;text "YOLO") (code;int 789))
+                               (s;sep-by (s;this (' "YOLO")) s;int)))
+                 (match (list 123 456)
+                        (s;run (list (code;int 123) (code;text "YOLO") (code;int 456) (code;int 789))
+                               (s;sep-by (s;this (' "YOLO")) s;int)))))
       ))
diff --git a/stdlib/test/test/lux/math.lux b/stdlib/test/test/lux/math.lux
index 2b834b9cc..a3000e7dd 100644
--- a/stdlib/test/test/lux/math.lux
+++ b/stdlib/test/test/lux/math.lux
@@ -22,100 +22,100 @@
 ## ## The JVM trigonometry functions sometimes give me funky results.
 ## ## I won't be testing this, until I can figure out what's going on, or
 ## ## come up with my own implementation
-## (test: "Trigonometry"
+## (context: "Trigonometry"
 ##   [angle (|> R;real (:: @ map (r.* &;tau)))]
 ##   ($_ seq
-##       (assert "Sine and arc-sine are inverse functions."
-##               (|> angle &;sin &;asin (within? margin angle)))
+##       (test "Sine and arc-sine are inverse functions."
+##             (|> angle &;sin &;asin (within? margin angle)))
 
-##       (assert "Cosine and arc-cosine are inverse functions."
-##               (|> angle &;cos &;acos (within? margin angle)))
+##       (test "Cosine and arc-cosine are inverse functions."
+##             (|> angle &;cos &;acos (within? margin angle)))
 
-##       (assert "Tangent and arc-tangent are inverse functions."
-##               (|> angle &;tan &;atan (within? margin angle)))
+##       (test "Tangent and arc-tangent are inverse functions."
+##             (|> angle &;tan &;atan (within? margin angle)))
 ##       ))
 
-(test: "Roots"
+(context: "Roots"
   [factor (|> R;nat (:: @ map (|>. (n.% +1000)
                                    (n.max +1)
                                    nat-to-int
                                    int-to-real)))
    base (|> R;real (:: @ map (r.* factor)))]
   ($_ seq
-      (assert "Square-root is inverse of square."
-              (|> base (&;pow 2.0) &;root2 (r.= base)))
+      (test "Square-root is inverse of square."
+            (|> base (&;pow 2.0) &;root2 (r.= base)))
       
-      (assert "Cubic-root is inverse of cube."
-              (|> base (&;pow 3.0) &;root3 (r.= base)))
+      (test "Cubic-root is inverse of cube."
+            (|> base (&;pow 3.0) &;root3 (r.= base)))
       ))
 
-(test: "Rounding"
+(context: "Rounding"
   [sample (|> R;real (:: @ map (r.* 1000.0)))]
   ($_ seq
-      (assert "The ceiling will be an integer value, and will be >= the original."
-              (let [ceil'd (&;ceil sample)]
-                (and (|> ceil'd real-to-int int-to-real (r.= ceil'd))
-                     (r.>= sample ceil'd)
-                     (r.<= 1.0 (r.- sample ceil'd)))))
-
-      (assert "The floor will be an integer value, and will be <= the original."
-              (let [floor'd (&;floor sample)]
-                (and (|> floor'd real-to-int int-to-real (r.= floor'd))
-                     (r.<= sample floor'd)
-                     (r.<= 1.0 (r.- floor'd sample)))))
-
-      (assert "The round will be an integer value, and will be < or > or = the original."
-              (let [round'd (&;round sample)]
-                (and (|> round'd real-to-int int-to-real (r.= round'd))
-                     (r.<= 1.0 (r/abs (r.- sample round'd))))))
+      (test "The ceiling will be an integer value, and will be >= the original."
+            (let [ceil'd (&;ceil sample)]
+              (and (|> ceil'd real-to-int int-to-real (r.= ceil'd))
+                   (r.>= sample ceil'd)
+                   (r.<= 1.0 (r.- sample ceil'd)))))
+
+      (test "The floor will be an integer value, and will be <= the original."
+            (let [floor'd (&;floor sample)]
+              (and (|> floor'd real-to-int int-to-real (r.= floor'd))
+                   (r.<= sample floor'd)
+                   (r.<= 1.0 (r.- floor'd sample)))))
+
+      (test "The round will be an integer value, and will be < or > or = the original."
+            (let [round'd (&;round sample)]
+              (and (|> round'd real-to-int int-to-real (r.= round'd))
+                   (r.<= 1.0 (r/abs (r.- sample round'd))))))
       ))
 
-(test: "Exponentials and logarithms"
+(context: "Exponentials and logarithms"
   [sample (|> R;real (:: @ map (r.* 10.0)))]
-  (assert "Logarithm is the inverse of exponential."
-          (|> sample &;exp &;log (within? 1.0e-15 sample))))
+  (test "Logarithm is the inverse of exponential."
+        (|> sample &;exp &;log (within? 1.0e-15 sample))))
 
-(test: "Greatest-Common-Divisor and Least-Common-Multiple"
+(context: "Greatest-Common-Divisor and Least-Common-Multiple"
   [#let [gen-nat (|> R;nat (:: @ map (|>. (n.% +1000) (n.max +1))))]
    x gen-nat
    y gen-nat]
-  ($_ (assert "GCD"
-              (let [gcd (&;gcd x y)]
-                (and (n.= +0 (n.% gcd x))
-                     (n.= +0 (n.% gcd y))
-                     (n.>= +1 gcd))))
-
-      (assert "LCM"
-              (let [lcm (&;lcm x y)]
-                (and (n.= +0 (n.% x lcm))
-                     (n.= +0 (n.% y lcm))
-                     (n.<= (n.* x y) lcm))))
+  ($_ (test "GCD"
+            (let [gcd (&;gcd x y)]
+              (and (n.= +0 (n.% gcd x))
+                   (n.= +0 (n.% gcd y))
+                   (n.>= +1 gcd))))
+
+      (test "LCM"
+            (let [lcm (&;lcm x y)]
+              (and (n.= +0 (n.% x lcm))
+                   (n.= +0 (n.% y lcm))
+                   (n.<= (n.* x y) lcm))))
       ))
 
-(test: "Infix syntax"
+(context: "Infix syntax"
   [x R;nat
    y R;nat
    z R;nat
    #let [top (|> x (n.max y) (n.max z))
          bottom (|> x (n.min y) (n.min z))]]
   ($_ seq
-      (assert "Constant values don't change."
-              (n.= x (&;infix x)))
+      (test "Constant values don't change."
+            (n.= x (&;infix x)))
 
-      (assert "Can call infix functions."
-              (n.= (&;gcd y x) (&;infix [x &;gcd y])))
+      (test "Can call infix functions."
+            (n.= (&;gcd y x) (&;infix [x &;gcd y])))
 
-      (assert "Can use regular syntax in the middle of infix code."
-              (n.= (&;gcd +450 (n.* +3 +9))
-                   (&;infix [(n.* +3 +9) &;gcd +450])))
+      (test "Can use regular syntax in the middle of infix code."
+            (n.= (&;gcd +450 (n.* +3 +9))
+                 (&;infix [(n.* +3 +9) &;gcd +450])))
 
-      (assert "Can use non-numerical functions/macros as operators."
-              (b/= (and (n.< y x) (n.< z y))
-                   (&;infix [[x n.< y] and [y n.< z]])))
+      (test "Can use non-numerical functions/macros as operators."
+            (b/= (and (n.< y x) (n.< z y))
+                 (&;infix [[x n.< y] and [y n.< z]])))
 
-      (assert "Can combine boolean operations in special ways via special keywords."
-              (and (b/= (and (n.< y x) (n.< z y))
-                        (&;infix [#and x n.< y n.< z]))
-                   (b/= (and (n.< y x) (n.> z y))
-                        (&;infix [#and x n.< y n.> z]))))
+      (test "Can combine boolean operations in special ways via special keywords."
+            (and (b/= (and (n.< y x) (n.< z y))
+                      (&;infix [#and x n.< y n.< z]))
+                 (b/= (and (n.< y x) (n.> z y))
+                      (&;infix [#and x n.< y n.> z]))))
       ))
diff --git a/stdlib/test/test/lux/math/logic/continuous.lux b/stdlib/test/test/lux/math/logic/continuous.lux
index b1770c815..c57060400 100644
--- a/stdlib/test/test/lux/math/logic/continuous.lux
+++ b/stdlib/test/test/lux/math/logic/continuous.lux
@@ -6,26 +6,26 @@
        ["&" math/logic/continuous])
   lux/test)
 
-(test: "Operations"
+(context: "Operations"
   [left R;deg
    right R;deg]
   ($_ seq
-      (assert "AND is the minimum."
-              (let [result (&;~and left right)]
-                (and (d.<= left result)
-                     (d.<= right result))))
+      (test "AND is the minimum."
+            (let [result (&;~and left right)]
+              (and (d.<= left result)
+                   (d.<= right result))))
 
-      (assert "OR is the maximum."
-              (let [result (&;~or left right)]
-                (and (d.>= left result)
-                     (d.>= right result))))
+      (test "OR is the maximum."
+            (let [result (&;~or left right)]
+              (and (d.>= left result)
+                   (d.>= right result))))
 
-      (assert "Double negation results in the original value."
-              (d.= left (&;~not (&;~not left))))
+      (test "Double negation results in the original value."
+            (d.= left (&;~not (&;~not left))))
 
-      (assert "Every value is equivalent to itself."
-              (and (d.>= left
-                         (&;~= left left))
-                   (d.>= right
-                         (&;~= right right))))
+      (test "Every value is equivalent to itself."
+            (and (d.>= left
+                       (&;~= left left))
+                 (d.>= right
+                       (&;~= right right))))
       ))
diff --git a/stdlib/test/test/lux/math/logic/fuzzy.lux b/stdlib/test/test/lux/math/logic/fuzzy.lux
index 73530f35b..bdc283551 100644
--- a/stdlib/test/test/lux/math/logic/fuzzy.lux
+++ b/stdlib/test/test/lux/math/logic/fuzzy.lux
@@ -13,7 +13,7 @@
   lux/test)
 
 (do-template [<desc> <hash> <gen> <triangle> <lt> <lte> <gt> <gte>]
-  [(test: (format "[" <desc> "] " "Triangles")
+  [(context: (format "[" <desc> "] " "Triangles")
      [values (R;set <hash> +3 <gen>)
       #let [[x y z] (case (set;to-list values)
                       (^ (list x y z))
@@ -30,22 +30,22 @@
                                   (undefined))
             triangle (<triangle> x y z)]]
      ($_ seq
-         (assert "The middle value will always have maximum membership."
-                 (d.= ~true (&;membership middle triangle)))
+         (test "The middle value will always have maximum membership."
+               (d.= ~true (&;membership middle triangle)))
          
-         (assert "Boundary values will always have 0 membership."
-                 (and (d.= ~false (&;membership bottom triangle))
-                      (d.= ~false (&;membership top triangle))))
-
-         (assert "Values within range, will have membership > 0."
-                 (B/= (d.> ~false (&;membership sample triangle))
-                      (and (<gt> bottom sample)
-                           (<lt> top sample))))
-
-         (assert "Values outside of range, will have membership = 0."
-                 (B/= (d.= ~false (&;membership sample triangle))
-                      (or (<lte> bottom sample)
-                          (<gte> top sample))))
+         (test "Boundary values will always have 0 membership."
+               (and (d.= ~false (&;membership bottom triangle))
+                    (d.= ~false (&;membership top triangle))))
+
+         (test "Values within range, will have membership > 0."
+               (B/= (d.> ~false (&;membership sample triangle))
+                    (and (<gt> bottom sample)
+                         (<lt> top sample))))
+
+         (test "Values outside of range, will have membership = 0."
+               (B/= (d.= ~false (&;membership sample triangle))
+                    (or (<lte> bottom sample)
+                        (<gte> top sample))))
          ))]
 
   ["Real" number;Hash<Real> R;real &;r.triangle r.< r.<= r.> r.>=]
@@ -53,7 +53,7 @@
   )
 
 (do-template [<desc> <hash> <gen> <trapezoid> <lt> <lte> <gt> <gte>]
-  [(test: (format "[" <desc> "] " "Trapezoids")
+  [(context: (format "[" <desc> "] " "Trapezoids")
      [values (R;set <hash> +4 <gen>)
       #let [[w x y z] (case (set;to-list values)
                         (^ (list w x y z))
@@ -70,40 +70,40 @@
                                                     (undefined))
             trapezoid (<trapezoid> w x y z)]]
      ($_ seq
-         (assert "The middle values will always have maximum membership."
-                 (and (d.= ~true (&;membership middle-bottom trapezoid))
-                      (d.= ~true (&;membership middle-top trapezoid))))
+         (test "The middle values will always have maximum membership."
+               (and (d.= ~true (&;membership middle-bottom trapezoid))
+                    (d.= ~true (&;membership middle-top trapezoid))))
          
-         (assert "Boundary values will always have 0 membership."
-                 (and (d.= ~false (&;membership bottom trapezoid))
-                      (d.= ~false (&;membership top trapezoid))))
-
-         (assert "Values within inner range will have membership = 1"
-                 (B/= (d.= ~true (&;membership sample trapezoid))
-                      (and (<gte> middle-bottom sample)
-                           (<lte> middle-top sample))))
-
-         (assert "Values within range, will have membership > 0."
-                 (B/= (d.> ~false (&;membership sample trapezoid))
-                      (and (<gt> bottom sample)
-                           (<lt> top sample))))
-
-         (assert "Values outside of range, will have membership = 0."
-                 (B/= (d.= ~false (&;membership sample trapezoid))
-                      (or (<lte> bottom sample)
-                          (<gte> top sample))))
+         (test "Boundary values will always have 0 membership."
+               (and (d.= ~false (&;membership bottom trapezoid))
+                    (d.= ~false (&;membership top trapezoid))))
+
+         (test "Values within inner range will have membership = 1"
+               (B/= (d.= ~true (&;membership sample trapezoid))
+                    (and (<gte> middle-bottom sample)
+                         (<lte> middle-top sample))))
+
+         (test "Values within range, will have membership > 0."
+               (B/= (d.> ~false (&;membership sample trapezoid))
+                    (and (<gt> bottom sample)
+                         (<lt> top sample))))
+
+         (test "Values outside of range, will have membership = 0."
+               (B/= (d.= ~false (&;membership sample trapezoid))
+                    (or (<lte> bottom sample)
+                        (<gte> top sample))))
          ))]
 
   ["Real" number;Hash<Real> R;real &;r.trapezoid r.< r.<= r.> r.>=]
   ["Deg"  number;Hash<Deg>  R;deg  &;d.trapezoid d.< d.<= d.> d.>=]
   )
 
-(test: "Gaussian"
+(context: "Gaussian"
   [deviation (|> R;real (R;filter (r.> 0.0)))
    center R;real
    #let [gaussian (&;gaussian deviation center)]]
-  (assert "The center value will always have maximum membership."
-          (d.= ~true (&;membership center gaussian))))
+  (test "The center value will always have maximum membership."
+        (d.= ~true (&;membership center gaussian))))
 
 (def: gen-triangle
   (R;Random (&;Fuzzy Real))
@@ -113,65 +113,65 @@
      z R;real]
     (wrap (&;r.triangle x y z))))
 
-(test: "Combinators"
+(context: "Combinators"
   [left gen-triangle
    right gen-triangle
    sample R;real]
   ($_ seq
-      (assert "Union membership as as high as membership in any of its members."
-              (let [combined (&;union left right)
-                    combined-membership (&;membership sample combined)]
-                (and (d.>= (&;membership sample left)
-                           combined-membership)
-                     (d.>= (&;membership sample right)
-                           combined-membership))))
+      (test "Union membership as as high as membership in any of its members."
+            (let [combined (&;union left right)
+                  combined-membership (&;membership sample combined)]
+              (and (d.>= (&;membership sample left)
+                         combined-membership)
+                   (d.>= (&;membership sample right)
+                         combined-membership))))
       
-      (assert "Intersection membership as as low as membership in any of its members."
-              (let [combined (&;intersection left right)
-                    combined-membership (&;membership sample combined)]
-                (and (d.<= (&;membership sample left)
-                           combined-membership)
-                     (d.<= (&;membership sample right)
-                           combined-membership))))
+      (test "Intersection membership as as low as membership in any of its members."
+            (let [combined (&;intersection left right)
+                  combined-membership (&;membership sample combined)]
+              (and (d.<= (&;membership sample left)
+                         combined-membership)
+                   (d.<= (&;membership sample right)
+                         combined-membership))))
       
-      (assert "Complement membership is the opposite of normal membership."
-              (d.= (&;membership sample left)
-                   (~not (&;membership sample (&;complement left)))))
-
-      (assert "Membership in the difference will never be higher than in the set being subtracted."
-              (B/= (d.> (&;membership sample right)
-                        (&;membership sample left))
-                   (d.< (&;membership sample left)
-                        (&;membership sample (&;difference left right)))))
+      (test "Complement membership is the opposite of normal membership."
+            (d.= (&;membership sample left)
+                 (~not (&;membership sample (&;complement left)))))
+
+      (test "Membership in the difference will never be higher than in the set being subtracted."
+            (B/= (d.> (&;membership sample right)
+                      (&;membership sample left))
+                 (d.< (&;membership sample left)
+                      (&;membership sample (&;difference left right)))))
       ))
 
-(test: "From predicates and sets"
+(context: "From predicates and sets"
   [#let [set-10 (set;from-list number;Hash<Nat> (list;n.range +0 +10))]
    sample (|> R;nat (:: @ map (n.% +20)))]
   ($_ seq
-      (assert "Values that satisfy a predicate have membership = 1.
+      (test "Values that satisfy a predicate have membership = 1.
                Values that don't have membership = 0."
-              (B/= (d.= ~true (&;membership sample (&;from-predicate n.even?)))
-                   (n.even? sample)))
+            (B/= (d.= ~true (&;membership sample (&;from-predicate n.even?)))
+                 (n.even? sample)))
 
-      (assert "Values that belong to a set have membership = 1.
+      (test "Values that belong to a set have membership = 1.
                Values that don't have membership = 0."
-              (B/= (d.= ~true (&;membership sample (&;from-set set-10)))
-                   (set;member? set-10 sample)))
+            (B/= (d.= ~true (&;membership sample (&;from-set set-10)))
+                 (set;member? set-10 sample)))
       ))
 
-(test: "Thresholds"
+(context: "Thresholds"
   [fuzzy gen-triangle
    sample R;real
    threshold R;deg
    #let [vip-fuzzy (&;cut threshold fuzzy)
          member? (&;to-predicate threshold fuzzy)]]
   ($_ seq
-      (assert "Can increase the threshold of membership of a fuzzy set."
-              (B/= (d.> ~false (&;membership sample vip-fuzzy))
-                   (d.> threshold (&;membership sample fuzzy))))
+      (test "Can increase the threshold of membership of a fuzzy set."
+            (B/= (d.> ~false (&;membership sample vip-fuzzy))
+                 (d.> threshold (&;membership sample fuzzy))))
 
-      (assert "Can turn fuzzy sets into predicates through a threshold."
-              (B/= (member? sample)
-                   (d.> threshold (&;membership sample fuzzy))))
+      (test "Can turn fuzzy sets into predicates through a threshold."
+            (B/= (member? sample)
+                 (d.> threshold (&;membership sample fuzzy))))
       ))
diff --git a/stdlib/test/test/lux/math/simple.lux b/stdlib/test/test/lux/math/simple.lux
index 67d8bf8d0..1b35c4069 100644
--- a/stdlib/test/test/lux/math/simple.lux
+++ b/stdlib/test/test/lux/math/simple.lux
@@ -13,20 +13,20 @@
   lux/test)
 
 (do-template [<category> <generator> <=> <+> <-> <*> </> <%> <0>]
-  [(test: (format <category> " arihtmetic")
+  [(context: (format <category> " arihtmetic")
      [x <generator>
       y (|> <generator> (R;filter (. not (<=> <0>))))]
      ($_ seq
-         (assert "Can add."
-                 (<=> (<+> y x) (&;+ y x)))
-         (assert "Can subtract."
-                 (<=> (<-> y x) (&;- y x)))
-         (assert "Can multiply."
-                 (<=> (<*> y x) (&;* y x)))
-         (assert "Can divide."
-                 (<=> (</> y x) (&;/ y x)))
-         (assert "Can get remainder."
-                 (<=> (<%> y x) (&;% y x)))
+         (test "Can add."
+               (<=> (<+> y x) (&;+ y x)))
+         (test "Can subtract."
+               (<=> (<-> y x) (&;- y x)))
+         (test "Can multiply."
+               (<=> (<*> y x) (&;* y x)))
+         (test "Can divide."
+               (<=> (</> y x) (&;/ y x)))
+         (test "Can get remainder."
+               (<=> (<%> y x) (&;% y x)))
          ))]
 
   ["Nat"  R;nat  n.= n.+ n.- n.* n./ n.% +0]
@@ -36,18 +36,18 @@
   )
 
 (do-template [<category> <generator> <lt> <lte> <gt> <gte>]
-  [(test: (format <category> " comparisons")
+  [(context: (format <category> " comparisons")
      [x <generator>
       y <generator>]
      ($_ seq
-         (assert "<"
-                 (b/= (<lt> y x) (&;< y x)))
-         (assert "<="
-                 (b/= (<lte> y x) (&;<= y x)))
-         (assert ">"
-                 (b/= (<gt> y x) (&;> y x)))
-         (assert ">="
-                 (b/= (<gte> y x) (&;>= y x)))
+         (test "<"
+               (b/= (<lt> y x) (&;< y x)))
+         (test "<="
+               (b/= (<lte> y x) (&;<= y x)))
+         (test ">"
+               (b/= (<gt> y x) (&;> y x)))
+         (test ">="
+               (b/= (<gte> y x) (&;>= y x)))
          ))]
 
   ["Nat"  R;nat  n.< n.<= n.> n.>=]
@@ -57,14 +57,14 @@
   )
 
 (do-template [<category> <generator> <=> <min> <max>]
-  [(test: (format <category> " min & max")
+  [(context: (format <category> " min & max")
      [x <generator>
       y <generator>]
      ($_ seq
-         (assert "Min."
-                 (<=> (<min> y x) (&;min y x)))
-         (assert "Max."
-                 (<=> (<max> y x) (&;max y x)))
+         (test "Min."
+               (<=> (<min> y x) (&;min y x)))
+         (test "Max."
+               (<=> (<max> y x) (&;max y x)))
          ))]
 
   ["Nat" R;nat n.= n.min n.max]
@@ -72,13 +72,13 @@
   )
 
 (do-template [<category> <generator> <=> <inc> <dec>]
-  [(test: (format <category> " inc & dec")
+  [(context: (format <category> " inc & dec")
      [x <generator>]
      ($_ seq
-         (assert "Inc."
-                 (<=> (<inc> x) (&;inc x)))
-         (assert "Dec."
-                 (<=> (<dec> x) (&;dec x)))
+         (test "Inc."
+               (<=> (<inc> x) (&;inc x)))
+         (test "Dec."
+               (<=> (<dec> x) (&;dec x)))
          ))]
 
   ["Nat" R;nat n.= n.inc n.dec]
@@ -86,13 +86,13 @@
   )
 
 (do-template [<category> <generator> <even?> <odd?>]
-  [(test: (format <category> " even & odd")
+  [(context: (format <category> " even & odd")
      [x <generator>]
      ($_ seq
-         (assert "Even."
-                 (b/= (<even?> x) (&;even? x)))
-         (assert "Odd."
-                 (b/= (<odd?> x) (&;odd? x)))
+         (test "Even."
+               (b/= (<even?> x) (&;even? x)))
+         (test "Odd."
+               (b/= (<odd?> x) (&;odd? x)))
          ))]
 
   ["Nat"  R;nat n.even? n.odd?]
diff --git a/stdlib/test/test/lux/type.lux b/stdlib/test/test/lux/type.lux
index 543484bb8..8adc9384e 100644
--- a/stdlib/test/test/lux/type.lux
+++ b/stdlib/test/test/lux/type.lux
@@ -44,41 +44,41 @@
                  )))))
 
 ## [Tests]
-(test: "Types"
+(context: "Types"
   [sample gen-type]
-  (assert "Every type is equal to itself."
-          (:: &;Eq<Type> = sample sample)))
-
-(test: "Type application"
-  (assert "Can apply quantified types (universal and existential quantification)."
-          (and (default false
-                 (do Monad<Maybe>
-                   [partial (&;apply-type Meta Bool)
-                    full (&;apply-type partial Int)]
-                   (wrap (:: &;Eq<Type> = full (#;Product Bool Int)))))
-               (|> (&;apply-type Text Bool)
-                   (case> #;None true _ false)))))
-
-(test: "Naming"
+  (test "Every type is equal to itself."
+        (:: &;Eq<Type> = sample sample)))
+
+(context: "Type application"
+  (test "Can apply quantified types (universal and existential quantification)."
+        (and (default false
+               (do Monad<Maybe>
+                 [partial (&;apply-type Meta Bool)
+                  full (&;apply-type partial Int)]
+                 (wrap (:: &;Eq<Type> = full (#;Product Bool Int)))))
+             (|> (&;apply-type Text Bool)
+                 (case> #;None true _ false)))))
+
+(context: "Naming"
   (let [base (#;Named ["" "a"] (#;Product Bool Int))
         aliased (#;Named ["" "c"]
                          (#;Named ["" "b"]
                                   base))]
     ($_ seq
-        (assert "Can remove aliases from an already-named type."
-                (:: &;Eq<Type> =
-                    base
-                    (&;un-alias aliased)))
-
-        (assert "Can remove all names from a type."
-                (and (not (:: &;Eq<Type> =
-                              base
-                              (&;un-name aliased)))
-                     (:: &;Eq<Type> =
-                         (&;un-name base)
-                         (&;un-name aliased)))))))
-
-(test: "Type construction [structs]"
+        (test "Can remove aliases from an already-named type."
+              (:: &;Eq<Type> =
+                  base
+                  (&;un-alias aliased)))
+
+        (test "Can remove all names from a type."
+              (and (not (:: &;Eq<Type> =
+                            base
+                            (&;un-name aliased)))
+                   (:: &;Eq<Type> =
+                       (&;un-name base)
+                       (&;un-name aliased)))))))
+
+(context: "Type construction [structs]"
   [size (|> R;nat (:: @ map (n.% +3)))
    members (|> gen-type
                (R;filter (function [type]
@@ -94,11 +94,11 @@
          (^open "L/") (list;Eq<List> &;Eq<Type>)]]
   (with-expansions
     [<struct-tests> (do-template [<desc> <ctor> <dtor> <unit>]
-                      [(assert (format "Can build and tear-down " <desc> " types.")
-                               (let [flat (|> members <ctor> <dtor>)]
-                                 (or (L/= members flat)
-                                     (and (L/= (list) members)
-                                          (L/= (list <unit>) flat)))))]
+                      [(test (format "Can build and tear-down " <desc> " types.")
+                             (let [flat (|> members <ctor> <dtor>)]
+                               (or (L/= members flat)
+                                   (and (L/= (list) members)
+                                        (L/= (list <unit>) flat)))))]
 
                       ["variant" &;variant &;flatten-variant Void]
                       ["tuple"   &;tuple   &;flatten-tuple   Unit]
@@ -107,7 +107,7 @@
         <struct-tests>
         )))
 
-(test: "Type construction [parameterized]"
+(context: "Type construction [parameterized]"
   [size (|> R;nat (:: @ map (n.% +3)))
    members (seqM @ (list;repeat size gen-type))
    extra (|> gen-type
@@ -121,17 +121,17 @@
    #let [(^open "&/") &;Eq<Type>
          (^open "L/") (list;Eq<List> &;Eq<Type>)]]
   ($_ seq
-      (assert "Can build and tear-down function types."
-              (let [[inputs output] (|> (&;function members extra) &;flatten-function)]
-                (and (L/= members inputs)
-                     (&/= extra output))))
-
-      (assert "Can build and tear-down application types."
-              (let [[tfunc tparams] (|> members (&;application extra) &;flatten-application)]
-                (n.= (list;size members) (list;size tparams))))
+      (test "Can build and tear-down function types."
+            (let [[inputs output] (|> (&;function members extra) &;flatten-function)]
+              (and (L/= members inputs)
+                   (&/= extra output))))
+
+      (test "Can build and tear-down application types."
+            (let [[tfunc tparams] (|> members (&;application extra) &;flatten-application)]
+              (n.= (list;size members) (list;size tparams))))
       ))
 
-(test: "Type construction [higher order]"
+(context: "Type construction [higher order]"
   [size (|> R;nat (:: @ map (n.% +3)))
    extra (|> gen-type
              (R;filter (function [type]
@@ -144,10 +144,10 @@
    #let [(^open "&/") &;Eq<Type>]]
   (with-expansions
     [<quant-tests> (do-template [<desc> <ctor> <dtor>]
-                     [(assert (format "Can build and tear-down " <desc> " types.")
-                              (let [[flat-size flat-body] (|> extra (<ctor> size) <dtor>)]
-                                (and (n.= size flat-size)
-                                     (&/= extra flat-body))))]
+                     [(test (format "Can build and tear-down " <desc> " types.")
+                            (let [[flat-size flat-body] (|> extra (<ctor> size) <dtor>)]
+                              (and (n.= size flat-size)
+                                   (&/= extra flat-body))))]
 
                      ["universally-quantified"   &;univ-q &;flatten-univ-q]
                      ["existentially-quantified" &;ex-q   &;flatten-ex-q]
diff --git a/stdlib/test/test/lux/type/auto.lux b/stdlib/test/test/lux/type/auto.lux
index c7e321240..95185671c 100644
--- a/stdlib/test/test/lux/type/auto.lux
+++ b/stdlib/test/test/lux/type/auto.lux
@@ -15,25 +15,25 @@
        type/auto)
   lux/test)
 
-(test: "Automatic structure selection"
+(context: "Automatic structure selection"
   [x R;nat
    y R;nat]
   ($_ seq
-      (assert "Can automatically select first-order structures."
-              (let [(^open "L/") (list;Eq<List> number;Eq<Nat>)]
-                (and (B/= (:: number;Eq<Nat> = x y)
-                          (::: = x y))
-                     (L/= (list;n.range +1 +10)
-                          (::: map n.inc (list;n.range +0 +9)))
-                     )))
+      (test "Can automatically select first-order structures."
+            (let [(^open "L/") (list;Eq<List> number;Eq<Nat>)]
+              (and (B/= (:: number;Eq<Nat> = x y)
+                        (::: = x y))
+                   (L/= (list;n.range +1 +10)
+                        (::: map n.inc (list;n.range +0 +9)))
+                   )))
       
-      (assert "Can automatically select second-order structures."
-              (::: =
-                   (list;n.range +1 +10)
-                   (list;n.range +1 +10)))
+      (test "Can automatically select second-order structures."
+            (::: =
+                 (list;n.range +1 +10)
+                 (list;n.range +1 +10)))
 
-      (assert "Can automatically select third-order structures."
-              (let [lln (::: map (list;n.range +1)
-                             (list;n.range +1 +10))]
-                (::: = lln lln)))
+      (test "Can automatically select third-order structures."
+            (let [lln (::: map (list;n.range +1)
+                           (list;n.range +1 +10))]
+              (::: = lln lln)))
       ))
diff --git a/stdlib/test/test/lux/type/check.lux b/stdlib/test/test/lux/type/check.lux
index 8cc8c88d7..1c4767a15 100644
--- a/stdlib/test/test/lux/type/check.lux
+++ b/stdlib/test/test/lux/type/check.lux
@@ -73,104 +73,104 @@
     false))
 
 ## [Tests]
-(test: "Top and Bottom"
+(context: "Top and Bottom"
   [sample (|> gen-type (R;filter valid-type?))]
   ($_ seq
-      (assert "Top is the super-type of everything."
-              (&;checks? Top sample))
+      (test "Top is the super-type of everything."
+            (&;checks? Top sample))
 
-      (assert "Bottom is the sub-type of everything."
-              (&;checks? sample Bottom))
+      (test "Bottom is the sub-type of everything."
+            (&;checks? sample Bottom))
       ))
 
-(test: "Simple type-checking."
+(context: "Simple type-checking."
   ($_ seq
-      (assert "Unit and Void match themselves."
-              (and (&;checks? Void Void)
-                   (&;checks? Unit Unit)))
-
-      (assert "Existential types only match with themselves."
-              (and (type-checks? (do &;Monad<Check>
-                                   [[id ex] &;existential]
-                                   (&;check ex ex)))
-                   (not (type-checks? (do &;Monad<Check>
-                                        [[lid lex] &;existential
-                                         [rid rex] &;existential]
-                                        (&;check lex rex))))))
-
-      (assert "Names don't affect type-checking."
-              (and (type-checks? (do &;Monad<Check>
-                                   [[id ex] &;existential]
-                                   (&;check (#;Named ["module" "name"] ex)
-                                            ex)))
-                   (type-checks? (do &;Monad<Check>
-                                   [[id ex] &;existential]
-                                   (&;check ex
-                                            (#;Named ["module" "name"] ex))))
-                   (type-checks? (do &;Monad<Check>
-                                   [[id ex] &;existential]
-                                   (&;check (#;Named ["module" "name"] ex)
-                                            (#;Named ["module" "name"] ex))))))
-
-      (assert "Can type-check functions."
-              (and (&;checks? (#;Function Bottom Top)
-                              (#;Function Top Bottom))
-                   (not (&;checks? (#;Function Top Bottom)
-                                   (#;Function Bottom Top)))))
+      (test "Unit and Void match themselves."
+            (and (&;checks? Void Void)
+                 (&;checks? Unit Unit)))
+
+      (test "Existential types only match with themselves."
+            (and (type-checks? (do &;Monad<Check>
+                                 [[id ex] &;existential]
+                                 (&;check ex ex)))
+                 (not (type-checks? (do &;Monad<Check>
+                                      [[lid lex] &;existential
+                                       [rid rex] &;existential]
+                                      (&;check lex rex))))))
+
+      (test "Names don't affect type-checking."
+            (and (type-checks? (do &;Monad<Check>
+                                 [[id ex] &;existential]
+                                 (&;check (#;Named ["module" "name"] ex)
+                                          ex)))
+                 (type-checks? (do &;Monad<Check>
+                                 [[id ex] &;existential]
+                                 (&;check ex
+                                          (#;Named ["module" "name"] ex))))
+                 (type-checks? (do &;Monad<Check>
+                                 [[id ex] &;existential]
+                                 (&;check (#;Named ["module" "name"] ex)
+                                          (#;Named ["module" "name"] ex))))))
+
+      (test "Can type-check functions."
+            (and (&;checks? (#;Function Bottom Top)
+                            (#;Function Top Bottom))
+                 (not (&;checks? (#;Function Top Bottom)
+                                 (#;Function Bottom Top)))))
       ))
 
-(test: "Type application"
+(context: "Type application"
   [meta gen-type
    data gen-type]
-  (assert "Can type-check type application."
-          (and (&;checks? (#;App (#;App Meta meta) data)
-                          (type;tuple (list meta data)))
-               (&;checks? (type;tuple (list meta data))
-                          (#;App (#;App Meta meta) data)))))
+  (test "Can type-check type application."
+        (and (&;checks? (#;App (#;App Meta meta) data)
+                        (type;tuple (list meta data)))
+             (&;checks? (type;tuple (list meta data))
+                        (#;App (#;App Meta meta) data)))))
 
-(test: "Host types"
+(context: "Host types"
   [nameL gen-name
    nameR (|> gen-name (R;filter (. not (Text/= nameL))))
    paramL gen-type
    paramR (|> gen-type (R;filter (|>. (&;checks? paramL) not)))]
   ($_ seq
-      (assert "Host types match when they have the same name and the same parameters."
-              (&;checks? (#;Host nameL (list paramL))
-                         (#;Host nameL (list paramL))))
+      (test "Host types match when they have the same name and the same parameters."
+            (&;checks? (#;Host nameL (list paramL))
+                       (#;Host nameL (list paramL))))
 
-      (assert "Names matter to host types."
-              (not (&;checks? (#;Host nameL (list paramL))
-                              (#;Host nameR (list paramL)))))
+      (test "Names matter to host types."
+            (not (&;checks? (#;Host nameL (list paramL))
+                            (#;Host nameR (list paramL)))))
 
-      (assert "Parameters matter to host types."
-              (not (&;checks? (#;Host nameL (list paramL))
-                              (#;Host nameL (list paramR)))))
+      (test "Parameters matter to host types."
+            (not (&;checks? (#;Host nameL (list paramL))
+                            (#;Host nameL (list paramR)))))
       ))
 
-(test: "Type-vars"
+(context: "Type-vars"
   ($_ seq
-      (assert "Type-vars check against themselves."
-              (type-checks? (&;with-var (function [[id var]] (&;check var var)))))
-
-      (assert "Can bind unbound type-vars by type-checking against them."
-              (and (type-checks? (&;with-var (function [[id var]] (&;check var #;Unit))))
-                   (type-checks? (&;with-var (function [[id var]] (&;check #;Unit var))))))
-
-      (assert "Can't rebind already bound type-vars."
-              (not (type-checks? (&;with-var (function [[id var]]
-                                               (do &;Monad<Check>
-                                                 [_ (&;check var #;Unit)]
-                                                 (&;check var #;Void)))))))
-
-      (assert "If the type bound to a var is a super-type to another, then the var is also a super-type."
-              (type-checks? (&;with-var (function [[id var]]
-                                          (do &;Monad<Check>
-                                            [_ (&;check var Top)]
-                                            (&;check var #;Unit))))))
-
-      (assert "If the type bound to a var is a sub-type of another, then the var is also a sub-type."
-              (type-checks? (&;with-var (function [[id var]]
-                                          (do &;Monad<Check>
-                                            [_ (&;check var Bottom)]
-                                            (&;check #;Unit var))))))
+      (test "Type-vars check against themselves."
+            (type-checks? (&;with-var (function [[id var]] (&;check var var)))))
+
+      (test "Can bind unbound type-vars by type-checking against them."
+            (and (type-checks? (&;with-var (function [[id var]] (&;check var #;Unit))))
+                 (type-checks? (&;with-var (function [[id var]] (&;check #;Unit var))))))
+
+      (test "Can't rebind already bound type-vars."
+            (not (type-checks? (&;with-var (function [[id var]]
+                                             (do &;Monad<Check>
+                                               [_ (&;check var #;Unit)]
+                                               (&;check var #;Void)))))))
+
+      (test "If the type bound to a var is a super-type to another, then the var is also a super-type."
+            (type-checks? (&;with-var (function [[id var]]
+                                        (do &;Monad<Check>
+                                          [_ (&;check var Top)]
+                                          (&;check var #;Unit))))))
+
+      (test "If the type bound to a var is a sub-type of another, then the var is also a sub-type."
+            (type-checks? (&;with-var (function [[id var]]
+                                        (do &;Monad<Check>
+                                          [_ (&;check var Bottom)]
+                                          (&;check #;Unit var))))))
       ))