138 lines
5.2 KiB
Plaintext
138 lines
5.2 KiB
Plaintext
#!/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
|
|
|
|
[$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
|
|
(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!")
|
|
|
|
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 " ")
|
|
|
|
$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!")
|
|
|
|
a (Vec) is a thing with {x, 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
|
|
..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
|
|
|
|
$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)) \
|
|
..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:
|
|
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
|
|
|
|
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)
|
|
|
|
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
|
|
|
|
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 $classname is a thing $class_body, an $classname is a thing] all parse as (..)
|
|
a $classname is a thing with (nil) $class_body
|