From 8a3c32408733a2f5e14f8a2dbafa3f980b2f73a1 Mon Sep 17 00:00:00 2001 From: Bruce Hill Date: Sun, 30 Dec 2018 19:04:34 -0800 Subject: Update to new syntax. --- lib/things.nom | 128 +++++++++++++++++++++++++++++++-------------------------- 1 file changed, 69 insertions(+), 59 deletions(-) (limited to 'lib/things.nom') diff --git a/lib/things.nom b/lib/things.nom index de51683..e10b9eb 100644 --- a/lib/things.nom +++ b/lib/things.nom @@ -1,4 +1,4 @@ -#!/usr/bin/env nomsu -V5.12.12.8 +#!/usr/bin/env nomsu -V6.12.12.8 # A library for simple object oriented programming. @@ -6,86 +6,91 @@ test: an (Empty) is a thing a (Dog) is a thing: [$it, $its] = [Dog, Dog] - ($its|set up) means: + ($its, set up) means: $its.barks or= 0 - [$its|bark, $its|woof] all mean: + [($its, bark), ($its, woof)] all mean: $barks = [: for $ in 1 to $its.barks: add "Bark!"] - return ($barks|joined with " ") + 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}) + $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, bark) == "Bark! Bark!") + assume (($d, woof) == "Bark! Bark!") + $d, gets pissed off assume ($d.barks == 3) - assume (($d|bark) == "Bark! Bark! Bark!") + 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!") + 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: + ($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 " ") + 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!") + 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}: + 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, + $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})) + 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 -..all compile to: +] 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" + $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 = {..} - "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" +$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)) \ +externally (a class named $classname with $members ((initialize $it)'s meaning)) ..means: - $class = {__type: $classname} + $class = {.__type = $classname} $class.__index = $class $class.class = $class $class.__tostring = ($ -> "\($.__type) \($ as text like a dict)") @@ -93,45 +98,50 @@ externally (a class named $classname with $members ((initialize $it)'s meaning)) $class.__len = ({}'s metatable).__len if $members: $class.__members = $members - $class.__newindex = (..) + $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." - 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) + if $class.($stub, as lua id): + $class.$metamethod = $class.($stub, as lua id) 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) +] 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 + $body_lua, remove free vars [$class_id] + $body_lua, declare locals - return (..) - Lua " + 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 "")\ ..) - 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 $class_body, an $classname is a thing] all parse as a $classname is a thing with (nil) $class_body -- cgit v1.2.3