Updating to v6.15, which includes "external (...)" instead of separate

'externally' versions of stuff, and some auto-formatting.

examples/how_do_i.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 # How do I...
 # Write a comment? Put a # and go till the end of the line
 # How do I write a multi-line comment?
@@ -247,7 +247,6 @@ say (2 + 3)
 # If you need to keep going after an indented region, you can start the next line with ".."
 say both "Very very very very long first argument that needs its own line"
 ..and also "short second arg"
-
 (my favorite number) means (21 + 2)
 
 # This can be nested:
@@ -330,6 +329,7 @@ say (best of [2, -3, 4, -8] according to $($ squared))
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 say (best of [2, -3, 4, -8] where $x has score ($x * $x))
+
 # The line above expands to:
 say
     result of:

ldt.lua

@@ -1 +0,0 @@
-/Users/bruce/Sandbox/lua/ldt/ldt.lua

lib/base64/init.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines actions for encoding/decoding base 64, as specified in:
     https://tools.ietf.org/html/rfc4648
@@ -15,36 +15,36 @@ test:
         assume (base64 $plain) == $encoded
         assume (base64 decode $encoded) == $plain
 
-externally [base64 $str, base64 encode $str, $str base64] all mean:
-    $chars = []
-    for $i in 1 to (size of $str) via 3:
-        $bytes = [=lua "\$str:byte(\$i, \($i + 2))"]
-        $chars, add $b64_chars.((($bytes.1 & 252) >> 2) + 1)
-        if (size of $bytes) is:
-            3:
-                $chars, add $b64_chars.((($bytes.1 & 3) << 4) + (($bytes.2 & 240) >> 4) + 1)
-                $chars, add $b64_chars.((($bytes.2 & 15) << 2) + (($bytes.3 & 192) >> 6) + 1)
-                $chars, add $b64_chars.(($bytes.3 & 63) + 1)
+external:
+    [base64 $str, base64 encode $str, $str base64] all mean:
+        $chars = []
+        for $i in 1 to (size of $str) via 3:
+            $bytes = [=lua "\$str:byte(\$i, \($i + 2))"]
+            $chars, add $b64_chars.((($bytes.1 & 252) >> 2) + 1)
+            if (size of $bytes) is:
+                3:
+                    $chars, add $b64_chars.((($bytes.1 & 3) << 4) + (($bytes.2 & 240) >> 4) + 1)
+                    $chars, add $b64_chars.((($bytes.2 & 15) << 2) + (($bytes.3 & 192) >> 6) + 1)
+                    $chars, add $b64_chars.(($bytes.3 & 63) + 1)
                 
-            2:
-                $chars, add $b64_chars.((($bytes.1 & 3) << 4) + (($bytes.2 & 240) >> 4) + 1)
-                $chars, add $b64_chars.((($bytes.2 & 15) << 2) + 1)
-                $chars, add "="
+                2:
+                    $chars, add $b64_chars.((($bytes.1 & 3) << 4) + (($bytes.2 & 240) >> 4) + 1)
+                    $chars, add $b64_chars.((($bytes.2 & 15) << 2) + 1)
+                    $chars, add "="
                 
-            1:
-                $chars, add $b64_chars.((($bytes.1 & 3) << 4) + 1)
-                $chars, add "="
-                $chars, add "="
-    return ($chars, joined)
-
-externally (chr $) means (=lua "string.char(\$)")
-externally [decode base64 $str, $str base64 decoded, base64 decode $str] all mean:
-    $chars = []
-    for $i in 1 to (size of $str) via 4:
-        $indices = [: for $j in $i to ($i + 3): add $reverse_b64.($str, character $j)]
-        $chars, add (chr (($indices.1 << 2) + (($indices.2 & 48) >> 4)))
-        if (($str, character ($i + 2)) == "="): stop
-        $chars, add (chr ((($indices.2 & 15) << 4) + (($indices.3 & 60) >> 2)))
-        if (($str, character ($i + 3)) == "="): stop
-        $chars, add (chr ((($indices.3 & 3) << 6) + $indices.4))
-    return ($chars, joined)
+                1:
+                    $chars, add $b64_chars.((($bytes.1 & 3) << 4) + 1)
+                    $chars, add "="
+                    $chars, add "="
+        return ($chars, joined)
+    (chr $) means (=lua "string.char(\$)")
+    [decode base64 $str, $str base64 decoded, base64 decode $str] all mean:
+        $chars = []
+        for $i in 1 to (size of $str) via 4:
+            $indices = [: for $j in $i to ($i + 3): add $reverse_b64.($str, character $j)]
+            $chars, add (chr (($indices.1 << 2) + (($indices.2 & 48) >> 4)))
+            if (($str, character ($i + 2)) == "="): stop
+            $chars, add (chr ((($indices.2 & 15) << 4) + (($indices.3 & 60) >> 2)))
+            if (($str, character ($i + 3)) == "="): stop
+            $chars, add (chr ((($indices.3 & 3) << 6) + $indices.4))
+        return ($chars, joined)

lib/commandline/init.nom

@@ -1,11 +1,12 @@
 #
     A library defining some command line program functionality
     
-(command line program with $args $body) parses as:
-    externally (run with $args) means $body
-    if (this file was run directly):
-        run with (the command line arguments)
+external:
+    (command line program with $args $body) parses as:
+        external ((run with $args) means $body)
+        if (this file was run directly):
+            run with (the command line arguments)
     
-externally (usage $) means:
-    say "Usage: \$"
-    exit 1
+    (usage $) means:
+        say "Usage: \$"
+        exit 1

lib/compatibility/2.3.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <2.3 to Nomsu 2.3
     

lib/compatibility/2.4.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <2.4 to Nomsu 2.4
     

lib/compatibility/2.5.5.5.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <2.5.5.5 to Nomsu 2.5.5.5
     

lib/compatibility/2.5.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <2.5 to Nomsu 2.5
     

lib/compatibility/2.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu 1 to Nomsu 2
     
@@ -24,8 +24,8 @@ upgrade $tree to "2" as:
     $need_blocks = [
         "if", "unless", "for 1 in", "for 1 = 2 in", "repeat while 1", "repeat 1 times"
         "repeat", "repeat until 1", "for 1 in 2 to 3 by", "for 1 in 2 to 3 via"
-        "for 1 in 2 to", "for 1 2 in", "do", "for 1 in recursive", "test", "with", "result of"
-        "when"
+        "for 1 in 2 to", "for 1 2 in", "do", "for 1 in recursive", "test", "with"
+        "result of", "when"
     ]
     
     for $n in $need_blocks:

lib/compatibility/3.5.5.6.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <3.5.5.6 to Nomsu 3.5.5.6
     

lib/compatibility/3.6.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <3.6 to 3.6
     
@@ -7,7 +7,8 @@ use "compatibility/compatibility"
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 upgrade action [
-    append $item to $list, add $item to $list, to $list add $item, to $list append $item
+    append $item to $list, add $item to $list, to $list add $item
+    to $list append $item
 ] to "3.6" as ($list, add $item)
 
 upgrade action [add $item to $list at index $i] to "3.6" as

lib/compatibility/3.7.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <3.7 to 3.7
     

lib/compatibility/3.8.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <3.8 to 3.8 (Text method changes)
     

lib/compatibility/3.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <=2 to Nomsu 3
     

lib/compatibility/4.10.12.7.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <4.10.12.7 to 4.10.12.7
 use "compatibility/compatibility"
@@ -8,9 +8,7 @@ use "compatibility/compatibility"
 upgrade action ($ as lua statements) to "4.10.12.7" as ($ as lua)
 upgrade action ($ as lua return) to "4.10.12.7" as
     =lua "\$.type == 'Block' and \($ as lua) or 'return '..\($ as lua expr)"
-
 upgrade action (Lua value $) to "4.10.12.7" as (Lua $)
-
 upgrade action ($e for $ in $items) to "4.10.12.7" as [: for $ in $items: add $e]
 upgrade action ($e for $k = $v in $items) to "4.10.12.7" as
     [: for $k = $v in $items: add $e]

lib/compatibility/4.11.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <4.11 to Nomsu 4.11
     (overhaul of function literals, deleting (if all of ...), etc. shorthand)
@@ -25,9 +25,7 @@ upgrade action "set" to "4.11" via
         for $entry in $tree.2 at $i:
             $lhs.$i = $entry.1
             $rhs.$i = $entry.2
-        
-        return
-            SyntaxTree {.type = "Action", .source = $tree.source} $lhs "=" $rhs
+        return (SyntaxTree {.type = "Action", .source = $tree.source} $lhs "=" $rhs)
 
 upgrade action "1 with 2 ~>" to "4.11" via
     for $tree:
@@ -93,5 +91,6 @@ upgrade action [
 ] to "4.11" as (if (not (any of $items)) $body else $else)
 
 upgrade action [
-    unless none of $items $body else $else, unless none of $items then $body else $else
+    unless none of $items $body else $else
+    unless none of $items then $body else $else
 ] to "4.11" as (if (any of $items) $body else $else)

lib/compatibility/4.12.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <4.11 to Nomsu 4.11
     (overhaul of function literals, deleting (if all of ...), etc. shorthand)

lib/compatibility/4.8.10.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <4.8.10 to 4.8.10 (renaming "action" -> "means")
 use "compatibility/compatibility"

lib/compatibility/4.9.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <4.9 to 4.9
 use "compatibility/compatibility"

lib/compatibility/5.13.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V5.13
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <5.13 to 5.13
 use "compatibility/compatibility"
@@ -6,19 +6,15 @@ use "compatibility/compatibility"
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 upgrade action (size of $) to "5.13" as (#$)
-
-upgrade action "with" to "5.13" via (..)
+upgrade action "with" to "5.13" via
     for $tree:
         $assignments = $tree.2
         $body = $tree.3
-        if ($assignments.type != "Dict"):
-            return $tree
+        if ($assignments.type != "Dict"): return $tree
         $new_assignments = \[]
         for $a in $assignments at $i:
             when:
-                (($a.type == "DictEntry") and ((#$a) == 1)):
-                    $a = $a.1
-                (all of [$a.type == "DictEntry", (#$a) == 2]):
-                    $a = \($a.1 = $a.2)
+                (($a.type == "DictEntry") and ((#$a) == 1)): $a = $a.1
+                (all of [$a.type == "DictEntry", (#$a) == 2]): $a = \($a.1 = $a.2)
             $new_assignments.$i = $a
         return \(with $new_assignments $body)

lib/compatibility/6.14.nom

@@ -1,6 +1,7 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines upgrades from Nomsu <6.14 to 6.14
+    
 use "compatibility/compatibility"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -26,16 +27,12 @@ upgrade action (assume $assumption or barf $err) to "6.14" as
     unless $assumption: fail $err
 
 upgrade action (barf $msg) to "6.14" as (fail $msg)
-
 upgrade action (\(1's meaning)).stub to "6.14" via
     $tree -> (SyntaxTree {.source = $tree.source, .type = "Var", $tree.1})
-
 upgrade action (log base $b of $n) to "6.14" as (log $n base $b)
-
 upgrade action "use" to "6.14" via
     for $tree:
         $path = $tree.2.1
         $path = ($path, with "%.nom$" -> "")
         $path = ($path, with "^lib/" -> "")
-        return \(use (SyntaxTree {.source = $tree.2.source, .type="Text"} $path))
-
+        return \(use (SyntaxTree {.source = $tree.2.source, .type = "Text"} $path))

lib/compatibility/6.15.nom

@@ -0,0 +1,20 @@
+#!/usr/bin/env nomsu -V6.15.13.8
+#
+    This file defines upgrades from Nomsu <6.15 to 6.15
+    
+use "compatibility/compatibility"
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+upgrade action (external $x = $y) to "6.15" as (external ($x = $y))
+upgrade action (externally $x means $y) to "6.15" as (external ($x means $y))
+upgrade action (externally $x all mean $y) to "6.15" as
+    external ($x all mean $y)
+
+upgrade action ($lists flattened) to "6.15" as [
+    : for $ in recursive $lists:
+        if ($ is a "List"):
+            for $child in $:
+                recurse $ on $child
+        ..else: add $
+]

lib/compatibility/compatibility.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file contains code for defining ways to upgrade code between different versions
     of Nomsu.
@@ -8,126 +8,123 @@ use "filesystem"
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 $UPGRADES = {}
-externally (upgrade to $version via $upgrade_fn) means:
-    $UPGRADES.$version = $upgrade_fn
 $ACTION_UPGRADES = ({} with fallback $ -> {})
-externally (upgrade action $stub to $version via $upgrade_fn) means:
-    $ACTION_UPGRADES.$version.$stub = $upgrade_fn
+external:
+    (upgrade to $version via $upgrade_fn) means:
+        $UPGRADES.$version = $upgrade_fn
     
-(upgrade $tree to $version as $body) parses as
-    upgrade to $version via (($ $end_version) -> ($ with $tree -> $body))
+    (upgrade action $stub to $version via $upgrade_fn) means:
+        $ACTION_UPGRADES.$version.$stub = $upgrade_fn
     
-(upgrade action $actions to $version as $body) compiles to:
-    if ($actions is "Action" syntax tree):
-        $actions = \[$actions]
-    $lua = (Lua "")
-    for $action in $actions:
-        $replacements = {}
-        for $i in 1 to (size of $action):
-            if ($action.$i is "Var" syntax tree):
-                $replacements.($action.$i.1) = "\(\$tree as lua id)[\$i]"
-        define mangler
-        (make tree $t) means:
-            when:
-                ($t is "Var" syntax tree):
-                    if $replacements.($t.1):
-                        return $replacements.($t.1)
-                    ..else:
-                        external $needs_mangle = (yes)
-                        return ("
-                            SyntaxTree{type=\(quote $t.type), source=\(quote "\($t.source)"), \(quote (mangle $t.1))}
-                        ")
+    (upgrade $tree to $version as $body) parses as
+        upgrade to $version via (($ $end_version) -> ($ with $tree -> $body))
     
-                ($t is syntax tree):
-                    $args = []
-                    for $k = $v in $t:
-                        if ((type of $k) == "number"):
-                            $args, add (make tree $v)
+    (upgrade action $actions to $version as $body) compiles to:
+        if ($actions is "Action" syntax tree):
+            $actions = \[$actions]
+        $lua = (Lua "")
+        for $action in $actions:
+            $replacements = {}
+            for $i in 1 to (size of $action):
+                if ($action.$i is "Var" syntax tree):
+                    $replacements.($action.$i.1) = "\(\$tree as lua id)[\$i]"
+            define mangler
+            (make tree $t) means:
+                when:
+                    ($t is "Var" syntax tree):
+                        if $replacements.($t.1):
+                            return $replacements.($t.1)
                         ..else:
-                            $args, add "\($k)=\(make tree $v)"
-                    return "SyntaxTree{\($args, joined with ", ")}"
+                            external ($needs_mangle = (yes))
+                            return ("
+                                SyntaxTree{type=\(quote $t.type), source=\(quote "\($t.source)"), \(quote (mangle $t.1))}
+                            ")
                     
-                else:
-                    return (quote $t)
+                    ($t is syntax tree):
+                        $args = []
+                        for $k = $v in $t:
+                            if ((type of $k) == "number"):
+                                $args, add (make tree $v)
+                            ..else:
+                                $args, add "\($k)=\(make tree $v)"
+                        return "SyntaxTree{\($args, joined with ", ")}"
                     
-        unless ("\$lua" == ""):
-            $lua, add "\n"
+                    else:
+                        return (quote $t)
             
-        $retval = (make tree $body)
-        $lua, add
-            Lua ("
-                upgrade_action_1_to_2_via(\(quote $action.stub), \($version as lua expr), function(\
-                ..\(\$tree as lua id))
-                    return \$retval
-                end)
-            ")
-    return $lua
+            unless ("\$lua" == ""):
+                $lua, add "\n"
             
-externally [
-    $tree upgraded from $start_version to $end_version
-    $tree upgraded to $end_version from $start_version
-] all mean:
-    unless ($tree is syntax tree): return $tree
+            $retval = (make tree $body)
+            $lua, add
+                Lua ("
+                    upgrade_action_1_to_2_via(\(quote $action.stub), \($version as lua expr), function(\
+                    ..\(\$tree as lua id))
+                        return \$retval
+                    end)
+                ")
+        return $lua
     
-    ($ver as list) means (($ as number) for $ in $ver matching "[0-9]+")
+    [
+        $tree upgraded from $start_version to $end_version
+        $tree upgraded to $end_version from $start_version
+    ] all mean:
+        unless ($tree is syntax tree): return $tree
+        ($ver as list) means (($ as number) for $ in $ver matching "[0-9]+")
+        (Ver $) means:
+            [$lib, $ver] = ($, match "(.*)/([0-9.]+)")
+            if $lib:
+                return {.lib = $lib, .version = ($ver as list)}
+            return {.version = ($ as list)}
+        $start = (Ver $start_version)
+        $end = (Ver $end_version)
+        $end.lib or= $start.lib
+        assume $start.lib == $end.lib
+        $seen = {}
+        $versions = {}
+        for $v = $ in $UPGRADES:
+            $versions.$v = (yes)
         
-    (Ver $) means:
-        [$lib, $ver] = ($, match "(.*)/([0-9.]+)")
-        if $lib:
-            return {.lib = $lib, .version = ($ver as list)}
-        return {.version = ($ as list)}
+        for $v = $ in $ACTION_UPGRADES:
+            $versions.$v = (yes)
         
-    $start = (Ver $start_version)
-    $end = (Ver $end_version)
-    $end.lib or= $start.lib
-    assume $start.lib == $end.lib
+        $versions = [: for $v = $ in $versions: if ((Ver $v).lib == $start.lib): add $v]
+        sort $versions by $ -> ($ as list)
+        for $ver in $versions:
+            if (($ver as list) <= $start.version): do next $ver
+            if (($ver as list) > $end.version): stop $ver
+            if $ACTION_UPGRADES.$ver:
+                $tree =
+                    $tree with $ ->:
+                        if (($ is "Action" syntax tree) and $ACTION_UPGRADES.$ver.($.stub)):
+                            $with_upgraded_args = {
+                                : for $k = $v in $:
+                                    add $k = ($v upgraded from $start_version to $end_version)
+                            }
+                            set $with_upgraded_args's metatable to ($'s metatable)
+                            return ($ACTION_UPGRADES.$ver.($.stub) $with_upgraded_args $end_version)
             
-    $seen = {}
-    $versions = {}
-    for $v = $ in $UPGRADES: $versions.$v = (yes)
-    for $v = $ in $ACTION_UPGRADES: $versions.$v = (yes)
-    $versions = [
-        :for $v = $ in $versions:
-            if ((Ver $v).lib == $start.lib):
-                add $v
-    ]
+            if $UPGRADES.$ver:
+                $with_upgraded_args = {
+                    : for $k = $v in $tree:
+                        add $k = ($v upgraded from $start_version to $end_version)
+                }
+                set $with_upgraded_args's metatable to ($tree's metatable)
+                $tree = ($UPGRADES.$ver $with_upgraded_args $end_version)
         
-    sort $versions by $ -> ($ as list)
-    for $ver in $versions:
-        if (($ver as list) <= $start.version): do next $ver
-        if (($ver as list) > $end.version): stop $ver
-        if $ACTION_UPGRADES.$ver:
-            $tree =
-                $tree with $ ->:
-                    if (($ is "Action" syntax tree) and $ACTION_UPGRADES.$ver.($.stub)):
-                        $with_upgraded_args = {
-                            : for $k = $v in $:
-                                add $k = ($v upgraded from $start_version to $end_version)
-                        }
-                        set $with_upgraded_args's metatable to ($'s metatable)
-                        return ($ACTION_UPGRADES.$ver.($.stub) $with_upgraded_args $end_version)
+        if ($tree.version != $end_version):
+            $tree = (SyntaxTree {: for $k = $v in $tree: add $k = $v})
+            $tree.version = $end_version
+            if $tree.shebang:
+                $tree.shebang = "#!/usr/bin/env nomsu -V\$end_version\n"
         
-        if $UPGRADES.$ver:
-            $with_upgraded_args = {
-                : for $k = $v in $tree:
-                    add $k = ($v upgraded from $start_version to $end_version)
-            }
-            set $with_upgraded_args's metatable to ($tree's metatable)
-            $tree = ($UPGRADES.$ver $with_upgraded_args $end_version)
+        return $tree
     
-    if ($tree.version != $end_version):
-        $tree = (SyntaxTree {: for $k = $v in $tree: add $k = $v})
-        $tree.version = $end_version
-        if $tree.shebang:
-            $tree.shebang = "#!/usr/bin/env nomsu -V\$end_version\n"
+    ($tree upgraded from $start_version) means
+        $tree upgraded from $start_version to (Nomsu version)
     
-    return $tree
+    ($tree upgraded to $end_version) means
+        $tree upgraded from ($tree.version or (Nomsu version)) to $end_version
     
-externally ($tree upgraded from $start_version) means
-    $tree upgraded from $start_version to (Nomsu version)
-
-externally ($tree upgraded to $end_version) means
-    $tree upgraded from ($tree.version or (Nomsu version)) to $end_version
-
-externally ($tree upgraded) means
-    $tree upgraded from ($tree.version or (Nomsu version)) to (Nomsu version)
+    ($tree upgraded) means
+        $tree upgraded from ($tree.version or (Nomsu version)) to (Nomsu version)

lib/compatibility/init.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14.13.8
+#!/usr/bin/env nomsu -V6.15.13.8
 export "compatibility/compatibility"
 export "compatibility/2"
 export "compatibility/2.3"

lib/consolecolor/init.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines actions for ANSI console color escape codes.
     

lib/core/collections.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file contains code that supports manipulating and using collections like lists
     and dictionaries.
@@ -44,19 +44,6 @@ test:
     assume ({.x = 1, .y = 1} & {.y = 10, .z = 10}) == {.y = 1}
     assume ({.x = 1, .y = 1} ~ {.y = 10, .z = 10}) == {.x = 1, .z = 10}
 
-test:
-    assume (([[1, 2], [3, 4]] flattened) == [1, 2, 3, 4])
-
-externally ($lists flattened) means:
-    $flat = []
-    for $item in recursive $lists:
-        if ($item is a "List"):
-            for $ in $item:
-                recurse $item on $
-        ..else:
-            $flat, add $item
-    return $flat
-
 test:
     assume ((entries in {.x = 1}) == [{.key = "x", .value = 1}])
 
@@ -118,28 +105,29 @@ test:
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-test:
-    assume ((sorted [3, 1, 2]) == [1, 2, 3])
+external:
+    test:
+        assume ((sorted [3, 1, 2]) == [1, 2, 3])
     
-externally [$items sorted, sorted $items] all mean:
-    $copy = [: for $ in $items: add $]
-    sort $copy
-    return $copy
-
-[$items sorted by $item = $key, $items sorted by $item -> $key] all parse as
-    result of:
+    [$items sorted, sorted $items] all mean:
         $copy = [: for $ in $items: add $]
-        sort $copy by $item = $key
+        sort $copy
         return $copy
     
-test:
-    assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3])
+    [$items sorted by $item = $key, $items sorted by $item -> $key] all parse as
+        result of:
+            $copy = [: for $ in $items: add $]
+            sort $copy by $item = $key
+            return $copy
     
-externally (unique $items) means:
-    $unique = []
-    $seen = {}
-    for $ in $items:
-        unless $seen.$:
-            $unique, add $
-            $seen.$ = (yes)
-    return $unique
+    test:
+        assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3])
+    
+    (unique $items) means:
+        $unique = []
+        $seen = {}
+        for $ in $items:
+            unless $seen.$:
+                $unique, add $
+                $seen.$ = (yes)
+        return $unique

lib/core/control_flow.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file contains compile-time actions that define basic control flow structures
     like "if" statements and loops.
@@ -466,6 +466,7 @@ test:
 # Recurion control flow
 (recurse $v on $x) compiles to
     Lua "table.insert(_stack_\($v as lua expr), \($x as lua expr))"
+
 (for $var in recursive $structure $body) compiles to:
     $lua =
         Lua ("

lib/core/coroutines.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines the code that creates and manipulates coroutines
     

lib/core/errors.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file contains basic error reporting code
     
@@ -23,9 +23,7 @@ use "core/control_flow"
 
 (assume $a == $b) compiles to:
     lua> "local \$assumption = 'Assumption failed: '..tostring(\(\($a == $b) as nomsu))"
-    
     define mangler
-    
     return
         Lua ("
             do

lib/core/id.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     A simple UUID function based on RFC 4122: http://www.ietf.org/rfc/rfc4122.txt
     
@@ -33,34 +33,35 @@ set $id_by_obj's metatable to {
             return $id
 }
 
-externally (uuid) means:
-    # Set all the other bits to randomly (or pseudo-randomly) chosen values.
-    $bytes = [
-        # time-low, time-mid, time-high-and-version
-        randint (2 ^ (4 * 8)), randint (2 ^ (2 * 8)), randint (2 ^ (2 * 8 - 4))
-        # clock-seq-and-reserved, clock-seq-low
-        randint (2 ^ (1 * 8 - 2)), randint (2 ^ (1 * 8)), randint (2 ^ (3 * 8))
-        # node
-        randint (2 ^ (3 * 8))
-    ]
+external:
+    (uuid) means:
+        # Set all the other bits to randomly (or pseudo-randomly) chosen values.
+        $bytes = [
+            # time-low, time-mid, time-high-and-version
+            randint (2 ^ (4 * 8)), randint (2 ^ (2 * 8)), randint (2 ^ (2 * 8 - 4))
+            # clock-seq-and-reserved, clock-seq-low
+            randint (2 ^ (1 * 8 - 2)), randint (2 ^ (1 * 8)), randint (2 ^ (3 * 8))
+            # node
+            randint (2 ^ (3 * 8))
+        ]
         
-    # Set the four most significant bits (bits 12 through 15) of the
-    # time_hi_and_version field to the 4-bit version number from
-    # Section 4.1.3.
-    $bytes.3 += 0x4000
+        # Set the four most significant bits (bits 12 through 15) of the
+        # time_hi_and_version field to the 4-bit version number from
+        # Section 4.1.3.
+        $bytes.3 += 0x4000
         
-    # Set the two most significant bits (bits 6 and 7) of the
-    # clock_seq_hi_and_reserved to zero and one, respectively.
-    $bytes.4 += 0xC0
-    return (=lua "('%08x-%04x-%04x-%02x%02x-%6x%6x'):format(unpack(\$bytes))")
+        # Set the two most significant bits (bits 6 and 7) of the
+        # clock_seq_hi_and_reserved to zero and one, respectively.
+        $bytes.4 += 0xC0
+        return (=lua "('%08x-%04x-%04x-%02x%02x-%6x%6x'):format(unpack(\$bytes))")
     
-# For strict identity checking, use ($x's id) == ($y's id)
-test:
-    assume (([] == []) and ((id of []) != (id of [])))
-    seed random with 0
-    $x = []
-    assume ((id of $x) == (id of $x))
-    seed random with 0
-    assume ((id of $x) != (id of []))
-    seed random
-externally [id of $, $'s id, $'id] all mean $id_by_obj.$
+    # For strict identity checking, use ($x's id) == ($y's id)
+    test:
+        assume (([] == []) and ((id of []) != (id of [])))
+        seed random with 0
+        $x = []
+        assume ((id of $x) == (id of $x))
+        seed random with 0
+        assume ((id of $x) != (id of []))
+        seed random
+    [id of $, $'s id, $'id] all mean $id_by_obj.$

lib/core/init.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14.13.8
+#!/usr/bin/env nomsu -V6.15.13.8
 # Export everything
 export "core/metaprogramming"
 export "core/operators"

lib/core/io.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file contains basic input/output code
     
@@ -6,24 +6,25 @@ use "core/metaprogramming"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-(say $message) compiles to:
-    lua> ("
-        if \$message.type == "Text" then
-            return LuaCode("say(", \($message as lua expr), ");");
-        else
-            return LuaCode("say(tostring(", \($message as lua expr), "));");
-        end
-    ")
+external:
+    (say $message) compiles to:
+        lua> ("
+            if \$message.type == "Text" then
+                return LuaCode("say(", \($message as lua expr), ");");
+            else
+                return LuaCode("say(tostring(", \($message as lua expr), "));");
+            end
+        ")
     
-(say $message inline) compiles to:
-    lua> ("
-        if \$message.type == "Text" then
-            return LuaCode("io.write(", \($message as lua expr), ")");
-        else
-            return LuaCode("io.write(tostring(", \($message as lua expr), "))");
-        end
-    ")
+    (say $message inline) compiles to:
+        lua> ("
+            if \$message.type == "Text" then
+                return LuaCode("io.write(", \($message as lua expr), ")");
+            else
+                return LuaCode("io.write(tostring(", \($message as lua expr), "))");
+            end
+        ")
     
-externally (ask $prompt) means:
-    $io.write $prompt
-    return ($io.read())
+    (ask $prompt) means:
+        $io.write $prompt
+        return ($io.read())

lib/core/math.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines some common math literals and functions
     
@@ -10,203 +10,201 @@ use "core/collections"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-# Literals:
-test:
-    unless (all of [inf, NaN, pi, tau, golden ratio, e]):
-        fail "math constants failed"
-    $nan = (NaN)
-    unless ($nan != $nan):
-        fail "NaN failed"
-[infinity, inf] all compile to "math.huge"
-[not a number, NaN, nan] all compile to "(0/0)"
-[pi, Pi, PI] all compile to "math.pi"
-[tau, Tau, TAU] all compile to "(2*math.pi)"
-(golden ratio) compiles to "((1+math.sqrt(5))/2)"
-(e) compiles to "math.exp(1)"
+external:
+    # Literals:
+    test:
+        unless (all of [inf, NaN, pi, tau, golden ratio, e]):
+            fail "math constants failed"
+        $nan = (NaN)
+        unless ($nan != $nan):
+            fail "NaN failed"
+    [infinity, inf] all compile to "math.huge"
+    [not a number, NaN, nan] all compile to "(0/0)"
+    [pi, Pi, PI] all compile to "math.pi"
+    [tau, Tau, TAU] all compile to "(2*math.pi)"
+    (golden ratio) compiles to "((1+math.sqrt(5))/2)"
+    (e) compiles to "math.exp(1)"
     
-# Functions:
-test:
-    assume (("5" as a number) == 5)
-external $($ as a number) = $(tonumber $)
-external $($ as number) = $(tonumber $)
-test:
-    unless
-        all of [
-            abs 5, | 5 |, sqrt 5, √ 5, sine 5, cosine 5, tangent 5, arc sine 5, arc cosine 5
-            arc tangent 5, arc tangent 5 / 10, hyperbolic sine 5, hyperbolic cosine 5
-            hyperbolic tangent 5, e^ 5, ln 5, log 5 base 2, floor 5, ceiling 5, round 5
-        ]
-    ..:
-        fail "math functions failed"
-external [$(absolute value $), $(absolute value of $), $(| $ |), $(abs $)] =
-    [$math.abs, $math.abs, $math.abs, $math.abs]
-external [$(square root $), $(square root of $), $(√ $), $(sqrt $)] =
-    [$math.sqrt, $math.sqrt, $math.sqrt, $math.sqrt]
-external [$(sine $), $(sin $)] = [$math.sin, $math.sin]
-external [$(cosine $), $(cos $)] = [$math.cos, $math.cos]
-external [$(tangent $), $(tan $)] = [$math.tan, $math.tan]
-external [$(arc sine $), $(asin $)] = [$math.asin, $math.asin]
-external [$(arc cosine $), $(acos $)] = [$math.acos, $math.acos]
-external [$(arc tangent $), $(atan $)] = [$math.atan, $math.atan]
-external [$(arc tangent $y / $x), $(atan2 $y $x)] = [$math.atan2, $math.atan2]
-external [$(hyperbolic sine $), $(sinh $)] = [$math.sinh, $math.sinh]
-external [$(hyperbolic cosine $), $(cosh $)] = [$math.cosh, $math.cosh]
-external [$(hyperbolic tangent $), $(tanh $)] = [$math.tanh, $math.tanh]
-external [$(e^ $), $(exp $)] = [$math.exp, $math.exp]
-external [$(natural log $), $(ln $), $(log $), $(log $ base $)] = [$math.log, $math.log, $math.log, $math.log]
-external $(floor $) = $math.floor
-external [$(ceiling $), $(ceil $)] = [$math.ceil, $math.ceil]
-externally [round $, $ rounded] all mean
-    floor ($ + 0.5)
-test:
-    unless ((463 to the nearest 100) == 500): fail "rounding failed"
-    unless ((2.6 to the nearest 0.25) == 2.5): fail "rounding failed"
+    # Functions:
+    test:
+        assume (("5" as a number) == 5)
+    $($ as a number) = $(tonumber $)
+    $($ as number) = $(tonumber $)
+    test:
+        unless
+            all of [
+                abs 5, | 5 |, sqrt 5, √ 5, sine 5, cosine 5, tangent 5, arc sine 5, arc cosine 5
+                arc tangent 5, arc tangent 5 / 10, hyperbolic sine 5, hyperbolic cosine 5
+                hyperbolic tangent 5, e^ 5, ln 5, log 5 base 2, floor 5, ceiling 5, round 5
+            ]
+        ..:
+            fail "math functions failed"
     
-externally ($n to the nearest $rounder) means
-    $rounder * (floor ($n / $rounder + 0.5))
+    [$(absolute value $), $(absolute value of $), $(| $ |), $(abs $)] =
+        [$math.abs, $math.abs, $math.abs, $math.abs]
     
-# Any/all
-externally [all of $items, all $items] all mean:
-    for $ in $items:
-        unless $:
-            return (no)
-    return (yes)
-[not all of $items, not all $items] all parse as (not (all of $items))
-externally [any of $items, any $items] all mean:
-    for $ in $items:
-        if $:
-            return (yes)
-    return (no)
-[none of $items, none $items] all parse as (not (any of $items))
+    [$(square root $), $(square root of $), $(√ $), $(sqrt $)] =
+        [$math.sqrt, $math.sqrt, $math.sqrt, $math.sqrt]
     
-# Sum/product
-externally [sum of $items, sum $items] all mean:
-    $total = 0
-    for $ in $items:
-        $total += $
-    return $total
+    [$(sine $), $(sin $)] = [$math.sin, $math.sin]
+    [$(cosine $), $(cos $)] = [$math.cos, $math.cos]
+    [$(tangent $), $(tan $)] = [$math.tan, $math.tan]
+    [$(arc sine $), $(asin $)] = [$math.asin, $math.asin]
+    [$(arc cosine $), $(acos $)] = [$math.acos, $math.acos]
+    [$(arc tangent $), $(atan $)] = [$math.atan, $math.atan]
+    [$(arc tangent $y / $x), $(atan2 $y $x)] = [$math.atan2, $math.atan2]
+    [$(hyperbolic sine $), $(sinh $)] = [$math.sinh, $math.sinh]
+    [$(hyperbolic cosine $), $(cosh $)] = [$math.cosh, $math.cosh]
+    [$(hyperbolic tangent $), $(tanh $)] = [$math.tanh, $math.tanh]
+    [$(e^ $), $(exp $)] = [$math.exp, $math.exp]
+    [$(natural log $), $(ln $), $(log $), $(log $ base $)] =
+        [$math.log, $math.log, $math.log, $math.log]
+    $(floor $) = $math.floor
+    [$(ceiling $), $(ceil $)] = [$math.ceil, $math.ceil]
+    [round $, $ rounded] all mean (floor ($ + 0.5))
+    test:
+        unless ((463 to the nearest 100) == 500): fail "rounding failed"
+        unless ((2.6 to the nearest 0.25) == 2.5): fail "rounding failed"
+    ($n to the nearest $rounder) means ($rounder * (floor ($n / $rounder + 0.5)))
     
-externally [product of $items, product $items] all mean:
-    $prod = 1
-    for $ in $items:
-        $prod *= $
-    return $prod
+    # Any/all
+    [all of $items, all $items] all mean:
+        for $ in $items:
+            unless $:
+                return (no)
+        return (yes)
+    [not all of $items, not all $items] all parse as (not (all of $items))
+    [any of $items, any $items] all mean:
+        for $ in $items:
+            if $:
+                return (yes)
+        return (no)
+    [none of $items, none $items] all parse as (not (any of $items))
     
-externally [avg of $items, average of $items] all mean
-    (sum of $items) / (size of $items)
+    # Sum/product
+    [sum of $items, sum $items] all mean:
+        $total = 0
+        for $ in $items:
+            $total += $
+        return $total
     
-# Min/max
-externally [min of $items, smallest of $items, lowest of $items] all mean:
-    $best = (nil)
-    for $ in $items:
-        if (($best == (nil)) or ($ < $best)): $best = $
-    return $best
+    [product of $items, product $items] all mean:
+        $prod = 1
+        for $ in $items:
+            $prod *= $
+        return $prod
     
-externally [
-    max of $items, biggest of $items, largest of $items, highest of $items
-] all mean:
-    $best = (nil)
-    for $ in $items:
-        if (($best == (nil)) or ($ > $best)): $best = $
-    return $best
+    [avg of $items, average of $items] all mean ((sum of $items) / (size of $items))
     
-test:
-    assume ((min of [3, -4, 1, 2] by $ = ($ * $)) == 1)
-    assume ((max of [3, -4, 1, 2] by $ = ($ * $)) == -4)
-
-(min of $items by $item = $value_expr) parses as
-    result of:
+    # Min/max
+    [min of $items, smallest of $items, lowest of $items] all mean:
         $best = (nil)
-        $best_key = (nil)
-        for $item in $items:
-            $key = $value_expr
-            if (($best == (nil)) or ($key < $best_key)):
-                $best = $item
-                $best_key = $key
+        for $ in $items:
+            if (($best == (nil)) or ($ < $best)): $best = $
         return $best
     
-(max of $items by $item = $value_expr) parses as
-    result of:
+    [max of $items, biggest of $items, largest of $items, highest of $items] all mean:
         $best = (nil)
-        $best_key = (nil)
-        for $item in $items:
-            $key = $value_expr
-            if (($best == (nil)) or ($key > $best_key)):
-                $best = $item
-                $best_key = $key
+        for $ in $items:
+            if (($best == (nil)) or ($ > $best)): $best = $
         return $best
     
-test:
-    assume (100 clamped between 0 and 10) == 10
+    test:
+        assume ((min of [3, -4, 1, 2] by $ = ($ * $)) == 1)
+        assume ((max of [3, -4, 1, 2] by $ = ($ * $)) == -4)
     
-externally ($ clamped between $min and $max) means:
-    when:
-        ($ < $min):
-            return $min
+    (min of $items by $item = $value_expr) parses as
+        result of:
+            $best = (nil)
+            $best_key = (nil)
+            for $item in $items:
+                $key = $value_expr
+                if (($best == (nil)) or ($key < $best_key)):
+                    $best = $item
+                    $best_key = $key
+            return $best
     
-        ($ > $max):
-            return $max
+    (max of $items by $item = $value_expr) parses as
+        result of:
+            $best = (nil)
+            $best_key = (nil)
+            for $item in $items:
+                $key = $value_expr
+                if (($best == (nil)) or ($key > $best_key)):
+                    $best = $item
+                    $best_key = $key
+            return $best
     
-        else:
-            return $
+    test:
+        assume (100 clamped between 0 and 10) == 10
     
-test:
-    assume (-0.1 smoothed by 2.7) == 0
-    assume (0 smoothed by 2.7) == 0
-    assume (0.5 smoothed by 2.7) == 0.5
-    assume (1 smoothed by 2.7) == 1
-    assume (1.1 smoothed by 2.7) == 1
+    ($ clamped between $min and $max) means:
+        when:
+            ($ < $min):
+                return $min
             
-externally ($ smoothed by $smoothness) means:
-    $ = ($ clamped between 0 and 1)
-    if ($smoothness == 0): return $
-    $k = (2 ^ $smoothness)
-    if ($ < 0.5):
-        return (0.5 * (2 * $) ^ $k)
-    ..else:
-        return (1 - 0.5 * (2 - 2 * $) ^ $k)
+            ($ > $max):
+                return $max
             
-test:
-    assume (5 to 7 mixed by -1.0) == 5
-    assume (5 to 7 mixed by 0.0) == 5
-    assume (5 to 7 mixed by 0.5) == 6
-    assume (5 to 7 mixed by 1.0) == 7
-    assume (5 to 7 mixed by 2.0) == 7
+            else:
+                return $
     
-externally ($lo to $hi mixed by $amount) means:
-    $ = ($amount clamped between 0 and 1)
-    return ((1 - $) * $lo + $ * $hi)
+    test:
+        assume (-0.1 smoothed by 2.7) == 0
+        assume (0 smoothed by 2.7) == 0
+        assume (0.5 smoothed by 2.7) == 0.5
+        assume (1 smoothed by 2.7) == 1
+        assume (1.1 smoothed by 2.7) == 1
     
-test:
-    assume ([0, 1, 11] mixed by 0.0) == 0
-    assume ([0, 1, 11] mixed by 0.25) == 0.5
-    assume ([0, 1, 11] mixed by 0.5) == 1
-    assume ([0, 1, 11] mixed by 0.75) == 6
-    assume ([0, 1, 11] mixed by 1.0) == 11
-    assume ([99] mixed by 0.5) == 99
+    ($ smoothed by $smoothness) means:
+        $ = ($ clamped between 0 and 1)
+        if ($smoothness == 0): return $
+        $k = (2 ^ $smoothness)
+        if ($ < 0.5):
+            return (0.5 * (2 * $) ^ $k)
+        ..else:
+            return (1 - 0.5 * (2 - 2 * $) ^ $k)
     
-externally ($nums mixed by $amount) means:
-    $ = ($amount clamped between 0 and 1)
-    $i = (1 + ($ * ((#$nums) - 1)))
-    if ((floor $i) == (#$nums)):
-        return $nums.(floor $i)
-    [$lo, $hi] = [$nums.(floor $i), $nums.(floor ($i + 1))]
-    return ($lo to $hi mixed by ($i mod 1))
+    test:
+        assume (5 to 7 mixed by -1) == 5
+        assume (5 to 7 mixed by 0) == 5
+        assume (5 to 7 mixed by 0.5) == 6
+        assume (5 to 7 mixed by 1) == 7
+        assume (5 to 7 mixed by 2) == 7
     
-# Random functions
-externally (seed random with $) means:
-    lua> ("
-        math.randomseed(\$);
-        for i=1,20 do math.random(); end
-    ")
-(seed random) parses as (seed random with (=lua "os.time()"))
-[random number, random, rand] all compile to "math.random()"
-[random int $n, random integer $n, randint $n] all compile to
-    "math.random(\($n as lua expr))"
+    ($lo to $hi mixed by $amount) means:
+        $ = ($amount clamped between 0 and 1)
+        return ((1 - $) * $lo + $ * $hi)
     
-[random from $low to $high, random number from $low to $high, rand $low $high]
-..all compile to "math.random(\($low as lua expr), \($high as lua expr))"
+    test:
+        assume ([0, 1, 11] mixed by 0) == 0
+        assume ([0, 1, 11] mixed by 0.25) == 0.5
+        assume ([0, 1, 11] mixed by 0.5) == 1
+        assume ([0, 1, 11] mixed by 0.75) == 6
+        assume ([0, 1, 11] mixed by 1) == 11
+        assume ([99] mixed by 0.5) == 99
     
-externally [
-    random choice from $elements, random choice $elements, random $elements
-] all mean (=lua "\$elements[math.random(#\$elements)]")
+    ($nums mixed by $amount) means:
+        $ = ($amount clamped between 0 and 1)
+        $i = (1 + ($ * ((#$nums) - 1)))
+        if ((floor $i) == (#$nums)):
+            return $nums.(floor $i)
+        [$lo, $hi] = [$nums.(floor $i), $nums.(floor ($i + 1))]
+        return ($lo to $hi mixed by ($i mod 1))
+    
+    # Random functions
+    (seed random with $) means:
+        lua> ("
+            math.randomseed(\$);
+            for i=1,20 do math.random(); end
+        ")
+    (seed random) parses as (seed random with (=lua "os.time()"))
+    [random number, random, rand] all compile to "math.random()"
+    [random int $n, random integer $n, randint $n] all compile to
+        "math.random(\($n as lua expr))"
+    
+    [random from $low to $high, random number from $low to $high, rand $low $high]
+    ..all compile to "math.random(\($low as lua expr), \($high as lua expr))"
+    
+    [random choice from $elements, random choice $elements, random $elements]
+    ..all mean (=lua "\$elements[math.random(#\$elements)]")

lib/core/metaprogramming.nom

@@ -1,9 +1,9 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This File contains actions for making actions and compile-time actions and some helper
     functions to make that easier.
     
-lua> "NOMSU_CORE_VERSION = 14"
+lua> "NOMSU_CORE_VERSION = 15"
 lua> "NOMSU_LIB_VERSION = 8"
 lua> ("
     do
@@ -25,8 +25,7 @@ lua> ("
     COMPILE_RULES["1 ->"] = function(\(nomsu environment), \$args, \$body)
         if \$args and not \$body then \$args, \$body = {}, \$args end
         local body_lua = SyntaxTree:is_instance(\$body) and \(nomsu environment):compile(\$body) or \$body
-        if SyntaxTree:is_instance(\$body) and \$body.type ~= "Block" then body_lua:prepend("\
-    ..return ") end
+        if SyntaxTree:is_instance(\$body) and \$body.type ~= "Block" then body_lua:prepend("return ") end
         local lua = LuaCode("(function(")
         if SyntaxTree:is_instance(\$args) and (\$args.type == "Action" or \$args.type == "MethodCall") then
             \$args = \$args:get_args()
@@ -41,8 +40,7 @@ lua> ("
                 end
             elseif not arg_lua:is_lua_id() then
                 compile_error_at(SyntaxTree:is_instance(arg) and arg or nil,
-                    "This does not compile to a Lua identifier, so it can't be used as a function \
-    ..argument.",
+                    "This does not compile to a Lua identifier, so it can't be used as a function argument.",
                     "This should probably be a Nomsu variable instead (like $x).")
             end
             lua:add(i > 1 and ", " or "", arg_lua)
@@ -186,26 +184,40 @@ test:
     ")
 
 test:
-    externally (baz1) means:
-        return "baz1"
-    externally (baz2) means "baz2"
+    $loc = 99
+    external ($glob = 99)
 
 test:
-    assume ((baz1) == "baz1")
-    assume ((baz2) == "baz2")
+    assume $loc == (nil)
+    assume $glob == 99
 
-(externally $action means $body) compiles to:
+(external $body) compiles to:
     lua> ("
-        local lua = \(\($action means $body) as lua)
-        lua:remove_free_vars({\$action:get_stub():as_lua_id()})
+        local lua = \($body as lua)
+        lua:remove_free_vars()
         return lua
     ")
 
-(externally $actions all mean $body) compiles to:
+test:
+    [$x, $y] = ["outer", "outer"]
+    external:
+        (set external x local y) means:
+            with external [$x]:
+                $x = "inner"
+                $y = "inner"
+    set external x local y
+    unless (($x == "inner") and ($y == "outer")):
+        fail "'with external' failed."
+
+(with external $externals $body) compiles to:
     lua> ("
-        local lua = \(\($actions all mean $body) as lua)
-        lua:remove_free_vars(table.map(\$actions, function(a) return a:get_stub():as_lua_id() end))
-        return lua
+        local body_lua = \($body as lua)
+        local varnames = {}
+        for i,\$v in ipairs(\$externals) do
+            varnames[i] = \($v as lua):text()
+        end
+        body_lua:remove_free_vars(varnames)
+        return body_lua
     ")
 
 test:
@@ -239,8 +251,8 @@ test:
                 if replacements[t:as_var()] then
                     return replacements[t:as_var()]
                 else
-                    return "SyntaxTree{mangle("..t:as_var():as_lua().."), type="..t.type:as_lua()..", \
-        ..source="..tostring(t.source):as_lua().."}"
+                    return "SyntaxTree{mangle("..t:as_var():as_lua().."), type="..t.type:as_lua(\
+        ..)..", source="..tostring(t.source):as_lua().."}"
                 end
             elseif SyntaxTree:is_instance(t) then
                 local ret = {}
@@ -274,34 +286,37 @@ test:
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [$action parses as $body] all parse as ([$action] all parse as $body)
-externally (in (nomsu environment) $tree as lua expr) means:
-    lua> ("
-        local tree_lua = \(nomsu environment):compile(\$tree)
-        if \$tree.type == 'Block' then
-            tree_lua = LuaCode:from(\$tree.source, '(function()\\n    ', tree_lua, '\\nend)()')
-        elseif \$tree.type == 'MethodCall' and #\$tree > 2 then
-            compile_error_at(\$tree, "This must be a single value instead of "..(#\$tree - 1).."\
-        .. method calls.",
-                "Replace this with a single method call.")
-        end
-        return tree_lua
-    ")
+external:
+    (in (nomsu environment) $tree as lua expr) means:
+        lua> ("
+            local tree_lua = \(nomsu environment):compile(\$tree)
+            if \$tree.type == 'Block' then
+                tree_lua = LuaCode:from(\$tree.source, '(function()\\n    ', tree_lua, '\\nend)()')
+            elseif \$tree.type == 'MethodCall' and #\$tree > 2 then
+                compile_error_at(\$tree, "This must be a single value instead of "..(#\$tree - 1).."\
+            .. method calls.",
+                    "Replace this with a single method call.")
+            end
+            return tree_lua
+        ")
 
 # Need to make sure the proper environment is used for compilation (i.e. the caller's environment)
-($tree as lua expr) compiles to (\(in \(nomsu environment) $tree as lua expr) as lua)
+($tree as lua expr) compiles to
+    \(in \(nomsu environment) $tree as lua expr) as lua
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-externally [$var as lua identifier, $var as lua id] all mean:
-    lua> ("
-        local lua = \($var as lua)
-        if not lua:text():is_a_lua_id() then
-            compile_error(\$var,
-                "This is supposed to be something that compiles to a valid Lua identifier.",
-                "This should probably be a variable.")
-        end
-        return lua
-    ")
+external:
+    [$var as lua identifier, $var as lua id] all mean:
+        lua> ("
+            local lua = \($var as lua)
+            if not lua:text():is_a_lua_id() then
+                compile_error(\$var,
+                    "This is supposed to be something that compiles to a valid Lua identifier.",
+                    "This should probably be a variable.")
+            end
+            return lua
+        ")
 
 test:
     (num args (*extra arguments*)) means (select "#" (*extra arguments*))
@@ -312,11 +327,10 @@ test:
     assume (third arg 5 6 7 8) == 7
 
 (*extra arguments*) compiles to "..."
-
 ($ is syntax tree) compiles to "SyntaxTree:is_instance(\($ as lua expr))"
-
-externally ($ is $kind syntax tree) means
-    =lua "SyntaxTree:is_instance(\$) and \$.type == \$kind"
+external:
+    ($ is $kind syntax tree) means
+        =lua "SyntaxTree:is_instance(\$) and \$.type == \$kind"
 
 ($tree with $t -> $replacement) compiles to ("
     \($tree as lua expr):map(function(\($t as lua expr))
@@ -329,14 +343,15 @@ externally ($ is $kind syntax tree) means
     end)
 ")
 
-externally ($tree with vars $replacements) means
-    =lua ("
-        \$tree:map(function(\$t)
-            if \$t.type == "Var" then
-                return \$replacements[\$t:as_var()]
-            end
-        end)
-    ")
+external:
+    ($tree with vars $replacements) means
+        =lua ("
+            \$tree:map(function(\$t)
+                if \$t.type == "Var" then
+                    return \$replacements[\$t:as_var()]
+                end
+            end)
+        ")
 
 (tree $tree with vars $replacements) compiles to ("
     \(=lua "(\$tree):as_lua()"):map(function(t)
@@ -355,24 +370,25 @@ externally ($tree with vars $replacements) means
     end)()
 ")
 
-externally (match $tree with $patt) means:
-    lua> ("
-        if \$patt.type == "Var" then return Dict{[\$patt:as_var()]=\$tree} end
-        if \$patt.type == "Action" and \$patt:get_stub() ~= \$tree:get_stub() then return nil end
-        if #\$patt ~= #\$tree then return nil end
-        local matches = Dict{}
-        for \($i)=1,#\$patt do
-            if SyntaxTree:is_instance(\$tree[\$i]) then
-                local submatch = \(match $tree.$i with $patt.$i)
-                if not submatch then return nil end
-                for k,v in pairs(submatch) do
-                    if matches[k] and matches[k] ~= v then return nil end
-                    matches[k] = v
+external:
+    (match $tree with $patt) means:
+        lua> ("
+            if \$patt.type == "Var" then return Dict{[\$patt:as_var()]=\$tree} end
+            if \$patt.type == "Action" and \$patt:get_stub() ~= \$tree:get_stub() then return nil end
+            if #\$patt ~= #\$tree then return nil end
+            local matches = Dict{}
+            for \($i)=1,#\$patt do
+                if SyntaxTree:is_instance(\$tree[\$i]) then
+                    local submatch = \(match $tree.$i with $patt.$i)
+                    if not submatch then return nil end
+                    for k,v in pairs(submatch) do
+                        if matches[k] and matches[k] ~= v then return nil end
+                        matches[k] = v
+                    end
                 end
             end
-        end
-        return matches
-    ")
+            return matches
+        ")
 
 test:
     assume
@@ -390,20 +406,20 @@ test:
     assume ({} is a "Dict")
     assume ("" is text)
     assume ("" isn't a "Dict")
-externally ($ is text) means (=lua "\(lua type of $) == 'string'")
-externally [$ is not text, $ isn't text] all mean
-    =lua "\(lua type of $) ~= 'string'"
 
-externally (type of $) means:
-    lua> ("
-        local lua_type = \(lua type of $)
-        if lua_type == 'string' then return 'Text'
-        elseif lua_type == 'table' or lua_type == 'userdata' then
-            local mt = getmetatable(\$)
-            if mt and mt.__type then return mt.__type end
-        end
-        return lua_type
-    ")
+external:
+    ($ is text) means (=lua "\(lua type of $) == 'string'")
+    [$ is not text, $ isn't text] all mean (=lua "\(lua type of $) ~= 'string'")
+    (type of $) means:
+        lua> ("
+            local lua_type = \(lua type of $)
+            if lua_type == 'string' then return 'Text'
+            elseif lua_type == 'table' or lua_type == 'userdata' then
+                local mt = getmetatable(\$)
+                if mt and mt.__type then return mt.__type end
+            end
+            return lua_type
+        ")
 
 [$ is a $type, $ is an $type] all parse as ((type of $) == $type)
 [$ isn't a $type, $ isn't an $type, $ is not a $type, $ is not an $type]
@@ -441,19 +457,24 @@ test:
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-#
-    (with local compile actions $body) compiles to ("
-        do
-            local OLD_RULES = COMPILE_RULES
-            local OLD_ENV = \(nomsu environment)
-            local \(nomsu environment) = setmetatable({
-                COMPILE_RULES=setmetatable({}, {__index=OLD_RULES})
-            }, {__index=OLD_ENV})
-            \($body as lua)
-        end
+test:
+    using compile rules:
+        (yes) compiles to "3"
+        assume $(COMPILE RULES).yes
+    ..do:
+        assume (yes) == 3
+    assume (yes) == (=lua "true")
+
+(using compile rules $rules do $body) compiles to:
+    lua> ("
+        local env = \(new environment)
+        env:run(\$rules)
+        local lua = env:compile(\$body)
+        return lua
     ")
 
-externally (Nomsu version) means:
-    return ("
-        \(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)
-    ")
+external:
+    (Nomsu version) means:
+        return ("
+            \(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)
+        ")

lib/core/operators.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file contains definitions of operators like "+" and "and".
     
@@ -77,34 +77,6 @@ test:
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-test:
-    [$foozle, $y] = ["outer", "outer"]
-    externally (set global x local y) means:
-        external $foozle = "inner"
-        $y = "inner"
-    set global x local y
-    unless (($foozle == "inner") and ($y == "outer")): fail "external failed."
-(external $var = $value) compiles to:
-    $lua = ((SyntaxTree {.type = "Action", .source = $var.source} $var "=" $value) as lua)
-    $lua, remove free vars
-    return $lua
-test:
-    [$foozle, $y] = ["outer", "outer"]
-    externally (set global x local y) means:
-        with external [$foozle]:
-            $foozle = "inner"
-            $y = "inner"
-    set global x local y
-    unless (($foozle == "inner") and ($y == "outer")):
-        fail "'with external' failed."
-
-(with external $externs $body) compiles to:
-    $body_lua = ($body as lua)
-    lua> ("
-        \$body_lua:remove_free_vars(table.map(\$externs, function(v) return \(nomsu environment):compile(v):text() end))
-    ")
-    return $body_lua
-
 test:
     [$x, $y] = [1, 2]
     with [$z, $x = 999]:
@@ -156,7 +128,8 @@ test:
 test:
     $calls = 0
     (one) means:
-        external $calls = ($calls + 1)
+        external:
+            $calls = ($calls + 1)
         return 1
     
     unless (0 <= (one) <= 2):

lib/core/text.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file contains some definitions of text escape sequences, including ANSI console
     color codes.
@@ -34,7 +34,6 @@ test:
             
         "), lines
     ..== ["one", "two", ""]
-    
     ($spec とは $body) parses as ($spec means $body)
 
 test:
@@ -61,16 +60,18 @@ test:
 test:
     assume (0xDEADBEEF as hex) == "0xDEADBEEF"
 
-externally ($num as hex) means:
-    if ($num < 0):
-        return ("-0x%X", formatted with (- $num))
-    ..else:
-        return ("0x%X", formatted with $num)
+external:
+    ($num as hex) means:
+        if ($num < 0):
+            return ("-0x%X", formatted with (- $num))
+        ..else:
+            return ("0x%X", formatted with $num)
 
 # Text literals
 $escapes = {
-    .nl = "\n", .newline = "\n", .tab = "\t", .bell = "\a", .cr = "\r", ."carriage return" = "\r"
-    .backspace = "\b", ."form feed" = "\f", .formfeed = "\f", ."vertical tab" = "\v"
+    .nl = "\n", .newline = "\n", .tab = "\t", .bell = "\a", .cr = "\r"
+    ."carriage return" = "\r", .backspace = "\b", ."form feed" = "\f"
+    .formfeed = "\f", ."vertical tab" = "\v"
 }
 
 for $name = $str in $escapes:

lib/file_hash/init.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines some actions for hashing files and looking up files by hash.
     
@@ -32,9 +32,10 @@ test:
         assume ((hash "hello world") == "Kq5sNclPz7QV2+lfQIuc6R7oRu0=")
 
 if $use_sha1:
-    externally (hash $) means:
-        $hash = (=lua "\$hashlib.new('sha1'):final(\$)")
-        return (base64 $hash)
+    external:
+        (hash $) means:
+            $hash = (=lua "\$hashlib.new('sha1'):final(\$)")
+            return (base64 $hash)
 ..else:
     # TODO: remove warning?
     say ("
@@ -42,19 +43,20 @@ if $use_sha1:
         ..hash function.\027[0m
     ")
     
-    externally (hash $) means:
-        $bytes = ($, bytes)
-        $hash = ($bytes.1 << 7)
-        for $i in 2 to (size of $bytes):
-            $hash = ((1000003 * $hash) ~ $bytes.$i)
-        $hash = ($hash ~ (size of $bytes))
-        return "\$hash"
+    external:
+        (hash $) means:
+            $bytes = ($, bytes)
+            $hash = ($bytes.1 << 7)
+            for $i in 2 to (size of $bytes):
+                $hash = ((1000003 * $hash) ~ $bytes.$i)
+            $hash = ($hash ~ (size of $bytes))
+            return "\$hash"
 
-externally (file with hash $hash) means:
-    for $filename in (files for "."):
-        $contents = (read file $filename)
-        $file_hash = (hash $contents)
-        if ($file_hash == $hash):
-            return $filename
-
-(hash of file $filename) parses as (hash (read file $filename))
+external:
+    (file with hash $hash) means:
+        for $filename in (files for "."):
+            $contents = (read file $filename)
+            $file_hash = (hash $contents)
+            if ($file_hash == $hash):
+                return $filename
+    (hash of file $filename) parses as (hash (read file $filename))

lib/filesystem/init.nom

@@ -1,36 +1,36 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines some actions that interact with the filesystem.
     
-externally (files for $path) means:
-    $files = (=lua "Files.list(\$path)")
-    if $files:
-        $files = (List $files)
-    return $files
+external:
+    (files for $path) means:
+        $files = (=lua "Files.list(\$path)")
+        if $files:
+            $files = (List $files)
+        return $files
+    $(read file $filename) = $Files.read
+    [
+        write to file $filename $text, to file $filename write $text
+        write $text to file $filename
+    ] all mean:
+        unless ($filename != "stdin"):
+            fail "Cannot write to stdin"
         
-external $(read file $filename) = $Files.read
-externally [
-    write to file $filename $text, to file $filename write $text
-    write $text to file $filename
-] all mean:
-    unless ($filename != "stdin"):
-        fail "Cannot write to stdin"
+        lua> ("
+            local file = io.open(\$filename, 'w')
+            file:write(\$text)
+            file:close()
+        ")
     
-    lua> ("
-        local file = io.open(\$filename, 'w')
-        file:write(\$text)
-        file:close()
-    ")
+    (source lines of $tree) means:
+        $source = ($tree.source if ($tree is syntax tree) else $tree)
+        $file = (read file $source.filename)
+        return
+            [
+                : for $ in ($file, line number at $source.start) to
+                    $file, line number at $source.stop
+                ..: add ($file, line $)
+            ], joined with "\n"
     
-externally (source lines of $tree) means:
-    $source = ($tree.source if ($tree is syntax tree) else $tree)
-    $file = (read file $source.filename)
-    return
-        [
-            : for $ in ($file, line number at $source.start) to
-                $file, line number at $source.stop
-            ..: add ($file, line $)
-        ], joined with "\n"
-
-external $(spoof file $text) = $Files.spoof
-external $(spoof file $filename = $text) = $Files.spoof
+    $(spoof file $text) = $Files.spoof
+    $(spoof file $filename = $text) = $Files.spoof

lib/object.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file contains the implementation of an Object-Oriented programming system.
     

lib/progressbar/init.nom

@@ -1,16 +1,12 @@
+#!/usr/bin/env nomsu -V6.15.13.8
 # A progress bar
     
-externally ($x / $w progress bar) means:
-    $x = ($x clamped between 0 and $w)
-    $bits = [" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"]
-    $middle =
-        "" if ($x == $w) else
-            $bits.(1 + (floor ((#$bits) * ($x mod 1))))
-    
-    return ("
-        \027[32;40m\($bits, last, rep (floor $x))\$middle\
-        ..\(" ", rep ($w - ((floor $x) + 1)))\027[0m
-    ")
-    
-externally ($w wide $ progress bar) means
-    ($ * $w) / $w progress bar
+external:
+    ($x / $w progress bar) means:
+        $x = ($x clamped between 0 and $w)
+        $bits = [" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"]
+        $middle = ("" if ($x == $w) else $bits.(1 + (floor ((#$bits) * ($x mod 1)))))
+        return ("
+            \027[32;40m\($bits, last, rep (floor $x))\$middle\(" ", rep ($w - ((floor $x) + 1)))\027[0m
+        ")
+    ($w wide $ progress bar) means (($ * $w) / $w progress bar)

lib/shell/init.nom

@@ -1,12 +1,12 @@
 #
     This file defines some actions for running shell commands.
     
-externally (=sh $cmd) means:
-    lua> ("
-        local result = io.popen(\$cmd)
-        local contents = result:read("*a")
-        result:close()
-        return contents
-    ")
-
-external $(sh> $) = $os.execute
+external:
+    (=sh $cmd) means:
+        lua> ("
+            local result = io.popen(\$cmd)
+            local contents = result:read("*a")
+            result:close()
+            return contents
+        ")
+    $(sh> $) = $os.execute

lib/things.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     A library for simple object oriented programming.
     
@@ -91,67 +91,70 @@ $METAMETHOD_MAP = {
 }
 
 $($ as text like a dict) = ({}'s metatable).__tostring
-externally (a class named $classname with $members $(initialize $)) means:
-    $class = {.__type = $classname}
-    $class.__index = $class
-    $class.class = $class
-    $class.__tostring = ($ -> "\($.__type) \($ as text like a dict)")
-    $class.__eq = ({}'s metatable).__eq
-    $class.__len = ({}'s metatable).__len
-    if $members:
-        $class.__members = $members
-        $class.__newindex =
-            for ($its $key = $value):
-                if $members.$key:
-                    rawset $its $key $value
-                ..else:
-                    fail "Cannot set \$key, it's not one of the allowed member fields."
+external:
+    (a class named $classname with $members $(initialize $)) means:
+        $class = {.__type = $classname}
+        $class.__index = $class
+        $class.class = $class
+        $class.__tostring = ($ -> "\($.__type) \($ as text like a dict)")
+        $class.__eq = ({}'s metatable).__eq
+        $class.__len = ({}'s metatable).__len
+        if $members:
+            $class.__members = $members
+            $class.__newindex =
+                for ($its $key = $value):
+                    if $members.$key:
+                        rawset $its $key $value
+                    ..else:
+                        fail "Cannot set \$key, it's not one of the allowed member fields."
         
-    set $class's metatable to {
-        .__tostring = ($class -> $class.__type)
-        .__call =
-            for ($class with $initial_values):
-                if ($initial_values == (nil)): return $class
-                set $initial_values's metatable to $class
-                if $initial_values.set_up:
-                    $initial_values, set up
-                return $initial_values
-    }
+        set $class's metatable to {
+            .__tostring = ($class -> $class.__type)
+            .__call =
+                for ($class with $initial_values):
+                    if ($initial_values == (nil)): return $class
+                    set $initial_values's metatable to $class
+                    if $initial_values.set_up:
+                        $initial_values, set up
+                    return $initial_values
+        }
         
-    if $(initialize $):
-        initialize $class
-        for $stub = $metamethod in $METAMETHOD_MAP:
-            if $class.($stub, as lua id):
-                $class.$metamethod = $class.($stub, as lua id)
+        if $(initialize $):
+            initialize $class
+            for $stub = $metamethod in $METAMETHOD_MAP:
+                if $class.($stub, as lua id):
+                    $class.$metamethod = $class.($stub, as lua id)
         
-    return $class
+        return $class
     
-[
-    a $classname is a thing with $members $class_body
-    an $classname is a thing with $members $class_body
-] all compile to:
-    $class_id = ($classname.stub, as lua id)
-    if $class_body:
-        $body_lua = ($class_body as lua)
-        $body_lua, remove free vars [$class_id]
-        $body_lua, declare locals
+    [
+        a $classname is a thing with $members $class_body
+        an $classname is a thing with $members $class_body
+    ] all compile to:
+        $class_id = ($classname.stub, as lua id)
+        if $class_body:
+            $body_lua = ($class_body as lua)
+            $body_lua, remove free vars [$class_id]
+            $body_lua, declare locals
         
-    return
-        Lua ("
-            \$class_id = a_class_named_1_with(\(quote $classname.stub), \($members as lua)\(
-                (
-                    Lua ("
-                        , function(\$class_id)
-                            local it, its = \$class_id, \$class_id;
-                            \$body_lua
-                        end
-                    ")
-                ) if $class_body else ""
-            ))
-            a_\$class_id = function(initial_values) return \($classname.stub, as lua id)(initial_values \
-            ..or {}) end
-            an_\$class_id, a_\($class_id)_with, an_\($class_id)_with = a_\$class_id, a_\$class_id, a_\$class_id
-        ")
+        $lua =
+            Lua ("
+                \$class_id = a_class_named_1_with(\(quote $classname.stub), \($members as lua)\(
+                    (
+                        Lua ("
+                            , function(\$class_id)
+                                local it, its = \$class_id, \$class_id;
+                                \$body_lua
+                            end
+                        ")
+                    ) if $class_body else ""
+                ))
+                a_\$class_id = function(initial_values) return \($classname.stub, as lua id)(initial_values or {}) end
+                an_\$class_id, a_\($class_id)_with, an_\($class_id)_with = a_\$class_id, a_\$class_id, a_\$class_id
+            ")
         
-[a $classname is a thing $class_body, an $classname is a thing] all parse as
-    a $classname is a thing with (nil) $class_body
+        $lua, add free vars [$class_id, "a_\$class_id", "an_\$class_id"]
+        return $lua
+    
+    [a $classname is a thing $class_body, an $classname is a thing] all parse as
+        a $classname is a thing with (nil) $class_body

lib/tools/find.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This is a tool to find syntax trees matching a pattern. "*" is a wildcard
     that will match any subtree, and "**" is a wildcard that will match any
@@ -79,7 +79,11 @@ command line program with $args:
             if ($t matches $pattern_tree):
                 $line_num = ($file, line number at $t.source.start)
                 $results, add {
-                    .line = $line_num, .text = "\(blue "\$filename:\$line_num:")\n\(source lines of $t)"
+                    .line = $line_num
+                    .text = ("
+                        \(blue "\$filename:\$line_num:")
+                        \(source lines of $t)
+                    ")
                 }
             
             for $sub in $t:

lib/tools/format.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     Auto-format Nomsu code. Usage:
     nomsu -t format [-i] file1 file2...

lib/tools/parse.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     Tool to print out a parse tree of files in an easy-to-read format. Usage:
     nomsu tools/parse.nom file1 file2 directory1 ...        
@@ -8,7 +8,7 @@ use "commandline"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-externally (print tree $t at indent $indent) means:
+(print tree $t at indent $indent) means:
     if $t.type is:
         "Action":
             say "\($indent)Action (\($t.stub)):"

lib/tools/repl.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This file defines a Read-Evaluate-Print-Loop (REPL) for Nomsu
     
@@ -8,12 +8,13 @@ use "commandline"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-externally (help) means:
-    say ("
-        This is the Nomsu v\(Nomsu version) interactive console.
-        You can type in Nomsu code here and hit 'enter' twice to run it.
-        To exit, type 'exit' or 'quit' and hit enter twice.
-    ")
+external:
+    (help) means:
+        say ("
+            This is the Nomsu v\(Nomsu version) interactive console.
+            You can type in Nomsu code here and hit 'enter' twice to run it.
+            To exit, type 'exit' or 'quit' and hit enter twice.
+        ")
 
 command line program with $args:
     say ("
@@ -38,9 +39,7 @@ command line program with $args:
                 go to (run buffer)
             $buff, add ($line, with "\t" -> "    ")
             say (dim (yellow ".. ")) inline
-        
         --- (run buffer) ---
-        
         if ((size of $buff) == 0): stop
         $buff = ($buff, joined)
         spoof file $buff

lib/tools/replace.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     This is a tool to replace syntax trees with something new.
     
@@ -95,7 +95,8 @@ command line program with $args:
             $tree = ($code parsed)
         ..if it fails with $msg:
             if $args.q:
-                unless $args.i: say $code
+                unless $args.i:
+                    say $code
             ..else:
                 say $msg
         
@@ -124,13 +125,10 @@ command line program with $args:
                                     ..\(reset color)
                                 ")
                                 say "\(bright)..be replaced with:"
-                                
                                 say ("
                                         \(bright)\(blue)\("\($ret as nomsu)", with "\n" -> "\n    ")\(reset color)
                                 ")
-                                
                                 $user_answers.$t = (ask "\(bright)..? [Y/n]\(reset color) ")
-                            
                             if ($user_answers.$t == "n"): return (nil)
                         $replaced.$t = (yes)
                         return $ret

lib/tools/test.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     Tool to run all tests in a file (i.e. the code block inside a call to 'test $'). Usage:
     nomsu tools/test.nom file1 file2 directory1 ...
@@ -14,7 +14,6 @@ command line program with $args:
         $file = (read file $filename)
         unless $file:
             fail "Couldn't find \$filename"
-
         $(test environment) = (new environment)
         $(test environment), export $filename
         $version =
@@ -24,7 +23,7 @@ command line program with $args:
                 ]*)
             ")
         $file_tests = []
-        for $src = $test in $(test environment).TESTS:
+        for $src = $test in (nomsu environment, Module $filename).TESTS:
             if $version:
                 $test = ("
                     #!/usr/bin/env nomsu -V\$version
@@ -36,20 +35,22 @@ command line program with $args:
             sort $file_tests by $ -> $.source
             say "[ .. ] \$filename" inline
             $io.flush()
-            
             if $args.v: say ""
-            
             $failures = []
             for $ in $file_tests:
                 if $args.v:
                     say "    \(yellow ($.test, with "\n" -> "\n    "))"
+                
                 try:
                     $(test environment), run $.test
                 ..if it fails with $msg:
                     $src = ($Source, from string $.source)
                     $l1 = ($file, line number at $src.start)
                     $l2 = ($file, line number at $src.stop)
-                    $failures, add "\(yellow "\($src.filename):\($l1)-\$l2:")\n\(bright (red ($msg, indented)))"
+                    $failures, add ("
+                        \(yellow "\($src.filename):\($l1)-\$l2:")
+                        \(bright (red ($msg, indented)))
+                    ")
             
             if ($failures is empty):
                 if $args.v:
@@ -62,4 +63,3 @@ command line program with $args:
                 ..else:
                     say "\r[\(red (bright "FAIL"))"
                 say "\($failures, joined with "\n", indented)"
-

lib/tools/upgrade.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V6.14
+#!/usr/bin/env nomsu -V6.15.13.8
 #
     Tool to automatically update code from old versions of Nomsu. Usage:
     nomsu tools/upgrade.nom [-i] file1 file2 directory1 ...

nomsu.lua

@@ -131,6 +131,7 @@ local NOMSU_PACKAGEPATH = NOMSU_PACKAGEPATH or "/opt/nomsu"
 add_path(NOMSU_PACKAGEPATH)
 add_path(".")
 package.nomsupath = table.concat(nomsupath, ";")
+package.nomsuloaded = Dict({ })
 local nomsu_environment = require('nomsu_environment')
 nomsu_environment.COMMAND_LINE_ARGS = nomsu_args
 nomsu_environment.OPTIMIZATION = optimization
@@ -173,6 +174,10 @@ run = function()
       nomsu_environment._1_parsed(NomsuCode:from(source, code))
       print("Parse succeeded: " .. tostring(filename))
     elseif args.compile then
+      local code = Files.read(filename)
+      if not code then
+        error("Could not find file '" .. tostring(filename) .. "'")
+      end
       if filename:match("%.lua$") then
         error("Cannot compile a lua file (expected a nomsu file as input)")
       end
@@ -182,7 +187,6 @@ run = function()
       else
         output = io.open(filename:gsub("%.nom$", ".lua"), "w")
       end
-      local code = Files.read(filename)
       local source = Source(filename, 1, #code)
       code = NomsuCode:from(source, code)
       local env = nomsu_environment.new_environment()

nomsu.moon

@@ -108,6 +108,7 @@ NOMSU_PACKAGEPATH or= "/opt/nomsu"
 add_path NOMSU_PACKAGEPATH
 add_path "."
 package.nomsupath = table.concat(nomsupath, ";")
+package.nomsuloaded = Dict{}
 
 nomsu_environment = require('nomsu_environment')
 nomsu_environment.COMMAND_LINE_ARGS = nomsu_args
@@ -141,12 +142,14 @@ run = ->
             nomsu_environment._1_parsed(NomsuCode\from(source, code))
             print("Parse succeeded: #{filename}")
         elseif args.compile
+            code = Files.read(filename)
+            if not code
+                error("Could not find file '#{filename}'")
             -- Compile .nom files into .lua
             if filename\match("%.lua$")
                 error("Cannot compile a lua file (expected a nomsu file as input)")
             output = if filename == 'stdin' then io.output()
             else io.open(filename\gsub("%.nom$", ".lua"), "w")
-            code = Files.read(filename)
             source = Source(filename, 1, #code)
             code = NomsuCode\from(source, code)
             env = nomsu_environment.new_environment!

nomsu_decompiler.lua

@@ -193,7 +193,7 @@ tree_to_inline_nomsu = function(tree)
     local target = tree[1]
     local target_nomsu = tree_to_inline_nomsu(target)
     local _exp_1 = target.type
-    if "Action" == _exp_1 or "MethodCall" == _exp_1 then
+    if "Action" == _exp_1 or "MethodCall" == _exp_1 or "EscapedNomsu" == _exp_1 then
       target_nomsu:parenthesize()
     elseif "Number" == _exp_1 then
       if target_nomsu:text():match("%.") then
@@ -498,10 +498,10 @@ tree_to_nomsu = function(tree)
             while #line > 0 do
               local space = max_line - nomsu:trailing_line_len()
               local split = find(line, "[%p%s]", space)
-              if not split or split > space + 10 then
-                split = space + 10
+              if not split or split > space + 16 then
+                split = space + 16
               end
-              if #line - split < 10 then
+              if #line - split < 16 then
                 split = #line
               end
               local bite

nomsu_decompiler.moon

@@ -147,7 +147,7 @@ tree_to_inline_nomsu = (tree)->
             target = tree[1]
             target_nomsu = tree_to_inline_nomsu(target)
             switch target.type
-                when "Action", "MethodCall"
+                when "Action", "MethodCall", "EscapedNomsu"
                     target_nomsu\parenthesize!
                 when "Number"
                     target_nomsu\parenthesize! if target_nomsu\text!\match("%.")
@@ -381,9 +381,9 @@ tree_to_nomsu = (tree)->
                             while #line > 0
                                 space = max_line - nomsu\trailing_line_len!
                                 split = find(line, "[%p%s]", space)
-                                if not split or split > space + 10
-                                    split = space + 10
-                                if #line - split < 10
+                                if not split or split > space + 16
+                                    split = space + 16
+                                if #line - split < 16
                                     split = #line
                                 bite, line = sub(line, 1, split), sub(line, split+1, -1)
                                 nomsu\add bite

nomsu_environment.lua

@@ -99,7 +99,6 @@ nomsu_environment = Importer({
   tostring = tostring,
   string = string,
   xpcall = xpcall,
-  module = module,
   say = print,
   loadfile = loadfile,
   rawset = rawset,
@@ -215,7 +214,7 @@ nomsu_environment = Importer({
     end
     return tree
   end,
-  load_module = function(self, package_name)
+  Module = function(self, package_name)
     local path
     if package_name:match("%.nom$") or package_name:match("%.lua") then
       path = package_name
@@ -228,7 +227,7 @@ nomsu_environment = Importer({
     end
     path = path:gsub("^%./", "")
     do
-      local ret = package.loaded[package_name] or package.loaded[path]
+      local ret = package.nomsuloaded[package_name] or package.nomsuloaded[path]
       if ret then
         return ret
       end
@@ -250,12 +249,12 @@ nomsu_environment = Importer({
     _currently_running_files:add(path)
     mod:run(code)
     _currently_running_files:pop()
-    package.loaded[package_name] = mod
-    package.loaded[path] = mod
+    package.nomsuloaded[package_name] = mod
+    package.nomsuloaded[path] = mod
     return mod
   end,
   use = function(self, package_name)
-    local mod = self:load_module(package_name)
+    local mod = self:Module(package_name)
     local imports = assert(_module_imports[self])
     for k, v in pairs(mod) do
       imports[k] = v
@@ -267,7 +266,7 @@ nomsu_environment = Importer({
     return mod
   end,
   export = function(self, package_name)
-    local mod = self:load_module(package_name)
+    local mod = self:Module(package_name)
     local imports = assert(_module_imports[self])
     for k, v in pairs(_module_imports[mod]) do
       if rawget(imports, k) == nil then
@@ -290,11 +289,6 @@ nomsu_environment = Importer({
         self.COMPILE_RULES[k] = v
       end
     end
-    for k, v in pairs(mod.TESTS) do
-      if rawget(self.TESTS, k) == nil then
-        self.TESTS[k] = v
-      end
-    end
     return mod
   end,
   run = function(self, to_run)

nomsu_environment.moon

@@ -48,7 +48,7 @@ nomsu_environment = Importer{
     :next, unpack: unpack or table.unpack, :setmetatable, :rawequal, :getmetatable, :pcall,
     yield:coroutine.yield, resume:coroutine.resume, coroutine_status_of:coroutine.status,
     coroutine_wrap:coroutine.wrap, coroutine_from: coroutine.create,
-    :error, :package, :os, :require, :tonumber, :tostring, :string, :xpcall, :module,
+    :error, :package, :os, :require, :tonumber, :tostring, :string, :xpcall,
     say:print, :loadfile, :rawset, :_VERSION, :collectgarbage, :rawget, :rawlen,
     :table, :assert, :dofile, :loadstring, lua_type_of:type, :select, :math, :io, :load,
     :pairs, :ipairs, :jit, :_VERSION
@@ -105,7 +105,7 @@ nomsu_environment = Importer{
         
         return tree
 
-    load_module: (package_name)=>
+    Module: (package_name)=>
         local path
         if package_name\match("%.nom$") or package_name\match("%.lua")
             path = package_name
@@ -114,7 +114,7 @@ nomsu_environment = Importer{
             if not path then error(err)
         path = path\gsub("^%./", "")
 
-        if ret = package.loaded[package_name] or package.loaded[path]
+        if ret = package.nomsuloaded[package_name] or package.nomsuloaded[path]
             return ret
 
         if _currently_running_files\has(path)
@@ -132,12 +132,12 @@ nomsu_environment = Importer{
         _currently_running_files\add path
         mod\run(code)
         _currently_running_files\pop!
-        package.loaded[package_name] = mod
-        package.loaded[path] = mod
+        package.nomsuloaded[package_name] = mod
+        package.nomsuloaded[path] = mod
         return mod
 
     use: (package_name)=>
-        mod = @load_module(package_name)
+        mod = @Module(package_name)
         imports = assert _module_imports[@]
         for k,v in pairs(mod)
             imports[k] = v
@@ -147,7 +147,7 @@ nomsu_environment = Importer{
         return mod
 
     export: (package_name)=>
-        mod = @load_module(package_name)
+        mod = @Module(package_name)
         imports = assert _module_imports[@]
         for k,v in pairs(_module_imports[mod])
             if rawget(imports, k) == nil
@@ -163,9 +163,9 @@ nomsu_environment = Importer{
         for k,v in pairs(mod.COMPILE_RULES)
             if rawget(@COMPILE_RULES, k) == nil
                 @COMPILE_RULES[k] = v
-        for k,v in pairs(mod.TESTS)
-            if rawget(@TESTS, k) == nil
-                @TESTS[k] = v
+        --for k,v in pairs(mod.TESTS)
+        --    if rawget(@TESTS, k) == nil
+        --        @TESTS[k] = v
         return mod
 
     run: (to_run)=>

parser.lua

@@ -96,7 +96,7 @@ make_parser = function(peg, make_tree)
       file = input
     }
     local tree = peg:match(input, nil, userdata)
-    if not tree then
+    if not tree or type(tree) == 'number' then
       error("File " .. tostring(filename) .. " failed to parse:\n" .. tostring(input))
     end
     return tree

parser.moon

@@ -74,7 +74,7 @@ make_parser = (peg, make_tree=nil)->
             :filename, file:input
         }
         tree = peg\match(input, nil, userdata)
-        if not tree
+        if not tree or type(tree) == 'number'
             error "File #{filename} failed to parse:\n#{input}"
         return tree