Auto-updated to version 5

1 files changed, 96 insertions, 99 deletions

diff --git a/lib/things.nom b/lib/things.nom
index c7ff2d6..de51683 100644
--- a/lib/things.nom
+++ b/lib/things.nom
@@ -1,140 +1,137 @@
-#!/usr/bin/env nomsu -V4.12.12.8
+#!/usr/bin/env nomsu -V5.12.12.8
 #
     A library for simple object oriented programming.
     
 test:
     an (Empty) is a thing
     a (Dog) is a thing:
-        [%it, %its] = [Dog, Dog]
-        (%its::set up) means:
-            %its.barks or= 0
+        [$it, $its] = [Dog, Dog]
+        ($its|set up) means:
+            $its.barks or= 0
         
-        [%its::bark, %its::woof] all mean:
-            %barks = [: for % in 1 to %its.barks: add "Bark!"]
-            return (%barks::joined with " ")
+        [$its|bark, $its|woof] all mean:
+            $barks = [: for $ in 1 to $its.barks: add "Bark!"]
+            return ($barks|joined with " ")
         
-        (%it::gets pissed off) means: %it.barks += 1
+        ($it|gets pissed off) means: $it.barks += 1
     (Dog).genus = "Canus"
-    %d = (a Dog with {barks: 2})
-    assume "\%d" == "Dog {barks: 2}"
-    assume (type of %d) == "Dog"
-    assume (%d is a "Dog")
-    assume %d.barks == 2
-    assume ((%d::bark) == "Bark! Bark!")
-    assume ((%d::woof) == "Bark! Bark!")
-    %d::gets pissed off
-    assume (%d.barks == 3)
-    assume ((%d::bark) == "Bark! Bark! Bark!")
-    assume (%d.genus == "Canus")
-    assume ("\(%d.class)" == "Dog")
-    assume (%d.genus == "Canus")
-    assume (%d.barks == 3)
-    %d2 = (a Dog)
-    assume (%d2.barks == 0) or barf "Default initializer failed"
-    with {%d: a Dog with {barks: 1}}:
-        assume ((%d::bark) == "Bark!")
+    $d = (a Dog with {barks: 2})
+    assume "\$d" == "Dog {barks: 2}"
+    assume (type of $d) == "Dog"
+    assume ($d is a "Dog")
+    assume $d.barks == 2
+    assume (($d|bark) == "Bark! Bark!")
+    assume (($d|woof) == "Bark! Bark!")
+    $d|gets pissed off
+    assume ($d.barks == 3)
+    assume (($d|bark) == "Bark! Bark! Bark!")
+    assume ($d.genus == "Canus")
+    assume ("\($d.class)" == "Dog")
+    assume ($d.genus == "Canus")
+    assume ($d.barks == 3)
+    $d2 = (a Dog)
+    assume ($d2.barks == 0) or barf "Default initializer failed"
+    with {$d: a Dog with {barks: 1}}:
+        assume (($d|bark) == "Bark!")
     
     a (Corgi) is a thing:
-        [%it, %its] = [Corgi, Corgi]
-        %it [set up, gets pissed off] like a (Dog)
-        (%it::as text) means "Dogloaf \{: for %k = %v in %it: add %k = %v}"
-        (%its::sploot) means "sploooot"
-        [%its::bark, %its::woof] all mean:
-            %barks = [: for % in 1 to %its.barks: add "Yip!"]
-            return (%barks::joined with " ")
+        [$it, $its] = [Corgi, Corgi]
+        $it [set up, gets pissed off] like a (Dog)
+        ($it|as text) means "Dogloaf \{: for $k = $v in $it: add $k = $v}"
+        ($its|sploot) means "sploooot"
+        [$its|bark, $its|woof] all mean:
+            $barks = [: for $ in 1 to $its.barks: add "Yip!"]
+            return ($barks|joined with " ")
     
-    %corg = (a Corgi)
-    assume (%corg.barks == 0)
-    assume "\%corg" == "Dogloaf {barks: 0}"
-    with {%d: a Corgi with {barks: 1}}:
-        assume ((%d::sploot) == "sploooot") or barf "subclass method failed"
-        assume ((%d::bark) == "Yip!") or barf "inheritance failed"
-        assume ((%d::woof) == "Yip!")
+    $corg = (a Corgi)
+    assume ($corg.barks == 0)
+    assume "\$corg" == "Dogloaf {barks: 0}"
+    with {$d: a Corgi with {barks: 1}}:
+        assume (($d|sploot) == "sploooot") or barf "subclass method failed"
+        assume (($d|bark) == "Yip!") or barf "inheritance failed"
+        assume (($d|woof) == "Yip!")
     
-    with {%d: a Dog with {barks: 2}}:
-        assume ((%d::bark) == "Bark! Bark!")
+    with {$d: a Dog with {barks: 2}}:
+        assume (($d|bark) == "Bark! Bark!")
     
     a (Vec) is a thing with {x, y}:
-        %its = (Vec)
-        (%its::+ %other) means (Vec {x: %its.x + %other.x, y: %its.y + %other.y})
+        $its = (Vec)
+        ($its|+ $other) means (Vec {x: $its.x + $other.x, y: $its.y + $other.y})
     
     assume ((Vec {x: 1, y: 2}) + (Vec {x: 10, y: 10})) == (Vec {x: 11, y: 12})
     assume (((Vec {x: 1, y: 2}) + (Vec {x: 10, y: 10})) != (Vec {x: 0, y: 0}))
 
 [..]
-    %it can %actions like a %class, %it can %actions like an %class
-    %it has %actions like a %class, %it has %actions like an %class
-    %it %actions like a %class, %it %actions like an %class
+    $it can $actions like a $class, $it can $actions like an $class
+    $it has $actions like a $class, $it has $actions like an $class
+    $it $actions like a $class, $it $actions like an $class
 ..all compile to:
-    %lua = (Lua "")
-    %class_expr = (%class as lua expr)
-    %lines = []
-    for %a in %actions:
-        %lines::add "\
-            ..\(%it as lua expr).\(%a.stub::as lua id) = \%class_expr.\(%a.stub::as lua id)"
-    %lua::add %lines joined with "\n"
-    return %lua
+    $lua = (Lua "")
+    $class_expr = ($class as lua expr)
+    $lines = []
+    for $a in $actions:
+        $lines|
+            add "\($it as lua expr).\($a.stub|as lua id) = \$class_expr.\($a.stub|as lua id)"
+    $lua|add $lines joined with "\n"
+    return $lua
 
-%METAMETHOD_MAP = {..}
+$METAMETHOD_MAP = {..}
     "as text": "__tostring", "clean up": "__gc", "+": "__add", "-": "__sub"
     "*": "__mul", "/": "__div", negative: "__unm", "//": "__idiv", mod: "__mod"
     "^": "__pow", "&": "__band", "|": "__bor", "~": "__bxor", "~": "__bnot"
     "<<": "__bshl", ">>": "__bshr", "==": "__eq", "<": "__lt", "<=": "__le"
     "set 1 =": "__newindex", size: "__len", iterate: "__ipairs", "iterate all": "__pairs"
 
-((% as text like a dict)'s meaning) = ({}'s metatable).__tostring
-externally (a class named %classname with %members ((initialize %it)'s meaning)) \
+(($ as text like a dict)'s meaning) = ({}'s metatable).__tostring
+externally (a class named $classname with $members ((initialize $it)'s meaning)) \
 ..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
+    $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:
-                    barf "Cannot set \%key, it's not one of the allowed member fields."
+                    barf "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)'s meaning):
-        initialize %class
-        for %stub = %metamethod in %METAMETHOD_MAP:
-            if %class.(%stub::as lua id):
-                %class.%metamethod = %class.(%stub::as lua id)
+        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
+    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
+    $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)\n    \%body_lua\nend") if %class_body else ""
+        Lua "
+            \$class_id = a_class_named_1_with(\(quote $classname.stub), \($members as lua)\((Lua ", function(\$class_id)\n    \$body_lua\nend") 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_\$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
+[a $classname is a thing $class_body, an $classname is a thing] all parse as (..)
+    a $classname is a thing with (nil) $class_body