Bruce/nomsu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fully upgraded to 4.10.12.7, including deprecating the old list/dict

Browse Source 
comprehension methods, in favor of the new native support.
This commit is contained in:
Bruce Hill 2018-11-11 15:50:46 -08:00
parent ba03cb67c3
commit 4efe44ed27
41 changed files with 638 additions and 666 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compatibility/2.3.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines upgrades from Nomsu <2.3 to Nomsu 2.3
use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

37
compatibility/2.4.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines upgrades from Nomsu <2.4 to Nomsu 2.4
use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -10,60 +10,65 @@ upgrade %tree to "2.4" as:
unless (%tree is "Action" syntax tree): return
if %tree.stub is:
"when" "if":
if ((size of %tree) == 3):
return %tree
if ((size of %tree) == 3): return %tree
%conditions = []
%new_lines = []
%body = (..)
(%tree.2 upgraded) if (%tree.2 is "Block" syntax tree) else [%tree.2 upgraded]
%body = ((%tree.2 upgraded) if (%tree.2 is "Block" syntax tree) else [%tree.2 upgraded])
for %line in %body:
when:
(not (%line is "Action" syntax tree)):
%new_lines::add %line
(%line.stub is "*"):
if ((size of %line) == 2):
%conditions::add %line.2
..else:
%new_lines::add %line
(%line.stub == "* else"):
%new_lines::add (\(else %block) with vars {block:%line.3})
%new_lines::add (\(else %block) with vars {block: %line.3})
else:
%conditions::add %line.2
%action = %line.3
unless (%action is "Block" syntax tree):
%action = (=lua "SyntaxTree{type='Block', source=\%action.source, \%action}")
%conditions::add %action
%new_lines::add (=lua "SyntaxTree{type='Action', source=\%conditions[1].source, unpack(\%conditions)}")
%new_lines::add (..)
=lua "SyntaxTree{type='Action', source=\%conditions[1].source, unpack(\%conditions)}"
%conditions = []
return (..)
\(when %body) with vars {body:=lua "SyntaxTree{type='Block', source=\%tree[2].source, unpack(\%new_lines)}"}
\(when %body) with vars {..}
body: =lua "SyntaxTree{type='Block', source=\%tree[2].source, unpack(\%new_lines)}"
"if 1 is ?" "if 1 = ?":
%values = []
%new_lines = []
%body = (..)
(%tree.5 upgraded) if (%tree.5 is "Block" syntax tree) else [%tree.5 upgraded]
%body = ((%tree.5 upgraded) if (%tree.5 is "Block" syntax tree) else [%tree.5 upgraded])
for %line in %body:
when:
(not (%line is "Action" syntax tree)):
%new_lines::add %line
(%line.stub is "*"):
if ((size of %line) == 2):
%values::add %line.2
..else:
%new_lines::add %line
(%line.stub == "* else"):
%new_lines::add (\(else %block) with vars {block:%line.3})
%new_lines::add (\(else %block) with vars {block: %line.3})
else:
%values::add %line.2
%action = %line.3
unless (%action is "Block" syntax tree):
%action = \(: %action)
unless (%action is "Block" syntax tree): %action = \(: %action)
%values::add %action
%new_lines::add (=lua "SyntaxTree{type='Action', source=\%values[1].source, unpack(\%values)}")
%new_lines::add (..)
=lua "SyntaxTree{type='Action', source=\%values[1].source, unpack(\%values)}"
%values = []
return (..)
\(if %var is %body) with vars {..}
var:%tree.2 upgraded, body:=lua "SyntaxTree{type='Block', source=\%tree[5].source, unpack(\%new_lines)}"
var: %tree.2 upgraded, body: =lua "SyntaxTree{type='Block', source=\%tree[5].source, unpack(\%new_lines)}"

10
compatibility/2.5.5.5.nom
View File

@ -1,16 +1,14 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines upgrades from Nomsu <2.5.5.5 to Nomsu 2.5.5.5
use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
upgrade action [hash %, sha1 %] to "2.5.5.5" as (..)
=lua "\
..\(base64 decode (hash %)):gsub('.', function(c) return ('%x02'):format(c) end)"
=lua "\(base64 decode (hash %)):gsub('.', function(c) return ('%x02'):format(c) end)"
upgrade action [file with hash %] to "2.5.5.5" as (..)
file with hash (..)
base64 (..)
=lua "\%:gsub('..', function(xx) return string.char(tonumber(xx, 16)) end)"
base64 (=lua "\%:gsub('..', function(xx) return string.char(tonumber(xx, 16)) end)")

4
compatibility/2.5.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines upgrades from Nomsu <2.5 to Nomsu 2.5
use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

21
compatibility/2.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines upgrades from Nomsu 1 to Nomsu 2
use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -15,21 +15,22 @@ upgrade %tree to "2" as:
%false_body = (%tree.5 upgraded)
unless (%false_body is "Block" syntax tree):
%false_body = (=lua "Block(\%false_body.source, \%false_body)")
return (..)
\(if %cond %true_body else %false_body) with vars {..}
cond:%tree.2 upgraded, true_body:%true_body, false_body:%false_body
cond: %tree.2 upgraded, true_body: %true_body, false_body: %false_body
%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"
"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 %n in %need_blocks:
if (%tree.stub is %n):
%bits = (((% upgraded) if (% is syntax tree) else %) for % in %tree)
%bits = [: for % in %tree: add ((% upgraded) if (% is syntax tree) else %)]
unless ((%bits::last) is "Block" syntax tree):
%body = (%bits::last)
%bits.(size of %bits) = (=lua "SyntaxTree{type='Block', source=\%body.source, \%body}")
%bits.(size of %bits) = (..)
=lua "SyntaxTree{type='Block', source=\%body.source, \%body}"
return (=lua "SyntaxTree{type='Action', source=\%tree.source, unpack(\%bits)}")

4
compatibility/3.5.5.6.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines upgrades from Nomsu <3.5.5.6 to Nomsu 3.5.5.6
use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

6
compatibility/3.6.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines upgrades from Nomsu <3.6 to 3.6
use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -16,11 +16,9 @@ upgrade action [add %item to %list at index %i] to "3.6" as (..)
upgrade action [pop from %list, remove last from %list] to "3.6" as (%list::pop)
upgrade action [remove index %index from %list] to "3.6" as (..)
%list::remove index %index
upgrade action [to %1 write %2, %1 <-write %2] to "3.6" as (%1::append %2)
upgrade action [to %1 write %2 joined by %3] to "3.6" as (..)
%1::append %2 joined by %3
upgrade action [declare locals in %lua] to "3.6" as (%lua::declare locals)
upgrade action [declare locals %locs in %lua] to "3.6" as (..)
%lua::declare locals %locs

24
compatibility/3.7.nom
View File

@ -1,19 +1,27 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines upgrades from Nomsu <3.7 to 3.7
use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
upgrade action [%index st to last in %list] to "3.7" as (%list::%index st to last)
upgrade action [%index nd to last in %list] to "3.7" as (%list::%index nd to last)
upgrade action [%index rd to last in %list] to "3.7" as (%list::%index rd to last)
upgrade action [%index th to last in %list] to "3.7" as (%list::%index rd th last)
upgrade action [%index st to last in %list] to "3.7" as (..)
%list::%index st to last
upgrade action [%index nd to last in %list] to "3.7" as (..)
%list::%index nd to last
upgrade action [%index rd to last in %list] to "3.7" as (..)
%list::%index rd to last
upgrade action [%index th to last in %list] to "3.7" as (..)
%list::%index rd th last
upgrade action [last in %list] to "3.7" as (%list::last)
upgrade action [first in %list] to "3.7" as (%list::first)
upgrade action [%item is in %list, %list contains %item, %list has %item]
..to "3.7" as (%list::has %item)
upgrade action [%item is in %list, %list contains %item, %list has %item] to \
.."3.7" as (%list::has %item)
upgrade action [..]
%item isn't in %list, %item is not in %list, %list doesn't contain %item

7
compatibility/3.8.nom
View File

@ -1,22 +1,19 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines upgrades from Nomsu <3.8 to 3.8 (Text method changes)
upgrade action [%texts joined with %glue] to "3.8" as (%texts::joined with %glue)
upgrade action [%texts joined, joined %texts] to "3.8" as (%texts::joined)
upgrade action [byte %i of %text] to "3.8" as (%text::byte %i)
upgrade action [bytes %start to %stop of %text] to "3.8" as (..)
%text::bytes %start to %stop
upgrade action [bytes of %text] to "3.8" as (%text::bytes)
upgrade action [capitalized %text, %text capitalized] to "3.8" as (..)
%text::capitalized
upgrade action [uppercase %text, %text uppercase] to "3.8" as (%text::uppercase)
upgrade action [..]
%text with %sub instead of %patt, %text with %patt replaced by %sub
%text s/ %patt / %sub
..to "3.8" as (%text::with %patt -> %sub)
upgrade action [%text matches %pattern] to "3.8" as (%text::matches %pattern)
upgrade action [%text matching %pattern] to "3.8" as (%text::matching %pattern).1

8
compatibility/3.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines upgrades from Nomsu <=2 to Nomsu 3
use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -10,6 +10,4 @@ upgrade action (method %spec %body) to "3" as (my action %spec %body)
upgrade action (me) to "3" as %me
upgrade action (@) to "3" as %me
upgrade action "as" to "3" via (..)
[] -> (..)
barf "\
..Object API has changed. Use (%obj::action ...) instead of (as %obj: action ...)"
[] -> (barf "Object API has changed. Use (%obj::action ...) instead of (as %obj: action ...)")

43
compatibility/4.10.12.7.nom
View File

@ -9,22 +9,33 @@ 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
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]
upgrade action (%e for %i in %start to %stop) to "4.10.12.7" as [:for %i in %start to %stop: add %e]
upgrade action (%e for %i in %start to %stop by %step) to "4.10.12.7" as (..)
[:for %i in %start to %stop by %step: add %e]
upgrade action (%e for %i in %start to %stop via %step) to "4.10.12.7" as (..)
[:for %i in %start to %stop by %step: add %e]
upgrade action (%e for %i in %start to %stop) to "4.10.12.7" as [..]
: for %i in %start to %stop: add %e
upgrade action (%k = %v for % in %items) to "4.10.12.7" as {:for % in %items: add %k = %v}
upgrade action (%k = %v for %k0 = %v0 in %items) to "4.10.12.7" as {:for %k0 = %v0 in %items: add %k = %v}
upgrade action (%k = %v for %i in %start to %stop) to "4.10.12.7" as {:for %i in %start to %stop: add %k = %v}
upgrade action (%k = %v for %i in %start to %stop by %step) to "4.10.12.7" as (..)
{:for %i in %start to %stop by %step: add %k = %v}
upgrade action (%k = %v for %i in %start to %stop via %step) to "4.10.12.7" as (..)
{:for %i in %start to %stop by %step: add %k = %v}
upgrade action (%e for %i in %start to %stop by %step) to "4.10.12.7" as [..]
: for %i in %start to %stop by %step: add %e
upgrade action (%e for %i in %start to %stop via %step) to "4.10.12.7" as [..]
: for %i in %start to %stop by %step: add %e
upgrade action (%k = %v for % in %items) to "4.10.12.7" as {..}
: for % in %items: add %k = %v
upgrade action (%k = %v for %k0 = %v0 in %items) to "4.10.12.7" as {..}
: for %k0 = %v0 in %items: add %k = %v
upgrade action (%k = %v for %i in %start to %stop) to "4.10.12.7" as {..}
: for %i in %start to %stop: add %k = %v
upgrade action (%k = %v for %i in %start to %stop by %step) to "4.10.12.7" as {..}
: for %i in %start to %stop by %step: add %k = %v
upgrade action (%k = %v for %i in %start to %stop via %step) to "4.10.12.7" as {..}
: for %i in %start to %stop by %step: add %k = %v
upgrade action (% as lua statements) to "4.10.12.7" as (% as lua)
upgrade action (compile error at %pos %err hint %hint) to "4.10.12.7" as (..)
@ -38,11 +49,13 @@ upgrade %tree to "4.10.12.7" as:
repeat while (%i < (size of %first_chunk)):
if %first_has_use:
if ((%first_chunk.%i.type != "Action") or (%first_chunk.%i.stub != "use")):
%chunk2 = (%SyntaxTree {type:"Block"})
%chunk2 = (%SyntaxTree {type: "Block"})
for %j in %i to (size of %first_chunk.%i):
%chunk2.((size of %chunk2) + 1) = %first_chunk.%i.%j
for %j in %i to (size of %first_chunk.%i):
%first_chunk.%i.%j = (nil)
%table.insert %tree 2 %chunk2
return %tree
..else:

6
compatibility/4.8.10.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10.6
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines upgrades from Nomsu <4.8.10 to 4.8.10 (renaming "action" -> "means")
use "compatibility/compatibility.nom"
@ -15,6 +15,7 @@ upgrade action "local action" to "4.8.10" via (..)
return \(%spec.1 means %body)
..else:
return \(%spec all mean %body)
else:
return \(%spec means %body)
@ -29,6 +30,7 @@ upgrade action "action" to "4.8.10" via (..)
return \(externally %spec.1 means %body)
..else:
return \(externally %spec all mean %body)
else:
return \(externally %spec means %body)
..else:
@ -44,6 +46,7 @@ upgrade action "compile 1 to" to "4.8.10" via (..)
return \(%spec.1 compiles to %body)
..else:
return \(%spec all compile to %body)
else:
return \(%spec compiles to %body)
@ -57,6 +60,7 @@ upgrade action "parse 1 as" to "4.8.10" via (..)
return \(%spec.1 parses as %body)
..else:
return \(%spec all parse as %body)
else:
return \(%spec parse as %body)

2
compatibility/4.9.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.9.11.6
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines upgrades from Nomsu <4.9 to 4.9
use "compatibility/compatibility.nom"

42
compatibility/compatibility.nom
View File

@ -1,8 +1,8 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file contains code for defining ways to upgrade code between different versions
of Nomsu.
use "lib/os.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -10,7 +10,6 @@ use "lib/os.nom"
%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
@ -27,7 +26,6 @@ externally (upgrade action %stub to %version via %upgrade_fn) means:
for %i in 1 to (size of %action):
if (%action.%i.type is "Var"):
%replacements.(%action.%i.1) = "\(\%tree as lua id)[\%i]"
define mangler
(make tree %t) means:
when:
@ -45,21 +43,20 @@ externally (upgrade action %stub to %version via %upgrade_fn) means:
%args::add (make tree %v)
..else:
%args::add "\(%k)=\(make tree %v)"
return "SyntaxTree{\(%args::joined with ", ")}"
else: return (quote %t)
else:
return (quote %t)
unless ("\%lua" == ""):
%lua::append "\n"
unless ("\%lua" == ""): %lua::append "\n"
%retval = (make tree %body)
%lua::append (..)
Lua "\
..upgrade_action_1_to_2_via(\(quote %action.stub), \(%version as lua expr), function(\(..)
\%tree as lua id
..)
..upgrade_action_1_to_2_via(\(quote %action.stub), \(%version as lua expr), function(\(\%tree as lua id))
return \%retval
end)"
return %lua
externally [..]
@ -71,8 +68,10 @@ externally [..]
%versions = {}
for %v = % in %UPGRADES:
%versions.%v = (yes)
for %v = % in %ACTION_UPGRADES:
%versions.%v = (yes)
%versions = ((keys in %versions) sorted by % -> (% as list))
for %ver in %versions:
if ((%ver as list) <= (%start_version as list)): do next %ver
@ -81,18 +80,18 @@ externally [..]
%tree = (..)
%tree with % ->:
if ((% is "Action" syntax tree) and %ACTION_UPGRADES.%ver.(%.stub)):
%with_upgraded_args = (..)
%k = (%v upgraded from %start_version to %end_version) for %k = %v in %
set %with_upgraded_args 's metatable to (% 's metatable)
return (..)
%ACTION_UPGRADES.%ver.(%.stub) %with_upgraded_args %end_version
%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 %UPGRADES.%ver:
%with_upgraded_args = (..)
%k = (%v upgraded from %start_version to %end_version) for %k = %v in %tree
set %with_upgraded_args 's metatable to (%tree 's metatable)
%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 = (call %UPGRADES.%ver with [%with_upgraded_args, %end_version])
%tree.shebang = "#!/usr/bin/env nomsu -V\%end_version"
return %tree
@ -107,7 +106,8 @@ externally (%tree upgraded) means (..)
externally (use %path from version %version) means:
for file %filename in %path:
if (=lua "LOADED[\%filename]"): do next %filename
if (=lua "LOADED[\%filename]"):
do next %filename
%file = (read file %filename)
%tree = (parse %file from %filename)
%tree = (upgrade %tree from %version)

151
core/collections.nom
View File

@ -1,8 +1,8 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file contains code that supports manipulating and using collections like lists
and dictionaries.
use "core/metaprogramming.nom"
use "core/control_flow.nom"
use "core/operators.nom"
@ -15,11 +15,11 @@ test:
%visited = {}
for %i = %x in %list:
%visited.%i = (yes)
assume (%visited == {1:yes, 2:yes, 3:yes, 4:yes, 5:yes})
assume (%visited == {1: yes, 2: yes, 3: yes, 4: yes, 5: yes})
%visited = {}
for %x in %list:
%visited.%x = (yes)
assume (%visited == {1:yes, 2:yes, 3:yes, 4:yes, 5:yes})
assume (%visited == {1: yes, 2: yes, 3: yes, 4: yes, 5: yes})
assume ((%list::2 nd to last) == 4)
assume ((%list::first) == 1)
assume (%list::has 3)
@ -35,130 +35,53 @@ test:
# Dict functionality
test:
%dict = {x:1, y:2, z:3}
assume ((size of %dict) == 3)
assume ((% for % in {x:1}) == [{key:"x", value:1}])
assume (({key:%k, value:%v} for %k = %v in {x:1}) == [{key:"x", value:1}])
assume (({x:1, y:1} + {y:10, z:10}) == {x:1, y:11, z:10})
assume (({x:1, y:1} | {y:10, z:10}) == {x:1, y:1, z:10})
assume (({x:1, y:1} & {y:10, z:10}) == {y:1})
assume (({x:1, y:1} ~ {y:10, z:10}) == {x:1, z:10})
# List Comprehension
test:
assume (((% * %) for % in [1, 2, 3]) == [1, 4, 9])
(%expression for %item in %iterable) parses as (..)
result of:
%comprehension = []
for %item in %iterable:
%comprehension::add %expression
return %comprehension
[..]
%expression for %index in %start to %stop via %step
%expression for %index in %start to %stop by %step
..all parse as (..)
result of:
%comprehension = []
for %index in %start to %stop via %step:
%comprehension::add %expression
return %comprehension
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test:
assume (((% * %) for % in 1 to 3) == [1, 4, 9])
(%expression for %var in %start to %stop) parses as (..)
%expression for %var in %start to %stop via 1
test:
assume (("\%k,\%v" for %k = %v in {x:1}) == ["x,1"])
[..]
%expression for %key = %value in %iterable
%expression for %key %value in %iterable
..all parse as (..)
result of:
%comprehension = []
for %key = %value in %iterable:
%comprehension::add %expression
return %comprehension
# Dict comprehensions
test:
assume (((% * %) = % for % in [1, 2, 3]) == {1:1, 4:2, 9:3})
[..]
%key = %value for %item in %iterable, %key %value for %item in %iterable
..all parse as (..)
result of:
%comprehension = {}
for %item in %iterable:
%comprehension.%key = %value
return %comprehension
test:
assume ((%k = (%v * %v) for %k = %v in {x:1, y:2, z:3}) == {x:1, y:4, z:9})
[..]
%key = %value for %src_key = %src_value in %iterable
%key %value for %src_key %src_value in %iterable
..all parse as (..)
result of:
%comprehension = {}
for %src_key = %src_value in %iterable:
%comprehension.%key = %value
return %comprehension
[..]
%key = %value for %item in %start to %stop via %step
%key %value for %item in %start to %stop via %step
..all parse as (..)
result of:
%comprehension = {}
for %item in %start to %stop via %step:
%comprehension.%key = %value
return %comprehension
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test:
assume (((% * %) = % for % in 1 to 3) == {1:1, 4:2, 9:3})
[..]
%key = %value for %item in %start to %stop
%key %value for %item in %start to %stop
..all parse as (%key = %value for %item in %start to %stop via 1)
%dict = {x: 1, y: 2, z: 3}
assume (size of %dict) == 3
assume [: for % in {x: 1}: add %] == [{key: "x", value: 1}]
assume [: for %k = %v in {x: 1}: add {key: %k, value: %v}] == [..]
{key: "x", value: 1}
assume ({x: 1, y: 1} + {y: 10, z: 10}) == {x: 1, y: 11, z: 10}
assume ({x: 1, y: 1} | {y: 10, z: 10}) == {x: 1, y: 1, z: 10}
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 %list in %lists:
for %item in %list: %flat::add %item
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}])
(entries in %dict) parses as ({key:%k, value:%v} for %k = %v in %dict)
assume ((entries in {x: 1}) == [{key: "x", value: 1}])
(entries in %dict) parses as [: for %k = %v in %dict: add {key: %k, value: %v}]
test:
assume ((keys in {x:1}) == ["x"])
[keys in %dict, keys of %dict] all parse as (%k for %k = %v in %dict)
assume ((keys in {x: 1}) == ["x"])
[keys in %dict, keys of %dict] all parse as [: for %k = %v in %dict: add %k]
test:
assume ((values in {x:1}) == [1])
[values in %dict, values of %dict] all parse as (%v for %k = %v in %dict)
assume ((values in {x: 1}) == [1])
[values in %dict, values of %dict] all parse as [: for %k = %v in %dict: add %v]
# Metatable stuff
test:
%t = {}
set %t 's metatable to {__tostring:[%] -> "XXX"}
set %t's metatable to {__tostring: [%] -> "XXX"}
assume ("\%t" == "XXX")
(set %dict 's metatable to %metatable) compiles to "\
(set %dict's metatable to %metatable) compiles to "\
..setmetatable(\(%dict as lua expr), \(%metatable as lua expr));"
[% 's metatable, % 'metatable] all compile to "\
..getmetatable(\(% as lua expr))"
[%'s metatable, %'metatable] all compile to "getmetatable(\(% as lua expr))"
test:
assume (({} with fallback % -> (% + 1)).10 == 11)
(%dict with fallback %key -> %value) compiles to "\
..(function(d)
local mt = {}
@ -178,12 +101,11 @@ test:
assume (%x == [1, 2, 3])
sort %x by % = (- %)
assume (%x == [3, 2, 1])
%keys = {1:999, 2:0, 3:50}
%keys = {1: 999, 2: 0, 3: 50}
sort %x by % = %keys.%
assume (%x == [2, 3, 1])
(sort %items) compiles to "table.sort(\(%items as lua expr));"
[..]
sort %items by %item = %key_expr, sort %items by %item -> %key_expr
[sort %items by %item = %key_expr, sort %items by %item -> %key_expr] \
..all parse as (..)
do:
%keys = ({} with fallback %item -> %key_expr)
@ -193,19 +115,21 @@ test:
test:
assume ((sorted [3, 1, 2]) == [1, 2, 3])
externally [%items sorted, sorted %items] all mean:
%copy = (% for % in %items)
%copy = [: for % in %items: add %]
sort %copy
return %copy
[%items sorted by %item = %key, %items sorted by %item -> %key] all parse as (..)
result of:
%copy = (% for % in %items)
%copy = [: for % in %items: add %]
sort %copy by %item = %key
return %copy
test:
assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3])
externally (unique %items) means:
%unique = []
%seen = {}
@ -213,5 +137,4 @@ externally (unique %items) means:
unless %seen.%:
%unique::add %
%seen.% = (yes)
return %unique

234
core/control_flow.nom
View File

@ -1,8 +1,8 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file contains compile-time actions that define basic control flow structures
like "if" statements and loops.
use "core/metaprogramming.nom"
use "core/operators.nom"
use "core/errors.nom"
@ -10,13 +10,15 @@ use "core/errors.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# No-Op
test: do nothing
test:
do nothing
(do nothing) compiles to ""
# Conditionals
test:
if (no):
barf "conditional fail"
(if %condition %if_body) compiles to "\
..if \(%condition as lua expr) then
\(%if_body as lua)
@ -25,9 +27,9 @@ test:
test:
unless (yes):
barf "conditional fail"
(unless %condition %unless_body) parses as (if (not %condition) %unless_body)
[..]
if %condition %if_body else %else_body, unless %condition %else_body else %if_body
[if %condition %if_body else %else_body, unless %condition %else_body else %if_body] \
..all compile to "\
..if \(%condition as lua expr) then
\(%if_body as lua)
@ -43,6 +45,7 @@ test:
test:
assume ((1 if (yes) else 2) == 1)
assume ((1 if (no) else 2) == 2)
[..]
%when_true_expr if %condition else %when_false_expr
%when_true_expr if %condition otherwise %when_false_expr
@ -51,12 +54,8 @@ test:
..all compile to:
# If %when_true_expr is guaranteed to be truthy, we can use Lua's idiomatic
equivalent of a conditional expression: (cond and if_true or if_false)
if {Text:yes, List:yes, Dict:yes, Number:yes}.(%when_true_expr.type):
return (..)
Lua "\
..(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(..)
%when_false_expr as lua expr
..)"
if {Text: yes, List: yes, Dict: yes, Number: yes}.(%when_true_expr.type):
return (Lua "(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(%when_false_expr as lua expr))")
..else:
# Otherwise, need to do an anonymous inline function (yuck, too bad lua
doesn't have a proper ternary operator!)
@ -78,35 +77,37 @@ test:
%i = 0
=== %loop ===
%i += 1
unless (%i == 10): go to %loop
unless (%i == 10):
go to %loop
assume (%i == 10)
=== (Loop) ===
%i -= 1
unless (%i == 0): go to (Loop)
unless (%i == 0):
go to (Loop)
assume (%i == 0)
[=== %label ===, --- %label ---, *** %label ***] all compile to "\
..::label_\(..)
(%label.stub if (%label.type == "Action") else %label) as lua identifier
..::"
..::label_\((%label.stub if (%label.type == "Action") else %label) as lua identifier)::"
(go to %label) compiles to "\
..goto label_\(..)
(%label.stub if (%label.type == "Action") else %label) as lua identifier
.."
..goto label_\((%label.stub if (%label.type == "Action") else %label) as lua identifier)"
# Basic loop control
(stop %var) compiles to:
if %var:
return (..)
Lua "goto stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)"
..else: return (Lua "break")
return (Lua "goto stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)")
..else:
return (Lua "break")
(do next %var) compiles to:
if %var:
return (..)
Lua "goto continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)"
..else: return (Lua "goto continue")
return (Lua "goto continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)")
..else:
return (Lua "goto continue")
[===stop %var ===, ---stop %var ---, ***stop %var ***] all compile to "\
..::stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
[===next %var ===, ---next %var ---, ***next %var ***] all compile to "\
..::continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
@ -116,32 +117,31 @@ test:
repeat while (%x < 10): %x += 1
assume (%x == 10)
repeat while (%x < 20): stop
repeat while (%x < 20): stop repeating
repeat while (%x < 20):
stop repeating
assume (%x == 10)
repeat while (%x < 20):
%x += 1
if (yes): do next
if (yes):
do next
barf "Failed to 'do next'"
assume (%x == 20)
repeat while (%x < 30):
%x += 1
if (yes): do next repeat
if (yes):
do next repeat
barf "Failed to 'do next repeat'"
assume (%x == 30)
(do next repeat) compiles to "goto continue_repeat"
(stop repeating) compiles to "goto stop_repeat"
(repeat while %condition %body) compiles to:
%lua = (..)
Lua "\
..while \(%condition as lua expr) do
\(%body as lua)"
%lua = (Lua "while \(%condition as lua expr) do\n \(%body as lua)")
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
if (%body has subtree \(do next repeat)):
%lua::append "\n ::continue_repeat::"
%lua::append "\nend --while-loop"
if (%body has subtree \(stop repeating)):
%inner_lua = %lua
@ -150,25 +150,24 @@ test:
..
::stop_repeat::
end -- end of 'stop repeating' label scope"
return %lua
(repeat %body) parses as (repeat while (yes) %body)
(repeat until %condition %body) parses as (repeat while (not %condition) %body)
test:
%x = 0
repeat 10 times: %x += 1
assume (%x == 10)
(repeat %n times %body) compiles to:
define mangler
%lua = (..)
Lua "for \(mangle "i")=1,\(%n as lua expr) do\n "
%lua = (Lua "for \(mangle "i")=1,\(%n as lua expr) do\n ")
%lua::append (%body as lua)
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
if (%body has subtree \(do next repeat)):
%lua::append "\n ::continue_repeat::"
%lua::append "\nend --numeric for-loop"
if (%body has subtree \(stop repeating)):
%inner_lua = %lua
@ -177,17 +176,18 @@ test:
..
::stop_repeat::
end -- end of 'stop repeating' label scope"
return %lua
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test:
%nums = []
for %x in 1 to 5: %nums::add %x
for %x in 1 to 5:
%nums::add %x
assume (%nums == [1, 2, 3, 4, 5])
%nums = []
for %x in 1 to 5 via 2: %nums::add %x
for %x in 1 to 5 via 2:
%nums::add %x
assume (%nums == [1, 3, 5])
%nums = []
for %outer in 1 to 100:
@ -195,10 +195,9 @@ test:
if (%inner == 2):
%nums::add -2
do next %inner
%nums::add %inner
if (%inner == 5): stop %outer
if (%inner == 5):
stop %outer
assume (%nums == [1, -2, 3, -2, 3, 4, 3, 4, 5])
# Numeric range for loops
@ -209,15 +208,11 @@ test:
# This uses Lua's approach of only allowing loop-scoped variables in a loop
unless (%var.type is "Var"):
compile error at %var "Expected a variable here, not a \(%var.type)"
%lua = (..)
Lua "\
..for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(..)
%step as lua expr
.. do"
%lua = (Lua "for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(%step as lua expr) do")
%lua::append "\n " (%body as lua)
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
if (%body has subtree \(do next %var)):
%lua::append "\n " (what (===next %var ===) compiles to)
@ -228,7 +223,6 @@ test:
%lua::append %inner_lua "\n "
%lua::append (what (===stop %var ===) compiles to)
%lua::append "\nend -- end of scope for stopping for-loop"
return %lua
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -239,25 +233,33 @@ test:
test:
%a = [10, 20, 30, 40, 50]
%b = []
for %x in %a: %b::add %x
for %x in %a:
%b::add %x
assume (%a == %b)
%b = []
for %x in %a:
if (%x == 10): do next %x
if (%x == 50): stop %x
if (%x == 10):
do next %x
if (%x == 50):
stop %x
%b::add %x
assume (%b == [20, 30, 40])
# For-each loop (lua's "ipairs()")
(for %var in %iterable %body) compiles to:
define mangler
# This uses Lua's approach of only allowing loop-scoped variables in a loop
%lua = (..)
Lua "for \(mangle "i"),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do\n "
Lua "\
..for \(mangle "i"),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
"
%lua::append (%body as lua)
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
if (%body has subtree \(do next %var)):
%lua::append "\n " (what (===next %var ===) compiles to)
@ -268,17 +270,19 @@ test:
%lua::append %inner_lua "\n "
%lua::append (what (===stop %var ===) compiles to)
%lua::append "\nend -- end of scope for stopping for-loop"
return %lua
# TODO: reduce code duplication
(for %var in %iterable at %i %body) compiles to:
# This uses Lua's approach of only allowing loop-scoped variables in a loop
%lua = (..)
Lua "for \(%i as lua identifier),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do\n "
Lua "\
..for \(%i as lua identifier),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
"
%lua::append (%body as lua)
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
if (%body has subtree \(do next %var)):
%lua::append "\n " (what (===next %var ===) compiles to)
@ -289,37 +293,36 @@ test:
%lua::append %inner_lua "\n "
%lua::append (what (===stop %var ===) compiles to)
%lua::append "\nend -- end of scope for stopping for-loop"
return %lua
test:
%d = {a:10, b:20, c:30, d:40, e:50}
%d = {a: 10, b: 20, c: 30, d: 40, e: 50}
%result = []
for %k = %v in %d:
if (%k == "a"): do next %k
if (%v == 20): do next %v
if (%k == "a"):
do next %k
if (%v == 20):
do next %v
%result::add "\%k = \%v"
assume ((%result sorted) == ["c = 30", "d = 40", "e = 50"])
# Dict iteration (lua's "pairs()")
[..]
for %key = %value in %iterable %body, for %key %value in %iterable %body
[for %key = %value in %iterable %body, for %key %value in %iterable %body] \
..all compile to:
# This uses Lua's approach of only allowing loop-scoped variables in a loop
unless (%key.type is "Var"):
compile error at %key "Expected a variable here, not a \(%key.type)"
unless (%value.type is "Var"):
compile error at %value "Expected a variable here, not a \(%value.type)"
%lua = (..)
Lua "\
..for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(..)
%iterable as lua expr
..) do"
%lua = (Lua "for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(%iterable as lua expr)) do")
%lua::append "\n " (%body as lua)
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
if (%body has subtree \(do next %key)):
%lua::append "\n " (what (===next %key ===) compiles to)
@ -350,8 +353,10 @@ test:
(1 == 0) (1 == 1) %not_a_variable.x: do nothing
(1 == 1):
barf "bad conditional"
(1 == 2):
barf "bad conditional"
else:
barf "bad conditional"
@ -361,30 +366,29 @@ test:
%clause = "if"
%else_allowed = (yes)
unless (%body.type is "Block"):
compile error at %body "'if' expected a Block, but got a \(%body.type)."
..hint "Perhaps you forgot to put a ':' after 'if'?"
compile error at %body "'if' expected a Block, but got a \(%body.type)." "\
..Perhaps you forgot to put a ':' after 'if'?"
for %line in %body:
unless (..)
((%line.type is "Action") and ((size of %line) >= 2)) and (..)
%line.(size of %line) is "Block" syntax tree
..:
compile error at %line "Invalid line for the body of an 'if' block."
..hint "Each line should contain one or more conditional expressions \
..followed by a block, or "else" followed by a block."
compile error at %line "Invalid line for the body of an 'if' block." "\
..Each line should contain one or more conditional expressions followed by a block, or "else" followed \
..by a block."
%action = %line.(size of %line)
if ((%line.1 is "else") and ((size of %line) == 2)):
unless %else_allowed:
compile error at %line "You can't have two 'else' blocks."
..hint "Merge all of the 'else' blocks together."
compile error at %line "You can't have two 'else' blocks." "\
..Merge all of the 'else' blocks together."
unless ((size of "\%code") > 0):
compile error at %line "\
..You can't have an 'else' block without a preceeding condition"
..hint "If you want the code in this block to always execute, you don't \
..need a conditional block around it. Otherwise, make sure the 'else' \
..block comes last."
.."\
..If you want the code in this block to always execute, you don't need a conditional block around it. \
..Otherwise, make sure the 'else' block comes last."
%code::append "\nelse\n " (%action as lua)
%else_allowed = (no)
@ -394,13 +398,13 @@ test:
if (%i > 1):
%code::append " or "
%code::append (%line.%i as lua expr)
%code::append " then\n " (%action as lua)
%clause = "\nelseif"
if ((size of "\%code") == 0):
compile error at %body "'if' block has an empty body."
..hint "This means nothing would happen, so the 'if' block should be deleted."
compile error at %body "'if' block has an empty body." "\
..This means nothing would happen, so the 'if' block should be deleted."
%code::append "\nend --when"
return %code
@ -408,9 +412,13 @@ test:
if 5 is:
1 2 3:
barf "bad switch statement"
4 5: do nothing
4 5:
do nothing
5 6:
barf "bad switch statement"
else:
barf "bad switch statement"
@ -421,28 +429,28 @@ test:
%else_allowed = (yes)
define mangler
unless (%body.type is "Block"):
compile error at %body "'if' expected a Block, but got a \(%body.type)"
..hint "Perhaps you forgot to put a ':' after the 'is'?"
compile error at %body "'if' expected a Block, but got a \(%body.type)" "\
..Perhaps you forgot to put a ':' after the 'is'?"
for %line in %body:
unless (..)
((%line.type is "Action") and ((size of %line) >= 2)) and (..)
%line.(size of %line) is "Block" syntax tree
..:
compile error at %line "Invalid line for 'if' block."
..hint "Each line should contain expressions \
..followed by a block, or "else" followed by a block"
compile error at %line "Invalid line for 'if' block." "\
..Each line should contain expressions followed by a block, or "else" followed by a block"
%action = %line.(size of %line)
if ((%line.1 is "else") and ((size of %line) == 2)):
unless %else_allowed:
compile error at %line "You can't have two 'else' blocks."
..hint "Merge all of the 'else' blocks together."
compile error at %line "You can't have two 'else' blocks." "\
..Merge all of the 'else' blocks together."
unless ((size of "\%code") > 0):
compile error at %line "\
..You can't have an 'else' block without a preceeding condition"
..hint "If you want the code in this block to always execute, you don't \
..need a conditional block around it. Otherwise, make sure the 'else' \
..block comes last."
.."\
..If you want the code in this block to always execute, you don't need a conditional block around it. \
..Otherwise, make sure the 'else' block comes last."
%code::append "\nelse\n " (%action as lua)
%else_allowed = (no)
@ -452,13 +460,13 @@ test:
if (%i > 1):
%code::append " or "
%code::append "\(mangle "branch value") == " (%line.%i as lua expr)
%code::append " then\n " (%action as lua)
%clause = "\nelseif"
if ((size of "\%code") == 0):
compile error at %body "'if' block has an empty body."
..hint "This means nothing would happen, so the 'if' block should be deleted."
compile error at %body "'if' block has an empty body." "\
..This means nothing would happen, so the 'if' block should be deleted."
%code::append "\nend --when"
return (..)
Lua "\
@ -468,19 +476,17 @@ test:
end -- if % is..."
# Do/finally
(do %action) compiles to "\
..do
\(%action as lua)
end -- do"
(do %action) compiles to "do\n \(%action as lua)\nend -- do"
test:
%d = {}
try:
do:
%d.x = "bad"
barf
..then always: %d.x = "good"
..then always:
%d.x = "good"
assume (%d.x == "good")
(do %action then always %final_action) compiles to:
define mangler
return (..)
@ -497,19 +503,19 @@ test:
end"
test:
assume ((result of (: return 99)) == 99)
assume ((result of: return 99) == 99)
# Inline thunk:
(result of %body) compiles to "\(what ([] -> %body) compiles to)()"
test:
%t = [1, [2, [[3], 4], 5, [[[6]]]]]
%flat = []
for % in recursive %t:
if ((lua type of %) is "table"):
for %2 in %: recurse % on %2
..else: %flat::add %
for %2 in %:
recurse % on %2
..else:
%flat::add %
assume (sorted %flat) == [1, 2, 3, 4, 5, 6]
# Recurion control flow
@ -518,6 +524,7 @@ test:
define mangler
(recurse %v on %x) compiles to (..)
Lua "table.insert(\(mangle "stack \(%v.1)"), \(%x as lua expr))"
%lua = (..)
Lua "\
..do
@ -525,10 +532,13 @@ test:
while #\(mangle "stack \(%var.1)") > 0 do
\(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)
\(%body as lua)"
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
if (%body has subtree \(do next %var)):
%lua::append "\n \(what (===next %var ===) compiles to)"
%lua::append "\n end -- Recursive loop"
if (%body has subtree \(stop %var)):
%lua::append "\n \(what (===stop %var ===) compiles to)"

9
core/coroutines.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines the code that creates and manipulates coroutines
use "core/metaprogramming.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -14,8 +14,11 @@ test:
-> 5
repeat 3 times: -> 6
for % in coroutine %co: %nums::add %
for % in coroutine %co:
%nums::add %
assume (%nums == [4, 5, 6, 6, 6]) or barf "Coroutine iteration failed"
[coroutine %body, generator %body] all compile to "\
..(function()
\(%body as lua)

39
core/errors.nom
View File

@ -1,16 +1,16 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file contains basic error reporting code
use "core/metaprogramming.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(barf %msg) compiles to "error(\(=lua "\%msg and \(%msg as lua expr) or 'nil'"), 0);"
(barf %msg) compiles to "\
..error(\(=lua "\%msg and \(%msg as lua expr) or 'nil'"), 0);"
(assume %condition) compiles to:
lua> "\
..local \%assumption = 'Assumption failed: '..tostring((\%condition):get_source_code())"
lua> "local \%assumption = 'Assumption failed: '..tostring((\%condition):get_source_code())"
return (..)
Lua "\
..if not \(%condition as lua expr) then
@ -18,17 +18,14 @@ use "core/metaprogramming.nom"
end"
(assume %a == %b) compiles to:
lua> "\
..local \%assumption = 'Assumption failed: '..tostring(\(\(%a == %b) as nomsu))"
lua> "local \%assumption = 'Assumption failed: '..tostring(\(\(%a == %b) as nomsu))"
define mangler
return (..)
Lua "\
..do
local \(mangle "a"), \(mangle "b") = \(%a as lua expr), \(%b as lua expr)
if \(mangle "a") ~= \(mangle "b") then
error(\(quote "\%assumption").."\\n"..tostring(\(mangle "a")).." != "..tostring(\(..)
mangle "b"
..), 0)
error(\(quote "\%assumption").."\\n"..tostring(\(mangle "a")).." != "..tostring(\(mangle "b")), 0)
end
end"
@ -38,16 +35,18 @@ use "core/metaprogramming.nom"
end"
test:
try (barf) and if it succeeds: barf "try failed."
try (barf) and if it succeeds:
barf "try failed."
%worked = (no)
try (barf) and if it barfs: %worked = (yes)
try (barf) and if it barfs:
%worked = (yes)
assume %worked or barf "try/catch failed"
%x = 1
try:
%x = 2
do (barf) then always: %x = 3
..and if it barfs: do nothing
..and if it barfs:
do nothing
assume (%x == 3) or barf "do/then always failed"
# Try/except
@ -81,19 +80,19 @@ test:
#
[..]
try %action and if it succeeds %success or if it barfs %fallback
try %action and if it barfs %fallback or if it succeeds %success
try %action and if it succeeds %success or if it barfs %fallback
try %action and if it barfs %fallback or if it succeeds %success
..all parse as (..)
try %action and if it succeeds %success or if it barfs (=lua "") %fallback
try %action and if it succeeds %success or if it barfs (=lua "") %fallback
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(try %action) parses as (..)
try %action and if it succeeds (do nothing) or if it barfs (do nothing)
#(try %action and if it barfs %fallback) parses as (..)
try %action and if it succeeds (do nothing) or if it barfs %fallback
(try %action and if it barfs %msg %fallback) parses as (..)
try %action and if it succeeds (do nothing) or if it barfs %msg %fallback

33
core/id.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
A simple UUID function based on RFC 4122: http://www.ietf.org/rfc/rfc4122.txt
use "core/metaprogramming.nom"
use "core/operators.nom"
use "core/math.nom"
@ -13,21 +13,22 @@ use "core/control_flow.nom"
%NaN_surrogate = {}
%nil_surrogate = {}
%obj_by_id = {}
set %obj_by_id's metatable to {__mode:"v"}
set %obj_by_id's metatable to {__mode: "v"}
%id_by_obj = {}
set %id_by_obj 's metatable to {..}
__mode:"k", __index: (..)
[%self, %key] ->:
if (%key == (nil)):
return %self.%nil_surrogate
if (%key != %key):
return %self.%NaN_surrogate
--- (retry) ---
%id = (uuid)
if (%obj_by_id.%id != (nil)): go to (retry)
%self.%key = %id
%obj_by_id.%id = %key
return %id
set %id_by_obj's metatable to {..}
__mode: "k", __index: [%self, %key] ->:
if (%key == (nil)):
return %self.%nil_surrogate
if (%key != %key):
return %self.%NaN_surrogate
--- (retry) ---
%id = (uuid)
if (%obj_by_id.%id != (nil)): go to (retry)
%self.%key = %id
%obj_by_id.%id = %key
return %id
externally (uuid) means:
# Set all the other bits to randomly (or pseudo-randomly) chosen values.

8
core/io.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file contains basic input/output code
use "core/metaprogramming.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -19,7 +19,5 @@ use "core/metaprogramming.nom"
..if \%prompt.type == "Text" then
return LuaCode("(io.write(", \(%prompt as lua expr), ") and io.read())");
else
return LuaCode("(io.write(tostring(", \(..)
%prompt as lua expr
.., ")) and io.read())");
return LuaCode("(io.write(tostring(", \(%prompt as lua expr), ")) and io.read())");
end"

137
core/math.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines some common math literals and functions
use "core/metaprogramming.nom"
use "core/text.nom"
use "core/operators.nom"
@ -28,7 +28,6 @@ test:
assume (("5" as a number) == 5)
((% as a number)'s meaning) = ((tonumber %)'s meaning)
((% as number)'s meaning) = ((tonumber %)'s meaning)
test:
assume (..)
all of [..]
@ -36,101 +35,108 @@ test:
arc tangent 5, arc tangent 5 / 10, hyperbolic sine 5, hyperbolic cosine 5
hyperbolic tangent 5, e^ 5, ln 5, log base 2 of 5, floor 5, ceiling 5, round 5
..or barf "math functions failed"
[absolute value %, | % |, abs %] all compile to (..)
"math.abs(\(% as lua expr))"
[square root %, square root of %, √ %, sqrt %] all compile to (..)
"math.sqrt(\(% as lua expr))"
[absolute value %, | % |, abs %] all compile to "math.abs(\(% as lua expr))"
[square root %, square root of %, √ %, sqrt %] all compile to "\
..math.sqrt(\(% as lua expr))"
[sine %, sin %] all compile to "math.sin(\(% as lua expr))"
[cosine %, cos %] all compile to "math.cos(\(% as lua expr))"
[tangent %, tan %] all compile to "math.tan(\(% as lua expr))"
[arc sine %, asin %] all compile to "math.asin(\(% as lua expr))"
[arc cosine %, acos %] all compile to "math.acos(\(% as lua expr))"
[arc tangent %, atan %] all compile to "math.atan(\(% as lua expr))"
[arc tangent %y / %x, atan2 %y %x] all compile to (..)
"math.atan2(\(%y as lua expr), \(%x as lua expr))"
[hyperbolic sine %, sinh %] all compile to (..)
"math.sinh(\(% as lua expr))"
[hyperbolic cosine %, cosh %] all compile to (..)
"math.cosh(\(% as lua expr))"
[hyperbolic tangent %, tanh %] all compile to (..)
"math.tanh(\(% as lua expr))"
[arc tangent %y / %x, atan2 %y %x] all compile to "\
..math.atan2(\(%y as lua expr), \(%x as lua expr))"
[hyperbolic sine %, sinh %] all compile to "math.sinh(\(% as lua expr))"
[hyperbolic cosine %, cosh %] all compile to "math.cosh(\(% as lua expr))"
[hyperbolic tangent %, tanh %] all compile to "math.tanh(\(% as lua expr))"
[e^ %, exp %] all compile to "math.exp(\(% as lua expr))"
[natural log %, ln %, log %] all compile to (..)
"math.log(\(% as lua expr))"
[log % base %base, log base %base of %] all compile to (..)
"math.log(\(% as lua expr), \(%base as lua expr))"
[natural log %, ln %, log %] all compile to "math.log(\(% as lua expr))"
[log % base %base, log base %base of %] all compile to "\
..math.log(\(% as lua expr), \(%base as lua expr))"
(floor %) compiles to "math.floor(\(% as lua expr))"
[ceiling %, ceil %] all compile to "math.ceil(\(% as lua expr))"
[round %, % rounded] all compile to (..)
"math.floor(\(% as lua expr) + .5)"
[round %, % rounded] all compile to "math.floor(\(% as lua expr) + .5)"
test:
assume ((463 to the nearest 100) == 500) or barf "rounding failed"
assume ((2.6 to the nearest 0.25) == 2.5) or barf "rounding failed"
externally (%n to the nearest %rounder) means (..)
=lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)"
# Any/all
externally [all of %items, all %items] all mean:
for % in %items:
unless %: return (no)
unless %:
return (no)
return (yes)
[all of %items, all %items] all compile to:
unless (%items.type is "List"):
return \(all of %items)
if ((size of %items) == 0): return (Lua "true")
if ((size of %items) == 0):
return (Lua "true")
%lua = (Lua "(")
%lua::add ((% as lua expr) for % in %items) joined with " and "
%lua::add [: for % in %items: add (% as lua expr)] joined with " and "
%lua::append ")"
return %lua
[not all of %items, not all %items] all parse as (not (all of %items))
[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)
if %:
return (yes)
return (no)
[any of %items, any %items] all compile to:
unless (%items.type is "List"):
return \(any of %items)
if ((size of %items) == 0): return (Lua "false")
if ((size of %items) == 0):
return (Lua "false")
%lua = (Lua "(")
%lua::add ((% as lua expr) for % in %items) joined with " or "
%lua::add [: for % in %items: add (% as lua expr)] joined with " or "
%lua::append ")"
return %lua
[none of %items, none %items] all parse as (not (any of %items))
# Sum/product
externally [sum of %items, sum %items] all mean:
%total = 0
for % in %items: %total += %
for % in %items:
%total += %
return %total
[sum of %items, sum %items] all compile to:
unless (%items.type is "List"):
return \(sum of %items)
if ((size of %items) == 0): return (Lua "0")
if ((size of %items) == 0):
return (Lua "0")
%lua = (Lua "(")
%lua::add ((% as lua expr) for % in %items) joined with " + "
%lua::add [: for % in %items: add (% as lua expr)] joined with " + "
%lua::append ")"
return %lua
externally [product of %items, product %items] all mean:
%prod = 1
for % in %items: %prod *= %
for % in %items:
%prod *= %
return %prod
[product of %items, product %items] all compile to:
unless (%items.type is "List"):
return \(product of %items)
if ((size of %items) == 0): return (Lua "1")
if ((size of %items) == 0):
return (Lua "1")
%lua = (Lua "(")
%lua::add ((% as lua expr) for % in %items) joined with " * "
%lua::add [: for % in %items: add (% as lua expr)] joined with " * "
%lua::append ")"
return %lua
@ -156,45 +162,43 @@ externally [avg of %items, average of %items] all mean (..)
[unless none of %items %body, unless none of %items then %body] all parse as (..)
if (any of %items) %body
[if all of %items %body else %else, if all of %items then %body else %else] all parse \
..as (if (all of %items) %body else %else)
[if all of %items %body else %else, if all of %items then %body else %else] \
..all parse as (if (all of %items) %body else %else)
[..]
unless all of %items %body else %else, unless all of %items then %body else %else
[unless all of %items %body else %else, unless all of %items then %body else %else] \
..all parse as (if (not (all of %items)) %body else %else)
[if any of %items %body else %else, if any of %items then %body else %else] all parse \
..as (if (any of %items) %body else %else)
[if any of %items %body else %else, if any of %items then %body else %else] \
..all parse as (if (any of %items) %body else %else)
[..]
unless any of %items %body else %else, unless any of %items then %body else %else
[unless any of %items %body else %else, unless any of %items then %body else %else] \
..all parse as (if (not (any of %items)) %body else %else)
[if none of %items %body else %else, if none of %items then %body else %else] all \
..parse as (if (not (any of %items)) %body else %else)
[if none of %items %body else %else, if none of %items then %body else %else] \
..all parse as (if (not (any of %items)) %body else %else)
[..]
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] \
..all parse as (if (any of %items) %body else %else)
# 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 = %
if ((%best == (nil)) or (% < %best)): %best = %
return %best
externally [max of %items, biggest of %items, largest of %items, highest of %items] all mean:
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 = %
if ((%best == (nil)) or (% > %best)): %best = %
return %best
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:
%best = (nil)
@ -219,17 +223,14 @@ test:
# Random functions
externally (seed random with %) means:
lua> "\
..math.randomseed(\%);
for i=1,20 do math.random(); end"
lua> "math.randomseed(\%);\nfor 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 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 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))"
externally [..]
random choice from %elements, random choice %elements, random %elements

70
core/metaprogramming.nom
View File

@ -1,11 +1,9 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This File contains actions for making actions and compile-time actions and some helper
functions to make that easier.
lua> "\
..NOMSU_CORE_VERSION = 10
NOMSU_LIB_VERSION = 7"
lua> "NOMSU_CORE_VERSION = 10\nNOMSU_LIB_VERSION = 7"
lua> "\
..do
local mangle_index = 0
@ -25,7 +23,8 @@ lua> "\
..compile.action["1 ->"] = function(compile, \%args, \%body)
local lua = LuaCode("(function(")
if SyntaxTree:is_instance(\%args) and \%args.type == "Action" then \%args = \%args:get_args() end
local lua_args = table.map(\%args, function(a) return SyntaxTree:is_instance(a) and compile(a):text() or a end)
local lua_args = table.map(\%args, function(a) return SyntaxTree:is_instance(a) and compile(a):text(\
..) or a end)
lua:concat_append(lua_args, ", ")
local body_lua = SyntaxTree:is_instance(\%body) and compile(\%body) or \%body
if SyntaxTree:is_instance(\%body) and \%body.type ~= "Block" then body_lua:prepend("return ") end
@ -49,9 +48,11 @@ lua> "\
test:
(five) compiles to "5"
test:
assume ((five) == 5) or barf "Compile to expression failed."
(loc x) compiles to "local x = 99;"
test:
lua> "do"
loc x
@ -61,9 +62,11 @@ test:
(asdf) compiles to:
%tmp = ""
return (Lua %tmp)
test:
asdf
assume (%tmp is (nil)) or barf "compile to is leaking variables"
lua> "\
..compile.action["1 compiles to"] = function(compile, \%action, \%body)
local \%args = List{\(\%compile), unpack(\%action:get_args())}
@ -114,11 +117,9 @@ test:
(foo %x) means:
%y = (%x + 1)
return %y
assume ((foo 10) == 11) or barf "Action didn't work."
assume (%y is (nil)) or barf "Action leaked a local into globals."
(baz %) parses as (foo %)
assume ((foo 1) == "outer")
(%action means %body) compiles to:
@ -128,6 +129,7 @@ test:
local lua = LuaCode(fn_name, " = ", \(what (%args -> %body) compiles to))
lua:add_free_vars({fn_name})
return lua"
(%actions all mean %body) compiles to:
lua> "\
..local fn_name = \%actions[1].stub:as_lua_id()
@ -148,16 +150,20 @@ test:
return lua"
test:
externally (baz1) means: return "baz1"
externally (baz1) means:
return "baz1"
externally (baz2) means "baz2"
test:
assume ((baz1) == "baz1")
assume ((baz2) == "baz2")
(externally %action means %body) compiles to:
lua> "\
..local lua = \(what (%action means %body) compiles to)
lua:remove_free_vars({\%action.stub:as_lua_id()})
return lua"
(externally %actions all mean %body) compiles to:
lua> "\
..local lua = \(what (%actions all mean %body) compiles to)
@ -166,23 +172,25 @@ test:
test:
assume (((say %)'s meaning) == (=lua "say"))
(%action's meaning) compiles to (Lua (%action.stub as lua id))
(%action's meaning) compiles to (Lua (%action.stub as lua id))
test:
(swap %x and %y) parses as (..)
do:
%tmp = %x
%x = %y
%y = %tmp
test:
set {%1:1, %2:2}
set {%1: 1, %2: 2}
swap %1 and %2
assume ((%1 == 2) and (%2 == 1)) or barf "\
..'parse % as %' failed on 'swap % and %'"
set {%tmp:1, %tmp2:2}
set {%tmp: 1, %tmp2: 2}
swap %tmp and %tmp2
assume ((%tmp == 2) and (%tmp2 == 1)) or barf "\
..'parse % as %' variable mangling failed."
(%actions all parse as %body) compiles to:
lua> "\
..local replacements = {}
@ -197,7 +205,8 @@ test:
if replacements[t[1]] then
return replacements[t[1]]
else
return "SyntaxTree{mangle("..t[1]:as_lua().."), type="..t.type:as_lua()..", source="..tostring(t.source):as_lua().."}"
return "SyntaxTree{mangle("..t[1]:as_lua().."), type="..t.type:as_lua()..", source="..tostring(\
..t.source):as_lua().."}"
end
elseif SyntaxTree:is_instance(t) then
local ret = {}
@ -227,12 +236,10 @@ test:
local ret = \(what (%actions all compile to %new_body) compiles to)
return ret"
~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[%action parses as %body] all parse as ([%action] all parse as %body)
(%tree as lua expr) compiles to "\
..compile(\(=lua "compile(\%tree, true)"), true)"
(%tree as lua expr) compiles to "compile(\(=lua "compile(\%tree, true)"), true)"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -257,7 +264,10 @@ externally (% is %kind syntax tree) means (..)
(%tree with %t -> %replacement) compiles to "\
..\(%tree as lua expr):map(function(\(%t as lua expr))
\((%replacement as lua) if (%replacement.type == "Block") else ("return \(%replacement as lua expr)"))
\(..)
(%replacement as lua) if (%replacement.type == "Block") else "\
..return \(%replacement as lua expr)"
..
end)"
externally (%tree with vars %replacements) means (..)
@ -317,14 +327,9 @@ externally (%tree with %patt ~> %replacement) means:
end)"
test:
assume (..)
(..)
quote "\
..one
"two""
..== "\"one\\n\\\"two\\\"\""
(quote %s) compiles to "tostring(\(%s as lua expr)):as_lua()"
assume ((quote "one\n\"two\"") == "\"one\\n\\\"two\\\"\"")
(quote %s) compiles to "tostring(\(%s as lua expr)):as_lua()"
test:
assume (lua type of {}) == "table"
assume (type of {}) == "Dict"
@ -346,8 +351,8 @@ externally (type of %) means:
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] all parse as (..)
(type of %) != %type
[% isn't a %type, % isn't an %type, % is not a %type, % is not an %type] \
..all parse as ((type of %) != %type)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -357,18 +362,14 @@ test:
run "external %passed = (yes)"
assume %passed
assume (run \(return \(\(5) + \(5)))) == 10
(run %nomsu_code) compiles to "\
..run_1_in(\(%nomsu_code as lua expr), _ENV)"
(run %nomsu_code) compiles to "run_1_in(\(%nomsu_code as lua expr), _ENV)"
[compile %block, compiled %block, %block compiled] all compile to "\
..compile(\(%block as lua))"
# Return statement is wrapped in a do..end block because Lua is unhappy if you
put code after a return statement, unless you wrap it in a block.
(return %return_value) compiles to "\
..do return \(..)
=lua "\%return_value and \(%return_value as lua expr) or ''"
.. end"
..do return \(=lua "\%return_value and \(%return_value as lua expr) or ''") end"
# Literals
(yes) compiles to "true"
@ -392,5 +393,4 @@ test:
end"
externally (Nomsu version) means:
return "\
..\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)"
return "\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)"

59
core/operators.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file contains definitions of operators like "+" and "and".
use "core/metaprogramming.nom"
use "core/errors.nom"
@ -16,7 +16,6 @@ test:
(%x <= %y) compiles to "(\(%x as lua expr) <= \(%y as lua expr))"
(%x >= %y) compiles to "(\(%x as lua expr) >= \(%y as lua expr))"
[%a is %b, %a == %b] all compile to "(\(%a as lua expr) == \(%b as lua expr))"
[%a isn't %b, %a is not %b, %a not= %b, %a != %b] all compile to "\
..(\(%a as lua expr) ~= \(%b as lua expr))"
@ -38,9 +37,9 @@ test:
return lua"
test:
set {%x:10, %y:20}
set {%x: 10, %y: 20}
assume ((%x == 10) and (%y == 20)) or barf "mutli-assignment failed."
set {%x:%y, %y:%x}
set {%x: %y, %y: %x}
assume ((%y == 10) and (%x == 20)) or barf "swapping vars failed."
# Simultaneous mutli-assignments like: x,y,z = 1,x,3;
@ -48,6 +47,7 @@ test:
(set %assignments) compiles to:
assume (%assignments.type is "Dict") or barf "\
..Expected a Dict for the assignments part of '<- %' statement, not \%assignments"
lua> "\
..local lhs, rhs = LuaCode(), LuaCode()
for i, item in ipairs(\%assignments) do
@ -74,40 +74,37 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test:
set {%foozle:"outer", %y:"outer"}
set {%foozle: "outer", %y: "outer"}
externally (set global x local y) means:
external %foozle = "inner"
%y = "inner"
set global x local y
assume ((%foozle == "inner") and (%y == "outer")) or barf "external failed."
(external %var = %value) compiles to "\(%var as lua) = \(%value as lua)"
test:
set {%foozle:"outer", %y:"outer"}
set {%foozle: "outer", %y: "outer"}
externally (set global x local y) means:
with external [%foozle]:
%foozle = "inner"
%y = "inner"
set global x local y
assume ((%foozle == "inner") and (%y == "outer")) or barf "\
..'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 compile(v):text() end))"
lua> "\%body_lua:remove_free_vars(table.map(\%externs, function(v) return compile(v):text() end))"
return %body_lua
test:
set {%x:1, %y:2}
with {%z:nil, %x:999}:
set {%x: 1, %y: 2}
with {%z: nil, %x: 999}:
%z = 999
assume (%z == 999) or barf "'with' failed."
assume (%x == 999) or barf "'with' assignment failed."
assume (%x == 1) or barf "'with' scoping failed"
assume (%z == (nil)) or barf "'with' scoping failed"
(with %assignments %body) compiles to:
%lua = (%body as lua)
lua> "\
@ -132,18 +129,14 @@ test:
end
\%lua:remove_free_vars(vars)
\%lua:prepend("local ", lhs, " = ", rhs, ";\\n")"
return (..)
Lua "\
..do
\%lua
end -- 'with' block"
return (Lua "do\n \%lua\nend -- 'with' block")
# Math Operators
test:
assume ((5 wrapped around 2) == 1) or barf "mod not working"
[%x wrapped around %y, %x mod %y] all compile to (..)
"((\(%x as lua expr)) % (\(%y as lua expr)))"
[%x wrapped around %y, %x mod %y] all compile to "\
..((\(%x as lua expr)) % (\(%y as lua expr)))"
# 3-part chained comparisons
# (uses a lambda to avoid re-evaluating middle value, while still being an expression)
@ -152,10 +145,10 @@ test:
(one) means:
external %calls = (%calls + 1)
return 1
assume (0 <= (one) <= 2) or barf "Three-way chained comparison failed."
assume (%calls == 1) or barf "\
..Three-way comparison evaluated middle value multiple times"
(%x < %y < %z) parses as (..)
call ([%a, %b, %c] -> ((%a < %b) and (%b < %c))) with [%x, %y, %z]
@ -206,13 +199,21 @@ test:
fall back to bit.bor(), bit.band(), etc.
lua> "if \((is jit) or ((Lua version) == "Lua 5.2")) then"
[NOT %, ~ %] all compile to "bit.bnot(\(% as lua expr))"
[%x OR %y, %x | %y] all compile to "bit.bor(\(%x as lua expr), \(%y as lua expr))"
[%x XOR %y, %x ~ %y] all compile to "bit.bxor(\(%x as lua expr), \(%y as lua expr))"
[%x AND %y, %x & %y] all compile to "bit.band(\(%x as lua expr), \(%y as lua expr))"
[%x OR %y, %x | %y] all compile to "\
..bit.bor(\(%x as lua expr), \(%y as lua expr))"
[%x XOR %y, %x ~ %y] all compile to "\
..bit.bxor(\(%x as lua expr), \(%y as lua expr))"
[%x AND %y, %x & %y] all compile to "\
..bit.band(\(%x as lua expr), \(%y as lua expr))"
[%x LSHIFT %shift, %x << %shift] all compile to "\
..bit.lshift(\(%x as lua expr), \(%shift as lua expr))"
[%x RSHIFT %shift, %x >> %shift] all compile to "\
..bit.rshift(\(%x as lua expr), \(%shift as lua expr))"
lua> "else"
[NOT %, ~ %] all compile to "~(\(% as lua expr))"
[%x OR %y, %x | %y] all compile to "(\(%x as lua expr) | \(%y as lua expr))"
@ -220,8 +221,10 @@ lua> "else"
[%x AND %y, %x & %y] all compile to "(\(%x as lua expr) & \(%y as lua expr))"
[%x LSHIFT %shift, %x << %shift] all compile to "\
..(\(%x as lua expr) << \(%shift as lua expr))"
[%x RSHIFT %shift, %x >> %shift] all compile to "\
..(\(%x as lua expr) >> \(%shift as lua expr))"
lua> "end"
# Unary operators
@ -230,11 +233,9 @@ test:
assume ((not (yes)) == (no))
(- %) compiles to "(- \(% as lua expr))"
(not %) compiles to "(not \(% as lua expr))"
test:
assume ((size of [1, 2, 3]) == 3)
(size of %list) compiles to "(#\(%list as lua expr))"
(%list is empty) compiles to "(#\(%list as lua expr) == 0)"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

26
core/scopes.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file contains definitions pertaining to variable scoping
use "core/metaprogramming.nom"
use "core/operators.nom"
use "core/collections.nom"
@ -14,34 +14,26 @@ test:
with local %x:
%x = "inner"
assume (%x == "inner")
assume (%x == "outer")
externally (foo) means "outer foo"
with local [(foo)'s meaning]:
externally (foo) means "inner foo"
assume ((foo) == "inner foo")
assume ((foo) == "outer foo")
[with local %locals %body, with local %locals do %body] all compile to:
%body_lua = (%body as lua)
if %locals.type is:
"Dict":
%body_lua = (..)
Lua "\
..\(what (<- %locals) compiles to)
\%body_lua"
%body_lua::declare locals ("\(%.1 as lua)" for % in %locals)
%body_lua = (Lua "\(what (<- %locals) compiles to)\n\%body_lua")
%body_lua::declare locals [: for % in %locals: add "\(%.1 as lua)"]
"List":
%body_lua::declare locals ("\(% as lua)" for % in %locals)
%body_lua::declare locals [: for % in %locals: add "\(% as lua)"]
"Var" "Action":
%body_lua::declare locals ["\(%locals as lua)"]
else:
compile error at %locals "Unexpected local value"
return (..)
Lua "\
..do
\%body_lua
end"
return (Lua "do\n \%body_lua\nend")

17
core/text.nom
View File

@ -1,8 +1,8 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file contains some definitions of text escape sequences, including ANSI console
color codes.
use "core/metaprogramming.nom"
use "core/operators.nom"
use "core/control_flow.nom"
@ -27,19 +27,19 @@ test:
assume ("asdf"::with "s" -> "X") == "aXdf"
assume ("one\ntwo\n"::lines) == ["one", "two", ""]
(%spec とは %body) parses as (%spec means %body)
test:
%こんにちは = "こんにちは"
(% と言う) とは "\(%)世界"
assume (%こんにちは と言う) == "こんにちは世界"
(%expr for %match in %text matching %patt) compiles to:
define mangler
return (..)
Lua "\
..(function()
local \(mangle "comprehension") = List{}
for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(..)
%patt as lua expr
..) do
for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(%patt as lua expr)) do
\(mangle "comprehension")[#\(mangle "comprehension")+1] = \(%expr as lua)
end
return \(mangle "comprehension")
@ -50,8 +50,9 @@ test:
# 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:
with {%lua: Lua (quote %str)}:
%compile.action.%name = ([]-> %lua)
%compile.action.%name = ([] -> %lua)

34
examples/how_do_i.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
# How do I...
# Write a comment? Put a # and go till the end of the line
# How do I write a multi-line comment?
@ -65,7 +65,7 @@ say "\
Similarly, you can put a long interpolated indented value like: \(..)
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
.. between a backslash and two periods."
say "Single-line text can contain escape sequences like \", \\, \000, and \n"
# How do I define a list?
@ -91,7 +91,7 @@ say %my_list.1
# How do I define a dictionary/hash map?
One-word text keys don't need quotes, otherwise the key is an expression.
If the expression is more complex than a literal, it needs parentheses:
%my_dict = {x:101, y:2, "how many bottles":99, 653:292, (5 + 6):11}
%my_dict = {x: 101, y: 2, "how many bottles": 99, 653: 292, (5 + 6): 11}
# How do I use a dict?
# Dicts are also implemented as Lua tables, so they're accessed and modified the same way as lists
@ -113,10 +113,13 @@ if (1 > 10):
when:
(3 > 3):
say "this won't print"
(3 > 6) (3 > 5) (3 > 4):
say "this won't print because none of the conditions on the line above are true"
(3 > 2):
say "this will print"
else:
say "this is the default case"
@ -124,8 +127,10 @@ when:
if (1 + 2) is:
0 1:
say "this won't print"
2 3:
say "this will print"
else:
say "this won't print"
@ -140,7 +145,9 @@ for %i in 1 to 3:
say "For %i in 1 to 3 loop #\%i"
# This will print 0,2, and 4
for %even in 0 to 5 by 2: say "Even #\%even"
for %even in 0 to 5 by 2:
say "Even #\%even"
for %backwards in 3 to 1 by -1:
say "Backwards #\%backwards"
@ -149,7 +156,6 @@ for %backwards in 3 to 1 by -1:
repeat while (%x <= 3):
say "repeat while loop #\%x"
%x += 1
%x = 1
repeat until (%x > 3):
say "repeat until loop #\%x"
@ -160,7 +166,8 @@ repeat until (%x > 3):
repeat:
say "repeat loop #\%x"
%x += 1
if (%x > 3): stop repeating
if (%x > 3):
stop repeating
# How do I do a 'goto'?
do:
@ -168,7 +175,8 @@ do:
=== (my loop) ===
say "GOTO loop #\%x"
%x += 1
if (%x <= 3): go to (my loop)
if (%x <= 3):
go to (my loop)
say "finished going to"
# How do I define a function/method/procedure?
@ -189,8 +197,8 @@ say both "Hello" and also "world!"
%tmp = (%f1 + %f2)
%f1 = %f2
%f2 = %tmp
if (%f2 > %n): return %f2
if (%f2 > %n):
return %f2
say (first fibonacci above 10)
# Actions can have aliases, which may or may not have the arguments in different order
@ -200,7 +208,6 @@ say (first fibonacci above 10)
I like %better_things more than %worse_things
..all mean:
say "\(%better_things::capitalized) rule and \%worse_things drool!"
I like "dogs" more than "cats"
I think "chihuahuas" are worse than "corgis"
@ -208,7 +215,6 @@ I think "chihuahuas" are worse than "corgis"
(%what_she_said is what she said) means:
say %what_she_said
say "-- she said"
"Howdy pardner" is what she said
# The language only reserves []{}().,:;%#\ as special characters, so actions
@ -217,7 +223,6 @@ I think "chihuahuas" are worse than "corgis"
say %foo_bar
say %
say %1
>> "wow" $@&' --> "so flexible!" @&_~-^-~_~-^ "even numbers can be variables!" !
# There's also full unicode support
@ -243,7 +248,6 @@ say (2 + 3)
# If you need to keep going after an indented region, you can start the next line with ".."
say both "Very long first argument that needs its own line" and also "\
..short second arg"
(my favorite number) means (21 + 2)
# This can be nested:
@ -253,7 +257,6 @@ say both (my favorite number) and also "foo"
# The "lua> %" and "=lua %" macros can be used to write raw lua code:
(say the time) means:
lua> "io.write(\"The OS time is: \", os.time(), \"\\n\");"
say the time
say "Math expression result is: \(=lua "(1 + 2*3 + 3*4)^2 % 5")"
@ -270,7 +273,6 @@ say "The square root of 2 is \(square root of 2)"
return (Lua "-- Debug code:\n\(%body as lua)")
..else:
return (Lua "-- (debug code removed for production)")
%DEBUG_ENABLED = (yes)
# Constants can be defined as macros
@ -301,7 +303,6 @@ debug only:
if ((%best is (nil)) or (%key > %best_key)):
%best = %item
%best_key = %key
return %best
# Function literals look like: [%x] -> (%x * %x)
@ -323,7 +324,6 @@ say (best of [2, -3, 4, -8] according to ((% squared)'s meaning))
if ((%best is (nil)) or (%key > %best_key)):
%best = %item
%best_key = %key
return %best
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

12
lib/base64.nom
View File

@ -1,18 +1,18 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines actions for encoding/decoding base 64, as specified in:
https://tools.ietf.org/html/rfc4648
%b64_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
%reverse_b64 = (%b64_str.%i = (%i - 1) for %i in 1 to (size of %b64_str))
%reverse_b64 = {: for %i in 1 to (size of %b64_str): add %b64_str.%i = (%i - 1)}
%reverse_b64."=" = 0
test:
%cases = ["", "Zg==", "Zm8=", "Zm9v", "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy"]
for %len = %encoded in %cases:
%plain = "foobar".[1, %len - 1]
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:
@ -33,18 +33,16 @@ externally [base64 %str, base64 encode %str, %str base64] all mean:
%chars::add %b64_str.(((%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 = (%reverse_b64.(%str.%) for % in %i to (%i + 3))
%indices = [: for % in %i to (%i + 3): add %reverse_b64.(%str.%)]
%chars::add (chr ((%indices.1 << 2) + ((%indices.2 & 48) >> 4)))
if (%str.(%i + 2) == "="): stop
%chars::add (chr (((%indices.2 & 15) << 4) + ((%indices.3 & 60) >> 2)))
if (%str.(%i + 3) == "="): stop
%chars::add (chr (((%indices.3 & 3) << 6) + %indices.4))
return (%chars::joined)

21
lib/consolecolor.nom
View File

@ -1,23 +1,26 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines actions for ANSI console color escape codes.
test:
% = (bright "\(green)Color test passed.")
%colors = {..}
normal:0, "reset color":0, bright:1, bold:1, dim:2, italic:3, underscore:4
"slow blink":5, "fast blink":6, reverse:7, inverse:7, inverted:7, hidden:8
# There's some other codes, but they're not currently implemented
black:30, red:31, green:32, yellow:33, blue:34, magenta:35, cyan:36, white:37
"on black":40, "on red":41, "on green":42, "on yellow":43, "on blue":44
"on magenta":45, "on cyan":46, "on white":47
normal: 0, "reset color": 0, bright: 1, bold: 1, dim: 2, italic: 3, underscore: 4
"slow blink": 5, "fast blink": 6, reverse: 7, inverse: 7, inverted: 7
hidden: 8, # There's some other codes, but they're not currently implemented
black: 30, red: 31, green: 32, yellow: 33, blue: 34, magenta: 35, cyan: 36
white: 37, "on black": 40, "on red": 41, "on green": 42, "on yellow": 43
"on blue": 44, "on magenta": 45, "on cyan": 46, "on white": 47
for %name = %colornum in %colors:
%colornum = "\%colornum"
#(=lua "COMPILE_ACTIONS").%name = (..)
[%nomsu, %tree] -> (Lua "'\\027[\(%colornum)m'")
%compile.action.%name = (..)
[%nomsu, %text] ->:
if %text:
return (Lua "('\\027[\(%colornum)m'..\(%text as lua expr)..'\\027[0m')")
..else: return (Lua "'\\027[\(%colornum)m'")
..else:
return (Lua "'\\027[\(%colornum)m'")

13
lib/file_hash.nom
View File

@ -1,14 +1,13 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines some actions for hashing files and looking up files by hash.
use "lib/os.nom"
use "lib/base64.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lua> "local \%use_sha1, \%hashlib = pcall(require, 'openssl.digest')"
test:
assume (hash "hello world") == (hash "hello world")
assume ((hash "hello world") != (hash "goodbye")) or barf "\
@ -25,16 +24,17 @@ test:
assume ((hash "\000") != (hash "\000\000\000\000\000")) or barf "\
..Incorrect hashing of null strings"
if %use_sha1:
assume ((hash "hello world") == "Kq5sNclPz7QV2+lfQIuc6R7oRu0=")
if %use_sha1:
externally (hash %) means:
%hash = (=lua "\%hashlib.new('sha1'):final(\%)")
return (base64 %hash)
..else:
# TODO: remove warning?
say "\
..\027[31;1mWARNING: OpenSSL module not found. Defaulting to a non-cryptographically secure hash function.\027[0m"
say "\027[31;1mWARNING: OpenSSL module not found. Defaulting to a non-cryptographically secure hash function.\027[0m"
externally (hash %) means:
%bytes = (%::bytes)
%hash = (%bytes.1 << 7)
@ -47,6 +47,7 @@ externally (file with hash %hash) means:
for file %filename in ".":
%contents = (read file %filename)
%file_hash = (hash %contents)
if (%file_hash == %hash): return %filename
if (%file_hash == %hash):
return %filename
(hash of file %filename) parses as (hash (read file %filename))

42
lib/object.nom
View File

@ -1,25 +1,27 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file contains the implementation of an Object-Oriented programming system.
%globals.METAMETHOD_MAP = {..}
"as text":"__tostring", "clean up":"__gc", "+ 1":"__add", "- 1":"__sub"
"* 1":"__mul", "/ 1":"__div", "-":"__unm", "// 1":"__idiv", "mod 1":"__mod"
"^ 1":"__pow", "& 1":"__band", "| 1":"__bor", "~ 1":"__bxor", "~":"__bnot"
"<< 1":"__bshl", ">> 1":"__bshr", "== 1":"__eq", "< 1":"__lt", "<= 1":"__le"
"set 1 = 2":"__newindex", size:"__len", iterate:"__ipairs", "iterate all":"__pairs"
"as text": "__tostring", "clean up": "__gc", "+ 1": "__add", "- 1": "__sub"
"* 1": "__mul", "/ 1": "__div", "-": "__unm", "// 1": "__idiv", "mod 1": "__mod"
"^ 1": "__pow", "& 1": "__band", "| 1": "__bor", "~ 1": "__bxor", "~": "__bnot"
"<< 1": "__bshl", ">> 1": "__bshr", "== 1": "__eq", "< 1": "__lt", "<= 1": "__le"
"set 1 = 2": "__newindex", size: "__len", iterate: "__ipairs"
"iterate all": "__pairs"
test:
object (Dog):
(Dog).genus = "Canus"
my action [set up]: %me.barks or= 0
my action [set up]:
%me.barks or= 0
my action [bark, woof]:
%barks = ("Bark!" for % in 1 to %me.barks)
%barks = [: for % in 1 to %me.barks: add "Bark!"]
return (%barks::joined with " ")
my action [get pissed off]: %me.barks += 1
%d = (Dog {barks:2})
%d = (Dog {barks: 2})
assume (type of %d) == "Dog"
assume (%d is a "Dog")
assume %d.barks == 2
@ -34,31 +36,31 @@ test:
assume (%d.barks == 3)
%d2 = (Dog {})
assume (%d2.barks == 0) or barf "Default initializer failed"
with {%d:Dog {barks:1}}:
with {%d: Dog {barks: 1}}:
assume ((%d::bark) == "Bark!")
object (Corgi) extends (Dog):
my action [sploot] "splooted"
my action [bark, woof]:
%barks = ("Yip!" for % in 1 to %me.barks)
%barks = [: for % in 1 to %me.barks: add "Yip!"]
return (%barks::joined with " ")
%corg = (Corgi {})
assume (%corg.barks == 0)
with {%d:Corgi {barks:1}}:
with {%d: Corgi {barks: 1}}:
assume ((%d::sploot) == "splooted") or barf "subclass method failed"
assume ((%d::bark) == "Yip!") or barf "inheritance failed"
assume ((%d::woof) == "Yip!")
with {%d:Dog {barks:2}}:
with {%d: Dog {barks: 2}}:
assume ((%d::bark) == "Bark! Bark!")
(my action %actions %body) compiles to:
lua> "\
..local fn_name = \%actions[1].stub:as_lua_id()
local \%args = List(\%actions[1]:get_args())
table.insert(\%args, 1, \(\%me))
local lua = LuaCode("class.", fn_name, " = ", \(..)
what (%args -> %body) compiles to
..)
local lua = LuaCode("class.", fn_name, " = ", \(what (%args -> %body) compiles to))
for i=2,#\%actions do
local alias = \%actions[i]
local alias_name = alias.stub:as_lua_id()
@ -75,7 +77,9 @@ test:
(object %classname extends %parent %class_body) compiles to:
unless (%classname.type == "Action"):
compile error at %classname "Expected this to be an action, not a \(%classname.type)"
compile error at %classname "\
..Expected this to be an action, not a \%classname.type"
for % in %classname:
unless (% is text):
compile error at % "Class names should not have arguments."

19
lib/os.nom
View File

@ -1,9 +1,10 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file defines some actions that interact with the operating system and filesystem.
test:
path of Nomsu file "lib/os.nom"
externally (path of Nomsu file %filename) means:
lua> "for i,f in Files.walk(\%filename) do return f end"
barf "Could not find file: \%filename"
@ -17,10 +18,11 @@ externally (sh> %cmd) means:
test:
read file "lib/os.nom"
externally (read file %filename) means (=lua "Files.read(\%filename)")
externally (read file %filename) means (=lua "Files.read(\%filename)")
test:
for file %f in "core": do nothing
(for file %f in %path %body) compiles to "\
..for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
\(%body as lua)
@ -49,23 +51,28 @@ externally [..]
test:
assume (line number of 3 in "x\ny") == 2
externally (line number of %pos in %str) means (..)
=lua "Files.get_line_number(\%str, \%pos)"
test:
assume (line 2 in "one\ntwo\nthree") == "two"
externally (line %line_num in %str) means (..)
=lua "Files.get_line(\%str, \%line_num)"
test:
assume (source lines of \(this))
externally (source lines of %tree) means:
%source = (%tree.source if (%tree is syntax tree) else %tree)
%file = (read file %source.filename)
return (..)
(..)
(line % in %file) for % in (line number of %source.start in %file) to (..)
line number of %source.stop in %file
[..]
:
for % in (line number of %source.start in %file) to (..)
line number of %source.stop in %file
..: add (line % in %file)
..::joined with "\n"
externally (spoof file %text) means (%Files.spoof %text)

60
lib/things.nom
View File

@ -1,28 +1,26 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
A library for simple object oriented programming.
%globals.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": "__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"
test:
a (Dog) is a thing:
that can (set up) by:
%its.barks or= 0
whose [bark, woof] all mean:
%barks = ("Bark!" for % in 1 to %its.barks)
%barks = [: for % in 1 to %its.barks: add "Bark!"]
return (%barks::joined with " ")
that can (get pissed off) by:
%its.barks += 1
that can (get pissed off) by: %its.barks += 1
(Dog).genus = "Canus"
%d = (a Dog with {barks:2})
%d = (a Dog with {barks: 2})
assume (type of %d) == "Dog"
assume (%d is a "Dog")
assume %d.barks == 2
@ -37,36 +35,37 @@ test:
assume (%d.barks == 3)
%d2 = (a Dog)
assume (%d2.barks == 0) or barf "Default initializer failed"
with {%d:a Dog with {barks:1}}:
with {%d: a Dog with {barks: 1}}:
assume ((%d::bark) == "Bark!")
a (Corgi) is a thing:
that can [set up, get pissed off] like a (Dog)
whose (sploot) means "splooted"
whose [bark, woof] all mean:
%barks = ("Yip!" for % in 1 to %its.barks)
%barks = [: for % in 1 to %its.barks: add "Yip!"]
return (%barks::joined with " ")
%corg = (a Corgi)
assume (%corg.barks == 0)
with {%d:a Corgi with {barks:1}}:
with {%d: a Corgi with {barks: 1}}:
assume ((%d::sploot) == "splooted") or barf "subclass method failed"
assume ((%d::bark) == "Yip!") or barf "inheritance failed"
assume ((%d::woof) == "Yip!")
with {%d:a Dog with {barks:2}}:
with {%d: a Dog with {barks: 2}}:
assume ((%d::bark) == "Bark! Bark!")
[..]
that can %actions by %body,
whose %actions means %body, whose %actions all mean %body,
that can %actions by %body, whose %actions means %body
whose %actions all mean %body
..all compile to:
unless (%actions.type == "List"): %actions = [%actions]
unless (%actions.type == "List"):
%actions = [%actions]
lua> "\
..local fn_name = \%actions[1].stub:as_lua_id()
local \%args = List{\(\%its), unpack(\%actions[1]:get_args())}
local lua = LuaCode("class.", fn_name, " = ", \(..)
what (%args -> %body) compiles to
..)
local lua = LuaCode("class.", fn_name, " = ", \(what (%args -> %body) compiles to))
for i=2,#\%actions do
local alias = \%actions[i]
local alias_name = alias.stub:as_lua_id()
@ -85,8 +84,8 @@ test:
return lua"
[..]
that can %actions like a %class, that can %actions like an %class,
that has %actions like a %class, that has %actions like an %class,
that can %actions like a %class, that can %actions like an %class
that has %actions like a %class, that has %actions like an %class
..all compile to:
%lua = (Lua "")
%class_expr = (%class as lua expr)
@ -96,13 +95,15 @@ test:
%lua::add %lines joined with "\n"
return %lua
(a %classname is a thing with %members %class_body) compiles to:
unless (%classname.type == "Action"):
compile error at %classname "Expected this to be an action, not a \(%classname.type)"
compile error at %classname "\
..Expected this to be an action, not a \%classname.type"
for % in %classname:
unless (% is text):
compile error at % "Class names should not have arguments."
return (..)
Lua "\
..do
@ -142,4 +143,5 @@ test:
end
end"
(a %classname is a thing %class_body) parses as (a %classname is a thing with (nil) %class_body)
(a %classname is a thing %class_body) parses as (..)
a %classname is a thing with (nil) %class_body

11
lib/training_wheels.nom
View File

@ -1,13 +1,12 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
This file contains a set of definitions that bring some familiar language features
from other languages into nomsu (e.g. "||" and "continue")
(%a === %b) parses as ((%a 's id) is (%b 's id))
(%a !== %b) parses as ((%a 's id) is not (%b 's id))
(%a === %b) parses as ((%a's id) is (%b's id))
(%a !== %b) parses as ((%a's id) is not (%b's id))
[function %names %body, def %names %body] all parse as (..)
externally %names means %body
(switch %branch_value %body) parses as (if %branch_value is %body)
[None, Null] all parse as (nil)
[True, true] all parse as (yes)
@ -17,7 +16,7 @@
(%a && %b) parses as (%a and %b)
(continue) parses as (do next)
(break) parses as (stop)
(let %thing = %value in %action) parses as (with local {%thing:%value})
(let %thing = %value in %action) parses as (with local {%thing: %value})
[print %, println %] all parse as (say %)
[error!, panic!, fail!, abort!] all parse as (barf!)
[error %, panic %, fail %, abort %] all parse as (barf %)

2
lib/version.nom
View File

@ -1,3 +1,3 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
# This file sets the current library version.
lua> "NOMSU_LIB_VERSION = 7"

7
tools/autoformat.nom
View File

@ -1,10 +1,10 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
Auto-format Nomsu code. Usage:
nomsu tools/autoformat.nom [-i] file1 file2 directory1 ...
If the first argument is "-i", modifications will be performed in-place. Otherwise,
the formatted code will be printed.
use "lib/os.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -24,4 +24,5 @@ for %path in %args:
if %inplace:
write %formatted to file %filename
..else: say %formatted
..else:
say %formatted

19
tools/find_action.nom
View File

@ -3,7 +3,7 @@
Find an action by its stub. Usage:
nomsu tools/find_action.nom "foo %" file1 file2 directory1 ...
Will print all the code locations and code that uses the stub.
use "lib/os.nom"
use "lib/consolecolor.nom"
@ -22,19 +22,20 @@ for %path in %files:
..and if it barfs %msg:
say (red "\%filename failed to parse:\n\%msg")
%tree = (nil)
unless %tree: do next %filename
unless %tree:
do next %filename
%results = []
for %t in recursive %tree:
if ((%t is "Action" syntax tree) and (%t.stub is %stub)):
%line_num = (line number of %t.source.start in %file)
%results::add {..}
line: %line_num
text: "\
..\(blue "\%filename:\%line_num:")
\(yellow (source lines of %t))"
line: %line_num, text: "\(blue "\%filename:\%line_num:")\n\(yellow (source lines of %t))"
if (%t is syntax tree):
for %sub in %t: recurse %t on %sub
for %sub in %t:
recurse %t on %sub
sort %results by % -> %.line
for % in %results: say %.text
for % in %results:
say %.text

9
tools/parse.nom
View File

@ -1,8 +1,8 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
Tool to print out a parse tree of files in an easy-to-read format. Usage:
nomsu tools/parse.nom file1 file2 directory1 ...
use "lib/os.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -21,14 +21,17 @@ externally (print tree %t at indent %indent) means:
"Number":
say "\%indent\(%t.1)"
"Var":
say "\(%indent)%\(%t.1)"
else:
say "\%indent\(%t.type):"
for %arg in %t:
if:
when:
(%arg is syntax tree):
print tree %arg at indent "\%indent "
else:
say "\%indent \(quote %arg)"

22
tools/repl.nom
View File

@ -1,12 +1,13 @@
#!/usr/bin/env nomsu -V4
#!/usr/bin/env nomsu -V4.10.12.7
use "lib/consolecolor.nom"
use "lib/os.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[quit, exit] all mean: lua> "os.exit(0)"
externally [quit, exit] all mean:
lua> "os.exit(0)"
(help) means:
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.
@ -15,7 +16,7 @@ use "lib/os.nom"
say "\
..
\(bright)\(underscore)Welcome to the Nomsu v\(Nomsu version) interactive console!\(reset color)
press 'enter' twice to run a command
press 'enter' twice to run a command
"
%repl_line = 0
@ -33,29 +34,28 @@ repeat:
go to (run buffer)
%buff::add (%line::with "\t" -> " ")
%io.write (dim (yellow ".. "))
=== (run buffer) ===
if ((size of %buff) == 0):
stop
if ((size of %buff) == 0): stop
%buff = (%buff::joined)
# TODO: support local variables
spoof file %buff
try:
%ret = (run %buff)
..and if it barfs %err:
say %err
..and if it barfs %err: say %err
..or if it succeeds:
if (type of %ret) is:
"nil":
do nothing
"boolean":
say "= \("yes" if %ret else "no")"
"table":
if %ret.as_nomsu:
say "= \(%ret::as nomsu)"
..else:
say "= \%ret"
else:
say "= \%ret"

9
tools/replace.nom
View File

@ -1,10 +1,10 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
Tool to find and replace one tree with another.
nomsu tools/replace.nom [-i] tree_to_replace replacement file1 file2 directory1 ...
If "-i" is the first argument, replacements will be performed in-place. Otherwise, the
upgraded code will be printed.
use "lib/os.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -35,9 +35,10 @@ for %path in %args:
..#!/usr/bin/env nomsu -V\(%tree.version or (Nomsu version))
\(%tree2 as nomsu)"
if:
when:
%inplace:
say "Replaced in \%filename"
write %text to file %filename
else: say %text
else:
say %text

12
tools/test.nom
View File

@ -1,8 +1,8 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
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 ...
use "lib/os.nom"
use "lib/consolecolor.nom"
@ -17,16 +17,15 @@ if (%args.1 == "-v"):
for %path in (command line args):
for file %filename in %path:
if (%filename::matches "%.nom$"): use %filename
for %path in (command line args): use %path
%tests = ((=lua "Source:from_string(\%s)") = %t for %s = %t in (tests))
%tests = {: for %s = %t in (tests): add (=lua "Source:from_string(\%s)") = %t}
for %path in (command line args):
for file %filename in %path:
unless (%filename::matches "%.nom$"): do next %filename
%file_tests = []
for %src = %test in %tests:
if (%src.filename == %filename):
%file_tests::add {test:%test, source:%src}
%file_tests::add {test: %test, source: %src}
unless (%file_tests is empty):
sort %file_tests by % -> %.source
@ -37,6 +36,7 @@ for %path in (command line args):
say " \(yellow (%.test::with "\n" -> "\n "))"
run %.test
if %verbose: say (green "PASS")
if %verbose:
say (green "PASS")
..else:
say "\r[\(green "PASS")"

11
tools/upgrade.nom
View File

@ -1,10 +1,10 @@
#!/usr/bin/env nomsu -V4.8.10
#!/usr/bin/env nomsu -V4.10.12.7
#
Tool to automatically update code from old versions of Nomsu. Usage:
nomsu tools/upgrade.nom [-i] file1 file2 directory1 ...
If "-i" is the first argument, upgrades will be performed in-place. Otherwise, the
upgraded code will be printed.
use "compatibility"
use "lib/os.nom"
@ -44,9 +44,9 @@ for %path in %args:
%code = (%NomsuCode::from (%Source %filename 1 (size of %file)) %file)
%tree = (%code parsed)
%uptree = (..)
%tree upgraded from (%start_version or (%tree.version or (Nomsu version))) to %version
%tree upgraded from (%start_version or (%tree.version or (Nomsu version))) to \
..%version
%text = ((%uptree as nomsu)::text)
when:
%inplace:
say "Upgraded \%filename"
@ -58,4 +58,5 @@ for %path in %args:
..else:
say (bright "\%filename will be changed")
else: say %text
else:
say %text