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

More major overhaulage.

Browse Source
This commit is contained in:
Bruce Hill 2017-09-18 22:41:50 -07:00
parent 15886aa579
commit 2c4acdfe67
7 changed files with 621 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

363
core.nom
View File

@ -1,10 +1,14 @@
# Rule for making rules # Rule for making rules
lua block ".." lua block ".."
|compiler:def("rule %spec = %body", function(compiler, vars) |compiler:defmacro("rule %spec = %body", function(compiler, vars, kind)
| return compiler:def(vars.spec, vars.body) | if kind == "Expression" then
| compiler:error("Cannot use rule definitions as an expression.")
| end
| local spec = compiler:get_invocations_from_definition(vars.spec.value, vars)
| return ("compiler:def("..compiler.utils.repr(spec,true)..", "..compiler:tree_to_lua(vars.body, vars)..")"), true
|end) |end)
rule "help %invocation" =: rule: help %invocation ..=:
lua block ".." lua block ".."
|local fn_info = compiler.defs[vars.invocation] |local fn_info = compiler.defs[vars.invocation]
|if not fn_info then |if not fn_info then
@ -16,7 +20,7 @@ rule "help %invocation" =:
# Macros # Macros
lua block ".." lua block ".."
|local add_macro = function(compiler, vars, kind) |local add_macro = function(compiler, vars, kind)
| local spec = compiler:tree_to_value(vars.spec, vars) | local spec = compiler:get_invocations_from_definition(vars.spec.value, vars)
| local fn = compiler:tree_to_value(vars.body, vars) | local fn = compiler:tree_to_value(vars.body, vars)
| compiler:defmacro(spec, fn, vars.body.src) | compiler:defmacro(spec, fn, vars.body.src)
| return "", true | return "", true
@ -24,7 +28,7 @@ lua block ".."
|compiler:defmacro("macro %spec = %body", add_macro) |compiler:defmacro("macro %spec = %body", add_macro)
| |
|local add_macro_block = function(compiler, vars, kind) |local add_macro_block = function(compiler, vars, kind)
| local spec = compiler:tree_to_value(vars.spec, vars) | local spec = compiler:get_invocations_from_definition(vars.spec.value, vars)
| local fn = compiler:tree_to_value(vars.body, vars) | local fn = compiler:tree_to_value(vars.body, vars)
| local wrapper = function(compiler, vars, kind) | local wrapper = function(compiler, vars, kind)
| if kind == "Expression" then | if kind == "Expression" then
@ -38,53 +42,56 @@ lua block ".."
|compiler:defmacro("macro block %spec = %body", add_macro_block) |compiler:defmacro("macro block %spec = %body", add_macro_block)
# Compiler tools # Compiler tools
rule ["eval %code", "run %code"] =: rule:
eval %code
run %code
..=:
lua expr "compiler:run(vars.code)" lua expr "compiler:run(vars.code)"
macro "source code %code" =: macro: source code %code ..=:
lua block ".." lua block ".."
|if vars.code.value.type ~= "Thunk" then |if vars.code.value.type ~= "Thunk" then
| compiler:error("'source code %' only takes code blocks, not "..vars.code.value.type) | compiler:error("'source code %' only takes code blocks, not "..vars.code.value.type)
|end |end
lua expr "compiler.utils.repr(vars.code.value.value.src, true)" lua expr "compiler.utils.repr(vars.code.value.value.src, true)"
rule "run file %filename" =: rule: run file %filename ..=:
lua block ".." lua block ".."
|local file = io.open(vars.filename) |local file = io.open(vars.filename)
|return compiler:run(file:read("*a")) |return compiler:run(file:read("*a"))
# Error functions # Error functions
rule "error!" =: rule: error! ..=:
lua block ".." lua block ".."
|table.remove(compiler.callstack) |table.remove(compiler.callstack)
|compiler:error() |compiler:error()
rule "error %msg" =: rule: error %msg ..=:
lua block ".." lua block ".."
|table.remove(compiler.callstack) |table.remove(compiler.callstack)
|compiler:error(vars.msg) |compiler:error(vars.msg)
macro "as lua %block" =: macro: as lua %block ..=:
lua expr "compiler.utils.repr(compiler:tree_to_lua(vars.block.value.value, vars), true)" lua expr "compiler.utils.repr(compiler:tree_to_lua(vars.block.value.value, vars), true)"
macro block "show generated lua %block" =: macro block: show generated lua %block ..=:
".."|compiler:writeln(\lua expr "compiler.utils.repr(compiler:tree_to_lua(vars.block.value.value, vars), true)"\) ".."|compiler:writeln(\lua expr "compiler.utils.repr(compiler:tree_to_lua(vars.block.value.value, vars), true)"\)
# Macro helper functions # Macro helper functions
rule "%tree as value" =: rule: %tree as value ..=:
lua expr ".." lua expr ".."
|compiler:tree_to_value(vars.tree, vars) |compiler:tree_to_value(vars.tree, vars)
rule "%tree as lua block" =: rule: %tree as lua block ..=:
lua block ".." lua block ".."
|return compiler:tree_to_lua(vars.tree, 'Statement'), true |return compiler:tree_to_lua(vars.tree, 'Statement'), true
rule "%tree as lua expr" =: rule: %tree as lua expr ..=:
lua expr ".." lua expr ".."
|compiler:tree_to_lua(vars.tree, 'Expression') |compiler:tree_to_lua(vars.tree, 'Expression')
# Moonscript! # Moonscript!
macro block "moonscript block %moonscript_code" =: macro block: moonscript block %moonscript_code ..=:
lua block ".." lua block ".."
|local parse, compile = require('moonscript.parse'), require('moonscript.compile') |local parse, compile = require('moonscript.parse'), require('moonscript.compile')
|local moon_code = compiler:tree_to_value(vars.moonscript_code, vars) |local moon_code = compiler:tree_to_value(vars.moonscript_code, vars)
@ -98,7 +105,7 @@ macro block "moonscript block %moonscript_code" =:
|end |end
|return "do\\n"..lua_code.."\\nend" |return "do\\n"..lua_code.."\\nend"
macro "moonscript %moonscript_code" =: macro: moonscript %moonscript_code ..=:
lua block ".." lua block ".."
|local parse, compile = require('moonscript.parse'), require('moonscript.compile') |local parse, compile = require('moonscript.parse'), require('moonscript.compile')
|local moon_code = compiler:tree_to_value(vars.moonscript_code, vars) |local moon_code = compiler:tree_to_value(vars.moonscript_code, vars)
@ -113,24 +120,27 @@ macro "moonscript %moonscript_code" =:
|return "(function(compiler, vars)\\n"..lua_code.."\\nend)(compiler, vars)" |return "(function(compiler, vars)\\n"..lua_code.."\\nend)(compiler, vars)"
# String functions # String functions
rule "join %strs" =: rule: join %strs ..=:
lua block ".." lua block ".."
|local str_bits = {} |local str_bits = {}
|for i,bit in ipairs(vars.strs) do str_bits[i] = compiler.utils.repr(bit) end |for i,bit in ipairs(vars.strs) do str_bits[i] = compiler.utils.repr(bit) end
|return table.concat(str_bits) |return table.concat(str_bits)
rule "join %strs with glue %glue" =: rule: join %strs with glue %glue ..=:
lua block ".." lua block ".."
|local str_bits = {} |local str_bits = {}
|for i,bit in ipairs(vars.strs) do str_bits[i] = compiler.utils.repr(bit) end |for i,bit in ipairs(vars.strs) do str_bits[i] = compiler.utils.repr(bit) end
|return table.concat(str_bits, vars.glue) |return table.concat(str_bits, vars.glue)
rule ["capitalize %str", "%str capitalized"] =: rule:
capitalize %str
%str capitalized
..=:
lua expr ".."|vars.str:gsub("%l", string.upper, 1) lua expr ".."|vars.str:gsub("%l", string.upper, 1)
# Variable assignment # Variable assignment
#.. #..
macro block "%var = %value" =: macro block: %var = %value ..=:
lua block ".." lua block ".."
|if vars.var.value.type ~= "Var" then |if vars.var.value.type ~= "Var" then
| compiler:error("Assignment operation has the wrong type for the left hand side. " | compiler:error("Assignment operation has the wrong type for the left hand side. "
@ -138,81 +148,107 @@ rule ["capitalize %str", "%str capitalized"] =:
|end |end
".."|\%var as lua expr\ = \%value as lua expr\ ".."|\%var as lua expr\ = \%value as lua expr\
macro block "%var = %value" =: lua block ".."
lua block ".." |local function helper(callback)
|if vars.var.value.type ~= "Var" then | return function(compiler, vars, kind)
| compiler:error("Assignment operation has the wrong type for the left hand side. " | if kind == "Expression" then
| .."Expected Var, but got: "..vars.var.value.type) | compiler:error("Cannot use an assignment operation as an expression value.")
|end | end
lua block ".." | if vars.var.value.type ~= "Var" then
|if vars.value.value.type ~= "Thunk" then | compiler:error("Assignment operation has the wrong type for the left hand side. "
| compiler:error("Assignment operation has the wrong type for the right hand side. " | .."Expected Var, but got: "..vars.var.value.type)
| .."Expected Thunk, but got: "..vars.value.value.type.."\\nMaybe you used '=' instead of '=:'?") | end
|end | if vars.value.value.type ~= "Thunk" then
".."|do | compiler:error("Assignment operation has the wrong type for the right hand side. "
| local ret | .."Expected Thunk, but got: "..vars.value.value.type.."\\nMaybe you used '=' instead of '=:'?")
| \lua expr "compiler:tree_to_lua(vars.value.value.value, 'Statement')"\ | end
| \%var as lua expr\ = ret | local ret = "do\\n local ret"
|end | ret = ret .. "\\n "..compiler:tree_to_lua(vars.value.value.value, "Statement")
| ret = ret .. "\\n "..callback(compiler:tree_to_lua(vars.var, "Expression"))
| return (ret.."\\nend"), true
| end
|end
|compiler:defmacro("%var = %value", helper(function(var) return var.." = ret" end))
|compiler:defmacro("%var += %value", helper(function(var) return var.." = "..var.." + ret" end))
|compiler:defmacro("%var -= %value", helper(function(var) return var.." = "..var.." - ret" end))
|compiler:defmacro("%var *= %value", helper(function(var) return var.." = "..var.." * ret" end))
|compiler:defmacro("%var /= %value", helper(function(var) return var.." = "..var.." / ret" end))
|compiler:defmacro("%var ^= %value", helper(function(var) return var.." = "..var.." ^ ret" end))
|compiler:defmacro("%var and= %value", helper(function(var) return var.." = "..var.." and ret" end))
|compiler:defmacro("%var or= %value", helper(function(var) return var.." = "..var.." or ret" end))
|compiler:defmacro("%var concat= %value", helper(function(var) return var.." = "..var.." .. ret" end))
|compiler:defmacro("%var mod= %value", helper(function(var) return var.." = "..var.." % ret" end))
# Operators # Operators
macro ["true","yes"] =: "true" macro:
macro ["false","no"] =: "false" true
macro ["nil","null"] =: "nil" yes
macro block ["nop", "pass"] =: "" ..=: "true"
macro "%a + %b" =: ".."|(\%a as lua expr\ + \%b as lua expr\) macro:
macro "%a + %b + %c" =: ".."|(\%a as lua expr\ + \%b as lua expr\ + \%c as lua expr\) false
macro "%a + %b + %c + %d" =: ".."|(\%a as lua expr\ + \%b as lua expr\ + \%c as lua expr\ + \%d as lua expr\) no
macro "%a - %b" =: ".."|(\%a as lua expr\ - \%b as lua expr\) ..=: "false"
macro "%a * %b" =: ".."|(\%a as lua expr\ * \%b as lua expr\) macro:
macro "%a * %b * %c" =: ".."|(\%a as lua expr\ * \%b as lua expr\ * \%c as lua expr\) nil
macro "%a * %b * %c * %d" =: ".."|(\%a as lua expr\ * \%b as lua expr\ * \%c as lua expr\ * \%d as lua expr\) null
macro "%a / %b" =: ".."|(\%a as lua expr\ / \%b as lua expr\) ..=: "nil"
macro "%a === %b" =: ".."|(\%a as lua expr\ == \%b as lua expr\) macro block:
macro "%a !== %b" =: ".."|(\%a as lua expr\ ~= \%b as lua expr\) nop
macro "%a < %b" =: ".."|(\%a as lua expr\ < \%b as lua expr\) pass
macro "%a < %b < %c" =: ".."|((\%a as lua expr\ < \%b as lua expr\) and (\%b as lua expr\ < \%c as lua expr\)) ..=: ""
macro "%a <= %b < %c" =: ".."|((\%a as lua expr\ <= \%b as lua expr\) and (\%b as lua expr\ < \%c as lua expr\)) macro: %a + %b ..=: ".."|(\%a as lua expr\ + \%b as lua expr\)
macro "%a <= %b <= %c" =: ".."|((\%a as lua expr\ <= \%b as lua expr\) and (\%b as lua expr\ <= \%c as lua expr\)) macro: %a + %b + %c ..=: ".."|(\%a as lua expr\ + \%b as lua expr\ + \%c as lua expr\)
macro "%a < %b <= %c" =: ".."|((\%a as lua expr\ < \%b as lua expr\) and (\%b as lua expr\ <= \%c as lua expr\)) macro: %a + %b + %c + %d ..=: ".."|(\%a as lua expr\ + \%b as lua expr\ + \%c as lua expr\ + \%d as lua expr\)
macro "%a > %b > %c" =: ".."|((\%a as lua expr\ > \%b as lua expr\) and (\%b as lua expr\ > \%c as lua expr\)) macro: %a - %b ..=: ".."|(\%a as lua expr\ - \%b as lua expr\)
macro "%a >= %b > %c" =: ".."|((\%a as lua expr\ >= \%b as lua expr\) and (\%b as lua expr\ > \%c as lua expr\)) macro: %a * %b ..=: ".."|(\%a as lua expr\ * \%b as lua expr\)
macro "%a >= %b >= %c" =: ".."|((\%a as lua expr\ >= \%b as lua expr\) and (\%b as lua expr\ >= \%c as lua expr\)) macro: %a * %b * %c ..=: ".."|(\%a as lua expr\ * \%b as lua expr\ * \%c as lua expr\)
macro "%a > %b >= %c" =: ".."|((\%a as lua expr\ > \%b as lua expr\) and (\%b as lua expr\ >= \%c as lua expr\)) macro: %a * %b * %c * %d ..=: ".."|(\%a as lua expr\ * \%b as lua expr\ * \%c as lua expr\ * \%d as lua expr\)
macro "%a <= %b" =: ".."|(\%a as lua expr\ <= \%b as lua expr\) macro: %a / %b ..=: ".."|(\%a as lua expr\ / \%b as lua expr\)
macro "%a > %b" =: ".."|(\%a as lua expr\ > \%b as lua expr\) macro: %a === %b ..=: ".."|(\%a as lua expr\ == \%b as lua expr\)
macro "%a >= %b" =: ".."|(\%a as lua expr\ >= \%b as lua expr\) macro: %a !== %b ..=: ".."|(\%a as lua expr\ ~= \%b as lua expr\)
macro "%a ^ %b" =: ".."|(\%a as lua expr\ ^ \%b as lua expr\) macro: %a < %b ..=: ".."|(\%a as lua expr\ < \%b as lua expr\)
macro "%a and %b" =: ".."|(\%a as lua expr\ and \%b as lua expr\) macro: %a < %b < %c ..=: ".."|((\%a as lua expr\ < \%b as lua expr\) and (\%b as lua expr\ < \%c as lua expr\))
macro "%a and %b and %c" =: macro: %a <= %b < %c ..=: ".."|((\%a as lua expr\ <= \%b as lua expr\) and (\%b as lua expr\ < \%c as lua expr\))
macro: %a <= %b <= %c ..=: ".."|((\%a as lua expr\ <= \%b as lua expr\) and (\%b as lua expr\ <= \%c as lua expr\))
macro: %a < %b <= %c ..=: ".."|((\%a as lua expr\ < \%b as lua expr\) and (\%b as lua expr\ <= \%c as lua expr\))
macro: %a > %b > %c ..=: ".."|((\%a as lua expr\ > \%b as lua expr\) and (\%b as lua expr\ > \%c as lua expr\))
macro: %a >= %b > %c ..=: ".."|((\%a as lua expr\ >= \%b as lua expr\) and (\%b as lua expr\ > \%c as lua expr\))
macro: %a >= %b >= %c ..=: ".."|((\%a as lua expr\ >= \%b as lua expr\) and (\%b as lua expr\ >= \%c as lua expr\))
macro: %a > %b >= %c ..=: ".."|((\%a as lua expr\ > \%b as lua expr\) and (\%b as lua expr\ >= \%c as lua expr\))
macro: %a <= %b ..=: ".."|(\%a as lua expr\ <= \%b as lua expr\)
macro: %a > %b ..=: ".."|(\%a as lua expr\ > \%b as lua expr\)
macro: %a >= %b ..=: ".."|(\%a as lua expr\ >= \%b as lua expr\)
macro: %a ^ %b ..=: ".."|(\%a as lua expr\ ^ \%b as lua expr\)
macro: %a and %b ..=: ".."|(\%a as lua expr\ and \%b as lua expr\)
macro: %a and %b and %c ..=:
".."|(\%a as lua expr\ and \%b as lua expr\ and \%c as lua expr\) ".."|(\%a as lua expr\ and \%b as lua expr\ and \%c as lua expr\)
macro "%a and %b and %c and %d" =: macro: %a and %b and %c and %d ..=:
".."|(\%a as lua expr\ and \%b as lua expr\ and \%c as lua expr\ and \%d as lua expr\) ".."|(\%a as lua expr\ and \%b as lua expr\ and \%c as lua expr\ and \%d as lua expr\)
macro "%a or %b" =: ".."|(\%a as lua expr\ or \%b as lua expr\) macro: %a or %b ..=: ".."|(\%a as lua expr\ or \%b as lua expr\)
macro "%a or %b or %c" =: macro: %a or %b or %c ..=:
".."|(\%a as lua expr\ or \%b as lua expr\ or \%c as lua expr\) ".."|(\%a as lua expr\ or \%b as lua expr\ or \%c as lua expr\)
macro "%a or %b or %c or %d" =: macro: %a or %b or %c or %d ..=:
".."|(\%a as lua expr\ or \%b as lua expr\ or \%c as lua expr\ or \%d as lua expr\) ".."|(\%a as lua expr\ or \%b as lua expr\ or \%c as lua expr\ or \%d as lua expr\)
macro "%a mod %b" =: ".."|(\%a as lua expr\ mod \%b as lua expr\) macro: %a mod %b ..=: ".."|(\%a as lua expr\ mod \%b as lua expr\)
macro "- %a" =: ".."|-(\%a as lua expr\) macro: - %a ..=: ".."|-(\%a as lua expr\)
macro "not %a" =: ".."|not (\%a as lua expr\) macro: not %a ..=: ".."|not (\%a as lua expr\)
rule "%a == %b" =: rule: %a == %b ..=:
lua expr "((vars.a == vars.b) or compiler.utils.equivalent(vars.a, vars.b))" lua expr "((vars.a == vars.b) or compiler.utils.equivalent(vars.a, vars.b))"
rule "%a != %b" =: rule: %a != %b ..=:
lua expr "((vars.a ~= vars.b) or not compiler.utils.equivalent(vars.a, vars.b))" lua expr "((vars.a ~= vars.b) or not compiler.utils.equivalent(vars.a, vars.b))"
macro "repr %obj" =: macro: repr %obj ..=:
".."|compiler.utils.repr(\%obj as lua expr\, true) ".."|compiler.utils.repr(\%obj as lua expr\, true)
macro "say %str" =: macro: say %str ..=:
".."|compiler:writeln(compiler.utils.repr(\%str as lua expr\)) ".."|compiler:writeln(compiler.utils.repr(\%str as lua expr\))
# Control flow # Control flow
rule "do %action" =: rule: do %action ..=:
lua expr "vars.action(compiler, setmetatable({}, {__index=vars}))" lua expr "vars.action(compiler, setmetatable({}, {__index=vars}))"
macro block "return %return_value" =: macro block: return %return_value ..=:
lua block ".." lua block ".."
|if vars.return_value.value.type ~= "Thunk" then |if vars.return_value.value.type ~= "Thunk" then
| compiler:error("Assignment operation has the wrong type for the right hand side. " | compiler:error("Assignment operation has the wrong type for the right hand side. "
@ -224,16 +260,16 @@ macro block "return %return_value" =:
| return ret | return ret
|end |end
macro block "return" =: macro block: return ..=:
"return nil" "return nil"
# Conditionals # Conditionals
macro block "if %condition %if_body" =: macro block: if %condition %if_body ..=:
".."|if \%condition as lua expr\ then ".."|if \%condition as lua expr\ then
| \(lua expr "vars.if_body.value.value") as lua block\ | \(lua expr "vars.if_body.value.value") as lua block\
|end |end
macro block "if %condition %if_body else %else_body" =: macro block: if %condition %if_body else %else_body ..=:
".."|if \%condition as lua expr\ then ".."|if \%condition as lua expr\ then
| \(lua expr "vars.if_body.value.value") as lua block\ | \(lua expr "vars.if_body.value.value") as lua block\
|else |else
@ -241,7 +277,7 @@ macro block "if %condition %if_body else %else_body" =:
|end |end
# Ternary operator # Ternary operator
macro "%if_expr if %condition else %else_expr" =: macro: %if_expr if %condition else %else_expr ..=:
".."|(function(compiler, vars) ".."|(function(compiler, vars)
| if \%condition as lua expr\ then | if \%condition as lua expr\ then
| return \%if_expr as lua expr\ | return \%if_expr as lua expr\
@ -250,8 +286,51 @@ macro "%if_expr if %condition else %else_expr" =:
| end | end
|end)(compiler, vars) |end)(compiler, vars)
# For loop # Loop control flow
macro block "for %var in %iterable %body" =: macro block: break ..=: "break"
macro block: continue ..=: "continue"
# TODO: add labeled break/continue?
# GOTOs
lua block ".."
|local function lua_label(label)
| if label.type ~= "Var" then
| compiler:error("Goto label has the wrong type for the label. Expected Var, but got: "..label.type)
| end
| local bits = "abcdefghijklmnop"
| local lua_identifier = "label_"
| for i=1,#label.value do
| local byte = string.byte(label.value, i)
| local low = byte % 16
| local high = (byte - low) / 16
| lua_identifier = lua_identifier .. bits:sub(low+1,low+1) .. bits:sub(high+1,high+1)
| end
| return lua_identifier
|end
|
|compiler:defmacro("-> %label", function(compiler, vars, kind)
| return "::"..lua_label(vars.label.value).."::", true
|end)
|compiler:defmacro("go to %label", function(compiler, vars, kind)
| return "goto "..lua_label(vars.label.value), true
|end)
# While loops
macro block: repeat %body ..=:
".."|while true do
| \(lua expr "vars.body.value.value") as lua block\
|end
macro block: repeat while %condition %body ..=:
".."|while \%condition as lua expr\ do
| \(lua expr "vars.body.value.value") as lua block\
|end
macro block: repeat until %condition %body ..=:
".."|while not (\%condition as lua expr\) do
| \(lua expr "vars.body.value.value") as lua block\
|end
# For loops
macro block: for %var in %iterable %body ..=:
%var-type =: lua expr "vars.var.value.type" %var-type =: lua expr "vars.var.value.type"
if (%var-type != "Var"): if (%var-type != "Var"):
error ".." error ".."
@ -264,7 +343,7 @@ macro block "for %var in %iterable %body" =:
|end |end
|\%var-code\ = old_loopval |\%var-code\ = old_loopval
macro block "for all %iterable %body" =: macro block: for all %iterable %body ..=:
".."|local old_loopval = vars.it ".."|local old_loopval = vars.it
|for i,value in ipairs(\%iterable as lua expr\) do |for i,value in ipairs(\%iterable as lua expr\) do
| vars.it = value | vars.it = value
@ -274,7 +353,7 @@ macro block "for all %iterable %body" =:
# List Comprehension # List Comprehension
# TODO: maybe make this lazy, or a lazy version? # TODO: maybe make this lazy, or a lazy version?
macro "%expression for %var in %iterable" =: macro: %expression for %var in %iterable ..=:
%var-type =: lua expr "vars.var.value.type" %var-type =: lua expr "vars.var.value.type"
if (%var-type != "Var"): if (%var-type != "Var"):
error ".." error ".."
@ -289,7 +368,7 @@ macro "%expression for %var in %iterable" =:
| return comprehension | return comprehension
|end)(game, setmetatable({}, {__index=vars})) |end)(game, setmetatable({}, {__index=vars}))
macro "%expression for all %iterable" =: macro: %expression for all %iterable ..=:
".."|(function(game, vars) ".."|(function(game, vars)
| local comprehension = {} | local comprehension = {}
| for i,value in ipairs(\%iterable as lua expr\) do | for i,value in ipairs(\%iterable as lua expr\) do
@ -300,7 +379,7 @@ macro "%expression for all %iterable" =:
|end)(game, setmetatable({}, {__index=vars})) |end)(game, setmetatable({}, {__index=vars}))
# Dict comprehension # Dict comprehension
macro "%key -> %value for %var in %iterable" =: macro: %key -> %value for %var in %iterable ..=:
%var-type =: lua expr "vars.var.value.type" %var-type =: lua expr "vars.var.value.type"
if (%var-type != "Var"): if (%var-type != "Var"):
error ".." error ".."
@ -315,7 +394,7 @@ macro "%key -> %value for %var in %iterable" =:
| return comprehension | return comprehension
|end)(game, setmetatable({}, {__index=vars})) |end)(game, setmetatable({}, {__index=vars}))
macro "%key -> %value for all %iterable" =: macro: %key -> %value for all %iterable ..=:
".."|(function(game, vars) ".."|(function(game, vars)
| local comprehension = {} | local comprehension = {}
| for i,value in ipairs(\%iterable as lua expr\) do | for i,value in ipairs(\%iterable as lua expr\) do
@ -326,58 +405,91 @@ macro "%key -> %value for all %iterable" =:
|end)(game, setmetatable({}, {__index=vars})) |end)(game, setmetatable({}, {__index=vars}))
# Number ranges # Number ranges
rule "%start up to %stop" =: rule: %start up to %stop ..=:
lua expr "compiler.utils.range(vars.start,vars.stop-1)" lua expr "compiler.utils.range(vars.start,vars.stop-1)"
rule ["%start thru %stop", "%start through %stop"] =: rule:
%start thru %stop
%start through %stop
..=:
lua expr "compiler.utils.range(vars.start,vars.stop)" lua expr "compiler.utils.range(vars.start,vars.stop)"
rule "%start down to %stop" =: rule: %start down to %stop ..=:
lua expr "compiler.utils.range(vars.start,vars.stop+1,-1)" lua expr "compiler.utils.range(vars.start,vars.stop+1,-1)"
rule ["%start down thru %stop", "%start down through %stop"] =: rule:
%start down thru %stop
%start down through %stop
..=:
lua expr "compiler.utils.range(vars.start,vars.stop,-1)" lua expr "compiler.utils.range(vars.start,vars.stop,-1)"
rule "%start up to %stop via %step" =: rule: %start up to %stop via %step ..=:
lua expr "compiler.utils.range(vars.start,vars.stop-1,vars.step)" lua expr "compiler.utils.range(vars.start,vars.stop-1,vars.step)"
rule ["%start thru %stop via %step", "%start through %stop via %step"] =: rule:
%start thru %stop via %step
%start through %stop via %step
..=:
lua expr "compiler.utils.range(vars.start,vars.stop,vars.step)" lua expr "compiler.utils.range(vars.start,vars.stop,vars.step)"
rule "%start down to %stop via %step" =: rule: %start down to %stop via %step ..=:
lua expr "compiler.utils.range(vars.start,vars.stop+1,-vars.step)" lua expr "compiler.utils.range(vars.start,vars.stop+1,-vars.step)"
rule ["%start down thru %stop via %step", "%start down through %stop via %step"] =: rule:
%start down thru %stop via %step
%start down through %stop via %step
..=:
lua expr "compiler.utils.range(vars.start,vars.stop,-vars.step)" lua expr "compiler.utils.range(vars.start,vars.stop,-vars.step)"
# Common utility functions # Common utility functions
rule ["random number"] =: lua expr "math.random()" rule: random number ..=: lua expr "math.random()"
rule ["sum of %items"] =: lua expr "compiler.utils.sum(vars.items)" rule: sum of %items ..=: lua expr "compiler.utils.sum(vars.items)"
rule ["product of %items"] =: lua expr "compiler.utils.product(vars.items)" rule: product of %items ..=: lua expr "compiler.utils.product(vars.items)"
rule ["all of %items"] =: lua expr "compiler.utils.all(vars.items)" rule: all of %items ..=: lua expr "compiler.utils.all(vars.items)"
rule ["any of %items"] =: lua expr "compiler.utils.any(vars.items)" rule: any of %items ..=: lua expr "compiler.utils.any(vars.items)"
rule ["avg of %items", "average of %items"] =: lua expr "(compiler.utils.sum(vars.items)/#vars.items)" rule:
rule ["min of %items", "smallest of %items", "lowest of %items"] =: avg of %items
average of %items
..=: lua expr "(compiler.utils.sum(vars.items)/#vars.items)"
rule:
min of %items
smallest of %items
lowest of %items
..=:
lua expr "compiler.utils.min(vars.items)" lua expr "compiler.utils.min(vars.items)"
rule ["max of %items", "biggest of %items", "largest of %items", "highest of %items"] =: rule:
max of %items
biggest of %items
largest of %items
highest of %items
..=:
lua expr "compiler.utils.min(vars.items)" lua expr "compiler.utils.min(vars.items)"
rule ["min of %items with respect to %keys"] =: rule: min of %items with respect to %keys ..=:
lua expr "compiler.utils.min(vars.items, vars.keys)" lua expr "compiler.utils.min(vars.items, vars.keys)"
rule ["max of %items with respect to %keys"] =: rule: max of %items with respect to %keys ..=:
lua expr "compiler.utils.max(vars.items, vars.keys)" lua expr "compiler.utils.max(vars.items, vars.keys)"
# List/dict functions # List/dict functions
macro [..] macro:
"%list 's %index", "%index st in %list", "%index nd in %list", "%index rd in %list" %list's %index
"%index th in %list", "%index in %list", "%list -> %index" %index st in %list
%index nd in %list
%index rd in %list
%index th in %list
%index in %list
%list -> %index
..=: ..=:
".."|\%list as lua expr\[\%index as lua expr\] ".."|\%list as lua expr\[\%index as lua expr\]
macro block [..] macro block:
"%list 's %index = %value", "%index st in %list = %value", "%index nd in %list = %value" %list's %index = %value
"%index rd in %list = %value", "%index th in %list = %value", "%index in %list = %value" %index st in %list = %value
"%index = %value in %list", "%list -> %index = %value" %index nd in %list = %value
%index rd in %list = %value
%index th in %list = %value
%index in %list = %value
%list -> %index = %value
..=: ..=:
lua block ".." lua block ".."
|if vars.value.value.type ~= "Thunk" then |if vars.value.value.type ~= "Thunk" then
@ -390,20 +502,27 @@ macro block [..]
| \%list as lua expr\[\%index as lua expr\] = ret | \%list as lua expr\[\%index as lua expr\] = ret
|end |end
macro ["%item is in %list", "%list contains %item"] =: macro:
%item is in %list
%list contains %item
..=:
".."|(\%list as lua expr\[\%index as lua expr\] ~= nil) ".."|(\%list as lua expr\[\%index as lua expr\] ~= nil)
macro ["length of %list", "size of %list", "number of %list"] =: macro:
length of %list
size of %list
number of %list
..=:
".."|#(\%list as lua expr\) ".."|#(\%list as lua expr\)
rule "dict %items" =: rule: dict %items ..=:
%dict =: [] %dict =: []
for %pair in %items: for %pair in %items:
lua block "vars.dict[vars.pair[1]] = vars.pair[2]" lua block "vars.dict[vars.pair[1]] = vars.pair[2]"
return: %dict return: %dict
# Permission functions # Permission functions
rule "restrict %fn to within %whitelist" =: rule: restrict %fn to within %whitelist ..=:
lua block ".." lua block ".."
|local fns = compiler:get_invocations(vars.fn) |local fns = compiler:get_invocations(vars.fn)
|local whitelist = compiler:get_invocations(vars.whitelist) |local whitelist = compiler:get_invocations(vars.whitelist)
@ -425,7 +544,7 @@ rule "restrict %fn to within %whitelist" =:
| end | end
|end |end
rule "allow %whitelist to use %fn" =: rule: allow %whitelist to use %fn ..=:
lua block ".." lua block ".."
|local fns = compiler:get_invocations(vars.fn) |local fns = compiler:get_invocations(vars.fn)
|local whitelist = compiler:get_invocations(vars.whitelist) |local whitelist = compiler:get_invocations(vars.whitelist)
@ -449,7 +568,7 @@ rule "allow %whitelist to use %fn" =:
| end | end
|end |end
rule "forbid %blacklist to use %fn" =: rule: forbid %blacklist to use %fn ..=:
lua block ".." lua block ".."
|local fns = compiler:get_invocations(vars.fn) |local fns = compiler:get_invocations(vars.fn)
|local blacklist = compiler:get_invocations(vars.blacklist) |local blacklist = compiler:get_invocations(vars.blacklist)
@ -472,7 +591,7 @@ rule "forbid %blacklist to use %fn" =:
|end |end
# For unit testing # For unit testing
macro block "test %code yields %expected" =: macro block: test %code yields %expected ..=:
%generated =: lua expr "compiler.utils.repr(compiler:stringify_tree(vars.code.value.value), true)" %generated =: lua expr "compiler.utils.repr(compiler:stringify_tree(vars.code.value.value), true)"
%expected =: %expected as lua expr %expected =: %expected as lua expr
if (%generated != %expected): if (%generated != %expected):

12
examples/parser_tests.nom
View File

@ -9,21 +9,23 @@ test: say (4) ..yields ".."
| 4 | 4
test: test:
rule "fart" =: say "poot" rule: fart ..=: say "poot"
..yields ".." ..yields ".."
|Call [rule % = %]: |Call [rule % = %]:
| "fart" | Thunk:
| Call [fart]!
| Thunk: | Thunk:
| Call [say %]: | Call [say %]:
| "poot" | "poot"
test: test:
rule "doublefart": rule: doublefart ..=:
say "poot" say "poot"
say "poot" say "poot"
..yields ".." ..yields ".."
|Call [rule % %]: |Call [rule % = %]:
| "doublefart" | Thunk:
| Call [doublefart]!
| Thunk: | Thunk:
| Call [say %]: | Call [say %]:
| "poot" | "poot"

48
examples/sample_code.nom
View File

@ -11,7 +11,7 @@ say (4)
#.. "rule" is just a function that takes a function call spec and a block of code to run, #.. "rule" is just a function that takes a function call spec and a block of code to run,
and stores the function definition and stores the function definition
rule "fart": say "poot" rule: fart ..=: say "poot"
fart fart
@ -33,13 +33,13 @@ say ".."
|(done) |(done)
| |
rule "doublefart": # this farts twice rule: doublefart ..=: # this farts twice
say "poot" say "poot"
say "poot" say "poot"
doublefart doublefart
rule "subex work": return "subexpressions work" rule: subex work ..=: "subexpressions work"
say (subex work) say (subex work)
@ -54,7 +54,7 @@ say [..]
1, 2 1, 2
3 3
rule "say both %one and %two": rule: say both %one and %two ..=:
say %one say %one
say %two say %two
@ -68,7 +68,7 @@ say both..
"hello" "hello"
and "world" and "world"
rule "three": return 3 rule: three ..=: 3
say both .. say both ..
"a list:" "a list:"
and [..] and [..]
@ -79,16 +79,16 @@ if 1: yes
if 1: yes ..else: no if 1: yes ..else: no
say (do: return 5) say (do: return: 5)
rule "do %one also %two": rule: do %one also %two ..=:
do %one do %one
do %two do %two
do: say "one liner" do: say "one liner"
..also: say "another one liner" ..also: say "another one liner"
say (do: return "wow") say (do: return: "wow")
say (1 + (-(2 * 3))) say (1 + (-(2 * 3)))
@ -110,27 +110,23 @@ say ".."
| with multiple lines | with multiple lines
| and an interpolated expression: \2 + 5\ | and an interpolated expression: \2 + 5\
rule "%n bottles": rule: %n bottles ..=:
lua block [..] lua block ".."
".." |do
|do | print("running raw lua code...")
| print("running raw lua code...") | for i=\%n\,1,-1 do
| local n = | print(tostring(i).." bottles of beer on the wall. Take one down, pass it around,")
.., %n, ".." | end
| | print("no more bottles of beer on the wall.")
| for i=n,1,-1 do |end
| print(tostring(i).." bottles of beer on the wall. Take one down, pass it around,")
| end
| print("no more bottles of beer on the wall.")
|end
nil nil
9 bottles 9 bottles
rule "dumsum %nums": rule: dumsum %nums ..=:
let "sum" = 0 %sum =: 0
for "n" in %nums: for %n in %nums:
let "sum" = (%sum + %n) %sum +=: %n
return %sum return: %sum
say (dumsum [1,2,3]) say (dumsum [1,2,3])

151
examples/sample_game.nom
View File

@ -1,4 +1,155 @@
run file "core.nom" run file "core.nom"
run file "lib/secrets.nom"
with secrets:
rule: pending proposal ..=:
secret %pending
rule: propose source %src ..=:
secret %pending =: %src
say ".."
|Proposal\%src\
macro block: propose %action ..=: ".."
|compiler:call("propose source %", \repr (%action's "src")\)
rule: approve ..=:
if (pending proposal):
say ".."
|Running\pending proposal\
do (..)
eval ".."
|return: \pending proposal\
..else:
say "No action pending"
propose:
say "motion passed."
rule: fart ..=:
say "poot"
approve
fart
# Users:
with secrets:
secret %users =: lua expr "require('users')"
rule: find user %name ..=:
lua expr "secrets.users.by_name(vars.name) or compiler:error('Failed to find user: '..tostring(vars.name))"
rule: add user %name ..=:
lua expr "secrets.users.add(vars.name)"
macro: @ %name_block ..=:
%name_str =: lua expr "vars.name_block.value.value.src"
".."|compiler:call("find user %", \repr %name_str\)
say ".."|A user looks like: \@:spill\
say ".."|A user looks like: \@:spill\
add user "dave"
say ".."|A user looks like: \@:dave\
add user "moloch"
say ".."|A user looks like: \@:moloch\
add user "bruce"
# Inventory:
with secrets:
secret %inventory =: lua expr ".."
|setmetatable({}, {__index=function(self,key)
| local t = {}
| self[key] = t
| return t
|end})
with secrets:
lua block ".."
|local endings = setmetatable({x="es",c="es",s="es"}, {__index=function() return "s" end})
|secrets.plurals = setmetatable({}, {__index=function(self,key)
| return key..endings[key:sub(-1)]
|end})
|secrets.singulars = setmetatable({}, {__index=function(self,key)
| if key:sub(-2) == "es" and rawget(endings, key:sub(-3,-3)) then return key:sub(1,-3) end
| if key:sub(-1) == "s" then return key:sub(1,-2) end
| return key
|end})
|secrets.canonicals = setmetatable({}, {__index=function(self,key)
| if key:sub(-1) == "s" then return secrets.singulars[key] end
| return key
|end})
rule: the plural of %singular is %plural ..=:
(secret %plurals)->%singular =: %plural
(secret %singulars)->%plural =: %singular
(secret %canonicals)->%plural =: %singular
rule: singular %plural ..=:
%plural in (secret %singulars)
rule: plural %singular ..=:
%singular in (secret %plurals)
rule: canonicalize %item-name ..=:
%item-name in (secret %canonicals)
rule: %person's inventory ..=:
(secret %inventory)->%person
rule: %person's stock of %item ..=:
%item =: canonicalize %item
((%person's inventory)->%item) or 0
rule: %person's stock of %item as str ..=:
%item =: canonicalize %item
%count =: %person's stock of %item
".."
|\%count\ \(singular %item) if (%count == 1) else (plural %item)\
rule: give %person %count %item ..=:
%item =: canonicalize %item
(%person's inventory)-> %item =: (%person's stock of %item) + %count
rule: give %person %count %item from %donor ..=:
%item =: canonicalize %item
if ((%donor's stock of %item) < %count):
say ".."
|\%donor\ does not have enough \%item\ to transfer
..else:
(%person's inventory)->%item =: (%person's stock of %item) + %count
(%donor's inventory)->%item =: (%donor's stock of %item) - %count
rule:
%person has %item
%person has a %item
%person has an %item
..=:
(%person's stock of %item) > 0
give (@:bruce) 3 "hats"
give (@:bruce) 3 "hats"
give (@:dave) 1 "hat" from (@:bruce)
say ".."|Bruce has \(@:bruce)'s stock of "hats" as str\
say ".."|Dave has \(@:dave)'s stock of "hats" as str\
give (@:dave) 1 "box"
say ".."|Dave has \(@:dave)'s stock of "boxes" as str\
the plural of "goose" is "geese"
give (@:dave) 1 "goose"
say ".."|Dave has \(@:dave)'s stock of "geese" as str\
give (@:dave) 1 "goose"
say ".."|Dave has \(@:dave)'s stock of "geese" as str\
do:
lua block "math.randomseed(os.time())"
repeat until ((random number) < 0.01):
say "tick"
say "tock"
# A basic key-value store that's only accessible through these functions: # A basic key-value store that's only accessible through these functions:
lua block ".." lua block ".."
|do -- Use a closure to hide this behind the accessor rules |do -- Use a closure to hide this behind the accessor rules

191
examples/tutorial.nom
View File

@ -25,7 +25,7 @@ run file "core.nom"
5 5
6,7,8 6,7,8
# Dicts: # Dictionaries (AKA hash maps):
dict [["x", 99], ["y", 101]] dict [["x", 99], ["y", 101]]
dict [..] dict [..]
["z", 222] ["z", 222]
@ -34,22 +34,105 @@ dict [..]
# Function calls: # Function calls:
say "Hello world!" say "Hello world!"
# Variables use the % sign:
%str =: "Hello again"
say %str
# There are +=:, -=:, *=:, /=:, ^=:, and=:, or=:, and mod=: operators for updating variables
%x =: 1
%x +=: 100
say %x
# Conditionals look like this:
if (1 < 10):
say "1 is indeed < 10"
if (1 > 10):
say "this won't print"
..else:
say "this will print"
if (1 > 3):
say "this won't print"
..else: if (1 < 2):
say "this won't print"
..else:
say "this will print"
# Loops look like this:
for %x in [1,2,3]:
say ".."|for loop over list #\%x\
# If you want to iterate over a numeric range, you can use some built in functions like this:
for %x in (1 through 3):
say ".."|for loop over number range #\%x\
# While loops:
%x =: 1
repeat while (%x <= 3):
say ".."|repeat while loop #\%x\
%x +=: 1
%x =: 1
repeat until (%x > 3):
say ".."|repeat until loop #\%x\
%x +=: 1
# Infinite loop:
%x =: 1
repeat:
say ".."|repeat loop #\%x\
%x +=: 1
if (%x > 3):
break
# GOTOs:
do:
%x =: 1
-> %again
say ".."|go to loop #\%x\
%x +=: 1
if (%x <= 3):
go to %again
say "finished going to"
# Function definition: # Function definition:
rule "say both %first and also %second": rule:
# Variables use the "%" sign: say both %first and also %second
..=:
# Function arguments are accessed just like variables
say %first say %first
say %second say %second
rule "get x from %dict": # The last line of a function is the return value
#.. Functions can return values explicitly, but if not, the last line in the function rule:
is the return value. add %x and %y
return (%dict's "x") ..=:
%result =: %x + %y
%result
# Functions can use "return" to return a value early
rule:
first fibonacci above %n
..=:
%f1 =: 0
%f2 =: 1
repeat:
%tmp =: %f1 + %f2
%f1 =: %f2
%f2 =: %tmp
if (%f2 > %n):
return: %f2
say (first fibonacci above 10)
# Functions can have aliases, which may or may not have the arguments in different order # Functions can have aliases, which may or may not have the arguments in different order
rule [..] rule:
"I hate %worse-things more than %better-things", "I think %worse-things are worse than %better-things" I hate %worse-things more than %better-things
"I like %better-things more than %worse-things" I think %worse-things are worse than %better-things
..: I like %better-things more than %worse-things
..=:
say ".."|\%better-things capitalized\ rule and \%worse-things\ drool! say ".."|\%better-things capitalized\ rule and \%worse-things\ drool!
I like "dogs" more than "cats" I like "dogs" more than "cats"
@ -61,24 +144,33 @@ I think "chihuahuas" are worse than "corgis"
say both "Hello" and also "again!" say both "Hello" and also "again!"
# Functions can even have their name at the end: # Functions can even have their name at the end:
rule "%what-she-said is what she said": rule:
%what-she-said is what she said
..=:
say %what-she-said say %what-she-said
say "-- she said" say "-- she said"
"Howdy pardner" is what she said "Howdy pardner" is what she said
#.. The language only reserves []{}().,:;% as special characters, so functions and variables #.. The language only reserves []{}().,:;% as special characters, so functions and variables
can have really funky names! can have really funky names!
rule ">> %foo-bar$$$^ --> %@@& _~-^-~_~-^ %1 !": rule:
>> %foo-bar$$$^ --> %@@& _~-^-~_~-^ %1 !
..=:
say %foo-bar$$$^ say %foo-bar$$$^
say %@@& say %@@&
say %1 say %1
>> "wow" --> "so flexible!" _~-^-~_~-^ "even numbers can be variables!" ! >> "wow" --> "so flexible!" _~-^-~_~-^ "even numbers can be variables!" !
# Though literals can't be used in function names
# Math and logic operations are just treated the same as function calls in the syntax # Math and logic operations are just treated the same as function calls in the syntax
say (2 + 3) say (2 + 3)
# So it's easy to define your own operators # So it's easy to define your own operators
rule "%a ++ %b": 2 * (%a + %b) rule:
%a ++ %b
..=:
2 * (%a + %b)
say (2 ++ 3) say (2 ++ 3)
@ -121,7 +213,7 @@ say both ".."
..and also.. ..and also..
"-- Abraham Lincoln" "-- Abraham Lincoln"
rule "my favorite number": return 23 rule: my favorite number ..=: 21 + 2
# Subexpressions are wrapped in parentheses: # Subexpressions are wrapped in parentheses:
say (my favorite number) say (my favorite number)
@ -139,48 +231,10 @@ say ".."
number number
..\, but this time it uses an indented subexpression! ..\, but this time it uses an indented subexpression!
#.. There's a few macros in the language for things like conditional branches and logic/math rule:
operations, but they can be thought of as basically the same as functions. sing %starting-bottles bottles of beer
There are no keywords in the language! ..=:
if (1 < 10): for %n in (%starting-bottles down through 0):
say "One is less than ten"
..else:
say "One is not less than ten"
#.. Breakdown of the above:
Function call (actually a macro) to "if % % else %"
First argument is a subexpression that is a function call (also a macro) to "% < %"
that performs a comparison on its arguments, 1 and 10
Second argument is a block of code that includes a function call to "say %", the "if" body
Third argument is a block of code that includes a different function call to "say %", the "else" body
# Line continuations can be used for "elseif"
if (1 > 10):
say "First condition"
..else: if (1 > 5):
say "Second condition"
..else:
say "Last condition"
# ^that's the same as:
if (1 > 10):
say "First condition"
..else:
if (1 > 5):
say "Second condition"
..else:
say "Last condition"
# Variables are modified with a macro, "let % = %"
let "numbers" = [5,6,7]
# Looping:
say ".."|Looping over \%numbers\:
for "number" in %numbers:
say (%number + 100)
rule "sing %starting-bottles bottles of beer":
for "n" in (%starting-bottles down through 0):
say ".." say ".."
|\%n if (%n > 0) else "No more"\ \"bottle" if (%n == 1) else "bottles"\ of beer on the wall. |\%n if (%n > 0) else "No more"\ \"bottle" if (%n == 1) else "bottles"\ of beer on the wall.
|\"" if (%n == 0) else " Take one down, pass it around..."\ |\"" if (%n == 0) else " Take one down, pass it around..."\
@ -206,7 +260,7 @@ any of [0,0,0,0,1,0,0]
# Macros: # Macros:
# The "lua block %" and "lua expr %" macros can be used to write raw lua code: # The "lua block %" and "lua expr %" macros can be used to write raw lua code:
rule "say the time": rule: say the time ..=:
lua block ".." lua block ".."
|io.write("The OS time is: ") |io.write("The OS time is: ")
|io.write(tostring(os.time()).."\\n") |io.write(tostring(os.time()).."\\n")
@ -215,24 +269,23 @@ say ".."|Math expression result is: \lua expr "(1 + 2*3 + 3*4)^2"\
#.. In the lua environment, "vars" can be used to get local variables/function args, and #.. In the lua environment, "vars" can be used to get local variables/function args, and
"compiler" can be used to access the compiler, function defs, and other things "compiler" can be used to access the compiler, function defs, and other things
rule "square root of %n": rule: square root of %n ..=:
return (lua expr "math.sqrt(vars.n)") lua expr "math.sqrt(vars.n)"
say ".."|The square root of 2 is \square root of 2\ say ".."|The square root of 2 is \square root of 2\
# Macros can be defined as functions that take unprocessed syntax trees and return lua code # Macros can be defined as functions that take unprocessed syntax trees and return lua code
# "macro block %" is for defining macros that produce blocks of code, not values # "macro block %" is for defining macros that produce blocks of code, not values
macro block "unless %condition %body": macro block: unless %condition %body ..=: ".."
".." |if not (\%condition as lua expr\) then
|if not (\%condition as lua expr\) then | \(lua expr "vars.body.value.value") as lua block\
| \(lua expr "vars.body.value.value") as lua block\ |end
|end
unless (1 > 10): unless (1 > 10):
say "Macros work!" say "Macros work!"
say "It looks like a keyword, but there's no magic here!" say "It looks like a keyword, but there's no magic here!"
# and "macro %" is for defining macros that produce an expression # and "macro %" is for defining macros that produce an expression
macro "%value as a boolean": macro: %value as a boolean ..=: ".."
".."|(not not (\%value as lua expr\)) |(not not (\%value as lua expr\))
macro "yep": "true" macro: yep ..=: "true"

50
nomsu.lua
View File

@ -203,7 +203,43 @@ do
self.defs[invocation] = fn_info self.defs[invocation] = fn_info
end end
end, end,
get_invocations_from_definition = function(self, def, vars)
if def.type == "String" or def.type == "List" then
return self:tree_to_value(def, vars)
end
if def.type ~= "Thunk" then
self:error("Trying to get invocations from " .. tostring(def.type) .. ", but expected Thunk.")
end
local invocations = { }
local _list_0 = def.value.value
for _index_0 = 1, #_list_0 do
local statement = _list_0[_index_0]
if statement.value.type ~= "FunctionCall" then
self:error("Invalid statement type: " .. tostring(statement.value.type) .. ", expected FunctionCall")
end
local name_bits = { }
local _list_1 = statement.value.value
for _index_1 = 1, #_list_1 do
local token = _list_1[_index_1]
if token.type == "Word" then
table.insert(name_bits, token.value)
elseif token.value.type == "Var" then
table.insert(name_bits, token.value.src)
else
self:error("Unexpected token type in definition: " .. tostring(token.value.type) .. " (expected Word or Var)")
end
end
table.insert(invocations, table.concat(name_bits, " "))
end
return invocations
end,
get_invocations = function(self, text) get_invocations = function(self, text)
if not text then
self:error("No text provided!")
end
if type(text) == 'function' then
error("Function passed to get_invocations")
end
if type(text) == 'string' then if type(text) == 'string' then
text = { text = {
text text
@ -764,11 +800,21 @@ do
if kind == "Expression" then if kind == "Expression" then
error("Expected to be in statement.") error("Expected to be in statement.")
end end
return "do\n" .. self:tree_to_value(vars.lua_code, vars) .. "\nend", true local inner_vars = setmetatable({ }, {
__index = function(_, key)
return "vars[" .. tostring(utils.repr(key, true)) .. "]"
end
})
return "do\n" .. self:tree_to_value(vars.lua_code, inner_vars) .. "\nend", true
end) end)
self:defmacro([[lua expr %lua_code]], function(self, vars, kind) self:defmacro([[lua expr %lua_code]], function(self, vars, kind)
local lua_code = vars.lua_code.value local lua_code = vars.lua_code.value
return self:tree_to_value(vars.lua_code, vars) local inner_vars = setmetatable({ }, {
__index = function(_, key)
return "vars[" .. tostring(utils.repr(key, true)) .. "]"
end
})
return self:tree_to_value(vars.lua_code, inner_vars)
end) end)
return self:def("run file %filename", function(self, vars) return self:def("run file %filename", function(self, vars)
local file = io.open(vars.filename) local file = io.open(vars.filename)

32
nomsu.moon
View File

@ -9,6 +9,7 @@ utils = require 'utils'
-- better scoping? -- better scoping?
-- first-class functions -- first-class functions
-- better error reporting -- better error reporting
-- versions of rules with auto-supplied arguments
-- type checking? -- type checking?
INDENT = " " INDENT = " "
@ -137,8 +138,33 @@ class NomsuCompiler
fn_info = {:fn, :arg_names, :invocations, :src, is_macro:false} fn_info = {:fn, :arg_names, :invocations, :src, is_macro:false}
for invocation in *invocations for invocation in *invocations
@defs[invocation] = fn_info @defs[invocation] = fn_info
get_invocations_from_definition:(def, vars)=>
if def.type == "String" or def.type == "List"
return @tree_to_value(def, vars)
if def.type != "Thunk"
@error "Trying to get invocations from #{def.type}, but expected Thunk."
invocations = {}
for statement in *def.value.value
if statement.value.type != "FunctionCall"
@error "Invalid statement type: #{statement.value.type}, expected FunctionCall"
name_bits = {}
for token in *statement.value.value
if token.type == "Word"
table.insert name_bits, token.value
elseif token.value.type == "Var"
table.insert name_bits, token.value.src
else
@error "Unexpected token type in definition: #{token.value.type} (expected Word or Var)"
table.insert invocations, table.concat(name_bits, " ")
return invocations
get_invocations:(text)=> get_invocations:(text)=>
if not text
@error "No text provided!"
if type(text) == 'function'
error "Function passed to get_invocations"
if type(text) == 'string' then text = {text} if type(text) == 'string' then text = {text}
invocations = {} invocations = {}
arg_names = {} arg_names = {}
@ -559,11 +585,13 @@ class NomsuCompiler
@defmacro [[lua block %lua_code]], (vars, kind)=> @defmacro [[lua block %lua_code]], (vars, kind)=>
if kind == "Expression" then error("Expected to be in statement.") if kind == "Expression" then error("Expected to be in statement.")
return "do\n"..@tree_to_value(vars.lua_code, vars).."\nend", true inner_vars = setmetatable({}, {__index:(_,key)-> "vars[#{utils.repr(key,true)}]"})
return "do\n"..@tree_to_value(vars.lua_code, inner_vars).."\nend", true
@defmacro [[lua expr %lua_code]], (vars, kind)=> @defmacro [[lua expr %lua_code]], (vars, kind)=>
lua_code = vars.lua_code.value lua_code = vars.lua_code.value
return @tree_to_value(vars.lua_code, vars) inner_vars = setmetatable({}, {__index:(_,key)-> "vars[#{utils.repr(key,true)}]"})
return @tree_to_value(vars.lua_code, inner_vars)
@def "run file %filename", (vars)=> @def "run file %filename", (vars)=>
file = io.open(vars.filename) file = io.open(vars.filename)