- Lux no longer has a Char primitive data-type.

16 files changed, 100 insertions, 164 deletions

diff --git a/stdlib/test/test/lux/control/parser.lux b/stdlib/test/test/lux/control/parser.lux
index 5c4f5851c..4580dca1e 100644
--- a/stdlib/test/test/lux/control/parser.lux
+++ b/stdlib/test/test/lux/control/parser.lux
@@ -9,7 +9,6 @@
              text/format
              [number]
              [bool]
-             [char]
              [ident]
              ["R" result])
        ["r" math/random]
diff --git a/stdlib/test/test/lux/data/char.lux b/stdlib/test/test/lux/data/char.lux
deleted file mode 100644
index e0f790905..000000000
--- a/stdlib/test/test/lux/data/char.lux
+++ /dev/null
@@ -1,48 +0,0 @@
-(;module:
-  lux
-  (lux (control [monad]
-                pipe)
-       [io]
-       (data char
-             [text]
-             text/format)
-       ["R" math/random])
-  lux/test)
-
-(context: "Char operations"
-  [value R;char
-   other R;char]
-  ($_ seq
-      (test "Can compare characterss for equality."
-            (:: Eq<Char> = value value))
-
-      (test "Can go back-and-forth into numeric codes."
-            (|> value code char (:: Eq<Char> = 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))))
-
-      (test "Characters have an ordering relationship."
-            (if (:: Order<Char> < other value)
-              (:: Order<Char> > value other)
-              (:: Order<Char> >= other value)))
-      ))
-
-(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/dict.lux b/stdlib/test/test/lux/data/coll/dict.lux
index 0153e8049..7d90e428d 100644
--- a/stdlib/test/test/lux/data/coll/dict.lux
+++ b/stdlib/test/test/lux/data/coll/dict.lux
@@ -6,7 +6,6 @@
        (data [text "Text/" Monoid<Text>]
              text/format
              [number]
-             [char]
              (coll ["&" dict]
                    [list "List/" Fold<List> Functor<List>]))
        ["R" math/random])
@@ -15,11 +14,9 @@
 (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)
-   non-key (|> R;char
-               (R;filter (function [key] (not (&;contains? key dict)))))
-   test-val (|> R;nat
-                (R;filter (function [val] (not (list;member? number;Eq<Nat> (&;values dict) val)))))]
+   dict (R;dict number;Hash<Nat> size R;nat capped-nat)
+   non-key (|> R;nat (R;filter (function [key] (not (&;contains? key dict)))))
+   test-val (|> R;nat (R;filter (function [val] (not (list;member? number;Eq<Nat> (&;values dict) val)))))]
   ($_ seq
       (test "Size function should correctly represent Dict size."
             (n.= size (&;size dict)))
@@ -30,7 +27,7 @@
               (not (&;empty? dict))))
       
       (test "The functions 'entries', 'keys' and 'values' should be synchronized."
-            (:: (list;Eq<List> (eq;conj char;Eq<Char> number;Eq<Nat>)) =
+            (:: (list;Eq<List> (eq;conj number;Eq<Nat> number;Eq<Nat>)) =
                 (&;entries dict)
                 (list;zip2 (&;keys dict)
                            (&;values dict))))
@@ -91,7 +88,7 @@
       (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)))))
+                   (|> dict &;entries (&;from-list number;Hash<Nat>) (= dict)))))
 
       (test "Merging a Dict to itself changes nothing."
             (let [(^open) (&;Eq<Dict> number;Eq<Nat>)]
@@ -100,7 +97,7 @@
       (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>))
+                            (&;from-list number;Hash<Nat>))
                   (^open) (&;Eq<Dict> number;Eq<Nat>)]
               (= dict' (&;merge dict' dict))))
 
diff --git a/stdlib/test/test/lux/data/format/json.lux b/stdlib/test/test/lux/data/format/json.lux
index e133ef87d..c61429b87 100644
--- a/stdlib/test/test/lux/data/format/json.lux
+++ b/stdlib/test/test/lux/data/format/json.lux
@@ -9,7 +9,6 @@
              text/format
              [result]
              [bool]
-             [char]
              [maybe]
              [number "i/" Number<Int>]
              (format ["&" json])
@@ -65,12 +64,11 @@
    #bool Bool
    #int Int
    #real Real
-   #char Char
    #text Text
    #maybe (Maybe Int)
    #list (List Int)
    #variant Variant
-   #tuple [Int Real Char]
+   #tuple [Int Real Text]
    #dict (d;Dict Text Int)})
 
 (def: gen-record
@@ -83,12 +81,11 @@
         r;bool
         gen-int
         r;real
-        r;char
         (r;text size)
         (r;maybe gen-int)
         (r;list size gen-int)
         ($_ r;alt r;bool gen-int r;real)
-        ($_ r;seq gen-int r;real r;char)
+        ($_ r;seq gen-int r;real (r;text size))
         (r;dict text;Hash<Text> size (r;text size) gen-int)
         )))
 
@@ -112,7 +109,6 @@
       (and (:: bool;Eq<Bool> = (get@ #bool recL) (get@ #bool recR))
            (i.= (get@ #int recL) (get@ #int recR))
            (r.= (get@ #real recL) (get@ #real recR))
-           (:: char;Eq<Char> = (get@ #char recL) (get@ #char recR))
            (:: text;Eq<Text> = (get@ #text recL) (get@ #text recR))
            (:: (maybe;Eq<Maybe> number;Eq<Int>) = (get@ #maybe recL) (get@ #maybe recR))
            (:: (list;Eq<List> number;Eq<Int>) = (get@ #list recL) (get@ #list recR))
@@ -121,7 +117,7 @@
                  [tR0 tR1 tR2] (get@ #tuple recR)]
              (and (i.= tL0 tR0)
                   (r.= tL1 tR1)
-                  (:: char;Eq<Char> = tL2 tR2)))
+                  (:: text;Eq<Text> = tL2 tR2)))
            (:: (d;Eq<Dict> i.=) = (get@ #dict recL) (get@ #dict recR))
            ))))
 
diff --git a/stdlib/test/test/lux/data/format/xml.lux b/stdlib/test/test/lux/data/format/xml.lux
index 414f19941..25002112a 100644
--- a/stdlib/test/test/lux/data/format/xml.lux
+++ b/stdlib/test/test/lux/data/format/xml.lux
@@ -3,50 +3,54 @@
   (lux [io]
        (control monad
                 pipe)
-       (data [char]
-             [text "Text/" Monoid<Text>]
+       (data [text "Text/" Monoid<Text>]
              text/format
              [ident]
              (format ["&" xml])
              (coll [dict]
                    [list]))
-       ["R" math/random "R/" Monad<Random>]
+       ["r" math/random "r/" Monad<Random>]
        test)
   )
 
-(def: (valid-xml-char? char)
-  (text;contains? (char;as-text char)
-                  (format "_"
-                          "abcdefghijklmnopqrstuvwxyz"
-                          "ABCDEFGHIJKLMNOPQRSTUVWXYZ")))
+(def: char-range
+  Text
+  (format "_"
+          "abcdefghijklmnopqrstuvwxyz"
+          "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
+
+(def: xml-char^
+  (r;Random Nat)
+  (do r;Monad<Random>
+    [idx (|> r;nat (:: @ map (n.% (text;size char-range))))]
+    (wrap (assume (text;nth idx char-range)))))
 
 (def: (size^ bottom top)
-  (-> Nat Nat (R;Random Nat))
+  (-> Nat Nat (r;Random Nat))
   (let [constraint (|>. (n.% top) (n.max bottom))]
-    (R/map constraint R;nat)))
+    (r/map constraint r;nat)))
 
 (def: (xml-text^ bottom top)
-  (-> Nat Nat (R;Random Text))
-  (do R;Monad<Random>
+  (-> Nat Nat (r;Random Text))
+  (do r;Monad<Random>
     [size (size^ bottom top)]
-    (R;text' (R;filter valid-xml-char? R;char)
-             size)))
+    (r;text' xml-char^ size)))
 
 (def: xml-identifier^
-  (R;Random Ident)
-  (R;seq (xml-text^ +0 +10)
+  (r;Random Ident)
+  (r;seq (xml-text^ +0 +10)
          (xml-text^ +1 +10)))
 
 (def: gen-xml
-  (R;Random &;XML)
-  (R;rec (function [gen-xml]
-           (R;alt (xml-text^ +1 +10)
-                  (do R;Monad<Random>
+  (r;Random &;XML)
+  (r;rec (function [gen-xml]
+           (r;alt (xml-text^ +1 +10)
+                  (do r;Monad<Random>
                     [size (size^ +0 +2)]
-                    ($_ R;seq
+                    ($_ r;seq
                         xml-identifier^
-                        (R;dict ident;Hash<Ident> size xml-identifier^ (xml-text^ +0 +10))
-                        (R;list size gen-xml)))))))
+                        (r;dict ident;Hash<Ident> size xml-identifier^ (xml-text^ +0 +10))
+                        (r;list size gen-xml)))))))
 
 (context: "XML"
   [sample gen-xml
diff --git a/stdlib/test/test/lux/data/text.lux b/stdlib/test/test/lux/data/text.lux
index bf509ff53..7005fdaf4 100644
--- a/stdlib/test/test/lux/data/text.lux
+++ b/stdlib/test/test/lux/data/text.lux
@@ -4,37 +4,36 @@
        (control monad
                 pipe)
        (data ["&" text]
-             [char]
              text/format
              [number]
              (coll [list]))
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (context: "Size"
-  [size (:: @ map (n.% +100) R;nat)
-   sample (R;text size)]
+  [size (:: @ map (n.% +100) r;nat)
+   sample (r;text size)]
   (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)))))
+  (r;Random Nat)
+  (|> r;nat
+      (:: r;Monad<Random> map (|>. (n.% +20) (n.+ +1)))))
 
 (context: "Locations"
   [size bounded-size
-   idx (:: @ map (n.% size) R;nat)
-   sample (R;text size)]
+   idx (:: @ map (n.% size) r;nat)
+   sample (r;text size)]
   (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)]
+                              [(&;from-code 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)
@@ -43,7 +42,7 @@
                            (n.= idx io')
                            (n.>= idx lio')
 
-                           (&;contains? char' sample))
+                           (&;contains? char sample))
 
                       _
                       false
@@ -53,8 +52,8 @@
 (context: "Text functions"
   [sizeL bounded-size
    sizeR bounded-size
-   sampleL (R;text sizeL)
-   sampleR (R;text sizeR)
+   sampleL (r;text sizeL)
+   sampleR (r;text sizeR)
    #let [sample (&;concat (list sampleL sampleR))
          fake-sample (&;join-with " " (list sampleL sampleR))
          dup-sample (&;join-with "" (list sampleL sampleR))
@@ -97,12 +96,12 @@
    #let [## The wider unicode charset includes control characters that
          ## can make text replacement work improperly.
          ## Because of that, I restrict the charset.
-         normal-char-gen (|> R;char (:: @ map (|>. char;code (n.% +128) (n.max +1) char;char)))]
-   sep1 (R;text' normal-char-gen +1)
-   sep2 (R;text' normal-char-gen +1)
-   #let [part-gen (|> (R;text' normal-char-gen sizeP)
-                      (R;filter (. not (&;contains? sep1))))]
-   parts (R;list sizeL part-gen)
+         normal-char-gen (|> r;nat (:: @ map (|>. (n.% +128) (n.max +1))))]
+   sep1 (r;text' normal-char-gen +1)
+   sep2 (r;text' normal-char-gen +1)
+   #let [part-gen (|> (r;text' normal-char-gen sizeP)
+                      (r;filter (. not (&;contains? sep1))))]
+   parts (r;list sizeL part-gen)
    #let [sample1 (&;concat (list;interpose sep1 parts))
          sample2 (&;concat (list;interpose sep2 parts))
          (^open "&/") &;Eq<Text>]]
diff --git a/stdlib/test/test/lux/data/text/format.lux b/stdlib/test/test/lux/data/text/format.lux
index afd788fa0..b852c6e56 100644
--- a/stdlib/test/test/lux/data/text/format.lux
+++ b/stdlib/test/test/lux/data/text/format.lux
@@ -14,7 +14,6 @@
               (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 8752d4b96..3f9621d9c 100644
--- a/stdlib/test/test/lux/data/text/lexer.lux
+++ b/stdlib/test/test/lux/data/text/lexer.lux
@@ -94,9 +94,9 @@
 
       (test "Can lex characters ranges."
             (and (should-passT "Y" (&;run "Y"
-                                          (&;range #"X" #"Z")))
+                                          (&;range (char "X") (char "Z"))))
                  (should-fail (&;run "M"
-                                     (&;range #"X" #"Z")))))
+                                     (&;range (char "X") (char "Z"))))))
       
       (test "Can lex upper-case and &;lower-case letters."
             (and (should-passT "Y" (&;run "Y"
diff --git a/stdlib/test/test/lux/data/text/regex.lux b/stdlib/test/test/lux/data/text/regex.lux
index ce18c0539..b819b99bb 100644
--- a/stdlib/test/test/lux/data/text/regex.lux
+++ b/stdlib/test/test/lux/data/text/regex.lux
@@ -12,7 +12,7 @@
        [macro]
        (macro [code]
               ["s" syntax #+ syntax:])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 ## [Utils]
@@ -267,9 +267,9 @@
       ))
 
 (context: "Pattern-matching"
-  [sample1 (R;text +3)
-   sample2 (R;text +3)
-   sample3 (R;text +4)]
+  [sample1 (r;text +3)
+   sample2 (r;text +3)
+   sample3 (r;text +4)]
   (case (format sample1 "-" sample2 "-" sample3)
     (&;^regex "(.{3})-(.{3})-(.{4})"
               [_ match1 match2 match3])
diff --git a/stdlib/test/test/lux/host.jvm.lux b/stdlib/test/test/lux/host.jvm.lux
index a90db336c..191d0f463 100644
--- a/stdlib/test/test/lux/host.jvm.lux
+++ b/stdlib/test/test/lux/host.jvm.lux
@@ -8,7 +8,7 @@
              [product]
              [text "Text/" Eq<Text>])
        ["&" host #+ jvm-import class: interface: object]
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (jvm-import java.lang.Exception
@@ -53,7 +53,7 @@
   ([] foo [boolean String] void #throws [Exception]))
 
 (context: "Conversions"
-  [sample R;int]
+  [sample r;int]
   (with-expansions
     [<int-convs> (do-template [<to> <from> <message>]
                    [(test <message>
@@ -100,9 +100,9 @@
       ))
 
 (context: "Arrays"
-  [size (|> R;nat (:: @ map (|>. (n.% +100) (n.max +1))))
-   idx (|> R;nat (:: @ map (n.% size)))
-   value R;int]
+  [size (|> r;nat (:: @ map (|>. (n.% +100) (n.max +1))))
+   idx (|> r;nat (:: @ map (n.% size)))
+   value r;int]
   ($_ seq
       (test "Can create arrays of some length."
             (n.= size (&;array-length (&;array Long size))))
diff --git a/stdlib/test/test/lux/macro/code.lux b/stdlib/test/test/lux/macro/code.lux
index fd1d7415e..5e5d71d44 100644
--- a/stdlib/test/test/lux/macro/code.lux
+++ b/stdlib/test/test/lux/macro/code.lux
@@ -20,7 +20,6 @@
                [(&;bool false)                                "false"]
                [(&;int 123)                                   "123"]
                [(&;real 123.0)                                "123.0"]
-               [(&;char #"\n")                                "#\"\\n\""]
                [(&;text "\n")                                 "\"\\n\""]
                [(&;tag ["yolo" "lol"])                        "#yolo;lol"]
                [(&;symbol ["yolo" "lol"])                     "yolo;lol"]
diff --git a/stdlib/test/test/lux/macro/poly/eq.lux b/stdlib/test/test/lux/macro/poly/eq.lux
index 512a7633b..e3c059ddd 100644
--- a/stdlib/test/test/lux/macro/poly/eq.lux
+++ b/stdlib/test/test/lux/macro/poly/eq.lux
@@ -6,9 +6,8 @@
        (data text/format
              [bool]
              [number "i/" Number<Int>]
-             [char]
              [text])
-       ["R" math/random]
+       ["r" math/random]
        [macro]
        (macro [poly #+ derived:]
               ["&" poly/eq]))
@@ -25,29 +24,27 @@
    #bool Bool
    #int Int
    #real Real
-   #char Char
    #text Text
    #maybe (Maybe Int)
    #list (List Int)
    #variant Variant
-   #tuple [Int Real Char]})
+   #tuple [Int Real Text]})
 
 (def: gen-record
-  (R;Random Record)
-  (do R;Monad<Random>
-    [size (:: @ map (n.% +2) R;nat)
-     #let [gen-int (|> R;int (:: @ map (|>. i/abs (i.% 1_000_000))))]]
-    ($_ R;seq
+  (r;Random Record)
+  (do r;Monad<Random>
+    [size (:: @ map (n.% +2) r;nat)
+     #let [gen-int (|> r;int (:: @ map (|>. i/abs (i.% 1_000_000))))]]
+    ($_ r;seq
         (:: @ wrap [])
-        R;bool
+        r;bool
         gen-int
-        R;real
-        R;char
-        (R;text size)
-        (R;maybe gen-int)
-        (R;list size gen-int)
-        ($_ R;alt R;bool gen-int R;real)
-        ($_ R;seq gen-int R;real R;char)
+        r;real
+        (r;text size)
+        (r;maybe gen-int)
+        (r;list size gen-int)
+        ($_ r;alt r;bool gen-int r;real)
+        ($_ r;seq gen-int r;real (r;text size))
         )))
 
 (derived: (&;Eq<?> Record))
diff --git a/stdlib/test/test/lux/macro/poly/functor.lux b/stdlib/test/test/lux/macro/poly/functor.lux
index ae0765a60..34d0d1a82 100644
--- a/stdlib/test/test/lux/macro/poly/functor.lux
+++ b/stdlib/test/test/lux/macro/poly/functor.lux
@@ -7,9 +7,8 @@
        (data text/format
              [bool]
              [number "i/" Number<Int>]
-             [char]
              [text])
-       ["R" math/random]
+       ["r" math/random]
        [macro]
        (macro [poly #+ derived:]
               ["&" poly/functor]))
diff --git a/stdlib/test/test/lux/macro/poly/text-encoder.lux b/stdlib/test/test/lux/macro/poly/text-encoder.lux
index 240ad7ad4..a98b8801d 100644
--- a/stdlib/test/test/lux/macro/poly/text-encoder.lux
+++ b/stdlib/test/test/lux/macro/poly/text-encoder.lux
@@ -6,9 +6,8 @@
        (data text/format
              [bool]
              [number "i/" Number<Int>]
-             [char]
              [text])
-       ["R" math/random]
+       ["r" math/random]
        [macro]
        (macro [poly #+ derived:]
               ["&" poly/text-encoder]))
@@ -25,29 +24,27 @@
    #bool Bool
    #int Int
    #real Real
-   #char Char
    #text Text
    #maybe (Maybe Int)
    #list (List Int)
    #variant Variant
-   #tuple [Int Real Char]})
+   #tuple [Int Real Text]})
 
 (def: gen-record
-  (R;Random Record)
-  (do R;Monad<Random>
-    [size (:: @ map (n.% +2) R;nat)
-     #let [gen-int (|> R;int (:: @ map (|>. i/abs (i.% 1_000_000))))]]
-    ($_ R;seq
+  (r;Random Record)
+  (do r;Monad<Random>
+    [size (:: @ map (n.% +2) r;nat)
+     #let [gen-int (|> r;int (:: @ map (|>. i/abs (i.% 1_000_000))))]]
+    ($_ r;seq
         (:: @ wrap [])
-        R;bool
+        r;bool
         gen-int
-        R;real
-        R;char
-        (R;text size)
-        (R;maybe gen-int)
-        (R;list size gen-int)
-        ($_ R;alt R;bool gen-int R;real)
-        ($_ R;seq gen-int R;real R;char)
+        r;real
+        (r;text size)
+        (r;maybe gen-int)
+        (r;list size gen-int)
+        ($_ r;alt r;bool gen-int r;real)
+        ($_ r;seq gen-int r;real (r;text size))
         )))
 
 (derived: (&;Codec<Text,?>::encode Record))
diff --git a/stdlib/test/test/lux/macro/syntax.lux b/stdlib/test/test/lux/macro/syntax.lux
index fa53e4596..ff8befbda 100644
--- a/stdlib/test/test/lux/macro/syntax.lux
+++ b/stdlib/test/test/lux/macro/syntax.lux
@@ -8,7 +8,6 @@
              text/format
              [number]
              [bool]
-             [char]
              [ident]
              ["E" result])
        ["R" math/random]
@@ -76,7 +75,6 @@
                       ["Can parse Int syntax."    123            code;int    number;Eq<Int>  s;int]
                       ["Can parse Deg syntax."   .123           code;deg   number;Eq<Deg> s;deg]
                       ["Can parse Real syntax."   123.0          code;real   number;Eq<Real> s;real]
-                      ["Can parse Char syntax."   #"\n"          code;char   char;Eq<Char>   s;char]
                       ["Can parse Text syntax."   "\n"           code;text   text;Eq<Text>   s;text]
                       ["Can parse Symbol syntax." ["yolo" "lol"] code;symbol ident;Eq<Ident> s;symbol]
                       ["Can parse Tag syntax."    ["yolo" "lol"] code;tag    ident;Eq<Ident> s;tag]
diff --git a/stdlib/test/tests.lux b/stdlib/test/tests.lux
index 7fb6eafb7..7eff48e75 100644
--- a/stdlib/test/tests.lux
+++ b/stdlib/test/tests.lux
@@ -25,7 +25,6 @@
                       ["_;" parser])
              (data ["_;" bit]
                    ["_;" bool]
-                   ["_;" char]
                    ["_;" result]
                    ["_;" ident]
                    ["_;" identity]
@@ -75,7 +74,8 @@
              [trace]
              [store])
        [macro]
-       (math [random]))
+       (math [random])
+       (paradigm ["_;" concatenative]))
   )
 
 ## [Program]