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

Added colons for aesthetics.

Browse Source
This commit is contained in:
Bruce Hill 2018-01-31 15:31:06 -08:00
parent b1406a3203
commit a387fd86a8
8 changed files with 144 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
lib/collections.nom
View File

@ -9,18 +9,18 @@ use "lib/operators.nom"
# List/dict functions:
# Indexing
immediately
immediately:
compile [..]
%index st to last in %list, %index nd to last in %list, %index rd to last in %list
%index th to last in %list
..to {expr:"utils.nth_to_last(\(%list as lua expr), \(%index as lua expr))"}
immediately
immediately:
parse [first in %list, first %list] as: 1 st in %list
parse [last in %list, last %list] as: 1 st to last in %list
# Membership testing
immediately
immediately:
action [%item is in %list, %list contains %item, %list has %item]
for %key = %value in %list
if (%key is %item): return (yes)
@ -30,12 +30,12 @@ immediately
%item isn't in %list, %item is not in %list
%list doesn't contain %item, %list does not contain %item
%list doesn't have %item, %list does not have %item
..
..:
for %key = %value in %list
if (%key is %item): return (no)
return (yes)
immediately
immediately:
# Note: it's important to have the space after "[" to prevent confusion if %index is a string
compile [%list has key %index, %list has index %index] to {..}
expr: ".."
@ -47,21 +47,21 @@ immediately
%list doesn't have index %index, %list does not have index %index
..to {expr:"((\(%list as lua expr))[ \(%index as lua expr)] == nil)"}
compile [length of %list, size of %list, size %list, number of %list, len %list] to
compile [length of %list, size of %list, size %list, number of %list, len %list] to:
{expr:"utils.size(\(%list as lua expr))"}
compile [append %item to %list, add %item to %list] to
compile [append %item to %list, add %item to %list] to:
{statements:"table.insert(\(%list as lua expr), \(%item as lua expr))"}
compile [pop from %list, remove last from %list] to
compile [pop from %list, remove last from %list] to:
{statements:"table.remove(\(%list as lua expr))"}
compile [remove index %index from %list] to
compile [remove index %index from %list] to:
{statements:"table.remove(\(%list as lua expr), \(%index as lua expr))"}
# List Comprehension
immediately
compile [%expression for %item in %iterable] to
immediately:
compile [%expression for %item in %iterable] to:
assume ((%item's "type") is "Var") or barf ".."
List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item's "type")
return {..}
@ -78,7 +78,7 @@ immediately
compile [..]
%expression for %index from %start to %stop via %step
%expression for %index from %start to %stop by %step
..to
..to:
assume ((%index's "type") is "Var") or barf ".."
List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%index's "type")
return {..}
@ -98,7 +98,7 @@ immediately
..as: %expression for % from %start to %stop via %step
parse [%expression for all %start to %stop] as: %expression for all %start to %stop via 1
compile [%expression for %key = %value in %iterable] to
compile [%expression for %key = %value in %iterable] to:
assume ((%key's "type") is "Var") or barf ".."
List comprehension has the wrong type for the key loop variable. Expected Var, but got: \(%key's "type")
assume ((%value's "type") is "Var") or barf ".."
@ -114,8 +114,8 @@ immediately
end)()
# Dict comprehensions
immediately
compile [%key = %value for %item in %iterable] to
immediately:
compile [%key = %value for %item in %iterable] to:
assume ((%item's "type") is "Var") or barf ".."
Dict comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item's "type")
# Note: it's important to have the space after "[" to prevent confusion if %key is a string
@ -130,7 +130,7 @@ immediately
end)()
parse [%key = %value for all %iterable] as: %key = %value for % in %iterable
compile [%key = %value for %src_key = %src_value in %iterable] to
compile [%key = %value for %src_key = %src_value in %iterable] to:
assume ((%src_key's "type") is "Var") or barf ".."
Dict comprehension has the wrong type for the key loop variable. Expected Var, but got: \(%src_key's "type")
assume ((%src_value's "type") is "Var") or barf ".."
@ -146,11 +146,11 @@ immediately
return comprehension;
end)()
immediately
action [%lists flattened]
immediately:
action [%lists flattened]:
%flat <- []
for %list in %lists
for %item in %list
for %list in %lists:
for %item in %list:
add %item to %flat
return %flat
@ -159,7 +159,7 @@ immediately
parse [values in %dict] as: %v for %k = %v in %dict
# Sorting:
immediately
immediately:
compile [sort %items] to {statements:"table.sort(\(%items as lua expr))"}
compile [sort %items by %key_expr] to {..}
statements: ".."
@ -167,26 +167,26 @@ immediately
return \(%key_expr as lua expr);
end)
immediately
action [%items sorted, sorted %items]
immediately:
action [%items sorted, sorted %items]:
%copy <- (% for all %items)
sort %copy
return %copy
action [%items sorted by %key]
action [%items sorted by %key]:
%copy <- (% for all %items)
sort %copy by %key
return %copy
action [unique %items]
action [unique %items]:
%unique <- []
%seen <- {}
for all %items
for all %items:
unless: % in %seen
add % to %unique
(% in %seen) <- (yes)
return %unique
immediately
immediately:
# Metatable stuff
compile [set %dict's metatable to %metatable] to {..}
statements: "setmetatable(\(%dict as lua expr), \(%metatable as lua expr));"

122
lib/control_flow.nom
View File

@ -7,12 +7,12 @@ use "lib/text.nom"
use "lib/operators.nom"
# No-Op
immediately
immediately:
compile [do nothing] to {statements:""}
# Conditionals
immediately
compile [if %condition %if_body] to
immediately:
compile [if %condition %if_body] to:
%if_body <- (%if_body as lua)
return {..}
locals: %if_body's "locals"
@ -22,7 +22,7 @@ immediately
end
parse [unless %condition %unless_body] as: if (not %condition) %unless_body
compile [if %condition %if_body else %else_body, unless %condition %else_body else %if_body] to
compile [if %condition %if_body else %else_body, unless %condition %else_body else %if_body] to:
%if_body <- (%if_body as lua)
%else_body <- (%else_body as lua)
lua> ".."
@ -47,13 +47,13 @@ immediately
%when_true_expr if %condition otherwise %when_false_expr
%when_false_expr unless %condition else %when_true_expr
%when_false_expr unless %condition then %when_true_expr
..to
..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: (%when_true_expr's "type") in {Text:yes, List:yes, Dict:yes, Number:yes}
return {..}
expr:"(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(%when_false_expr as lua expr))"
..else
..else:
#.. Otherwise, need to do an anonymous inline function (yuck, too bad lua
doesn't have a proper ternary operator!)
To see why this is necessary consider: (random()<.5 and false or 99)
@ -68,20 +68,20 @@ immediately
end)()
# GOTOs
immediately
immediately:
compile [=== %label ===, --- %label ---, *** %label ***] to {..}
statements:"::label_\(%label as lua identifier)::;"
compile [go to %label] to {..}
statements:"goto label_\(%label as lua identifier);"
# Basic loop control
immediately
immediately:
compile [do next] to {statements:"continue;"}
compile [stop] to {statements:"break;"}
# Helper function
immediately
compile [if %tree has subtree %subtree where %condition %body] to
immediately:
compile [if %tree has subtree %subtree where %condition %body] to:
%body_lua <- (%body as lua)
%body_statements <- ((%body_lua's "statements") or "\(%body_lua's "expr");")
return {..}
@ -97,22 +97,22 @@ immediately
end
# While loops
immediately
immediately:
compile [do next repeat] to {statements:"goto continue_repeat;"}
compile [stop repeating] to {statements:"goto stop_repeat;"}
compile [repeat while %condition %body] to
%body_lua <- (%body as lua)
%body_statements <- ((%body_lua's "statements") or "\(%body_lua's "expr");")
if %body has subtree % where
if %body has subtree % where:
((%'s "type") = "FunctionCall") and ((%'s "stub") is "do next repeat")
..: %body_statments +<- "\n::continue_repeat::;"
%code <- ".."
while \(%condition as lua expr) do
\%body_statements
end --while-loop
if %body has subtree % where
if %body has subtree % where:
((%'s "type") = "FunctionCall") and ((%'s "stub") is "stop repeating")
..
..:
%code <- ".."
do -- scope of "stop repeating" label
\%code
@ -124,7 +124,7 @@ immediately
compile [..]
repeat %n times %body
..to
..to:
%body_lua <- (%body as lua)
%body_statements <- ((%body_lua's "statements") or "\(%body_lua's "expr");")
if %body has subtree % where
@ -134,9 +134,9 @@ immediately
for i=1,\(%n as lua expr) do
\%body_statements
end --numeric for-loop
if %body has subtree % where
if %body has subtree % where:
((%'s "type") = "FunctionCall") and ((%'s "stub") is "stop repeating")
..
..:
%code <- ".."
do -- scope of "stop repeating" label
\%code
@ -145,21 +145,21 @@ immediately
return {statements:%code, locals:%body_lua's "locals"}
# For loop control flow:
immediately
immediately:
compile [stop %var] to {..}
statements:"goto stop_\(%var as lua identifier);"
compile [do next %var] to {..}
statements:"goto continue_\(%var as lua identifier);"
# Numeric range for loops
immediately
immediately:
compile [..]
for %var from %start to %stop by %step %body
for %var from %start to %stop via %step %body
..to
..to:
%body_lua <- (%body as lua)
%body_statements <- ((%body_lua's "statements") or "\(%body_lua's "expr");")
if %body has subtree % where
if %body has subtree % where:
((%'s "type") = "FunctionCall") and
((%'s "stub") is "do next %") and
((3rd in (%'s "value"))'s "value") is (%var's "value")
@ -172,11 +172,11 @@ immediately
\%body_statements
end --numeric for-loop
if %body has subtree % where
((%'s "type") = "FunctionCall") and
((%'s "stub") is "stop %") and
if %body has subtree % where:
((%'s "type") = "FunctionCall") and:
((%'s "stub") is "stop %") and:
((2nd in (%'s "value"))'s "value") is (%var's "value")
..
..:
%code <- ".."
do -- scope for stopping for-loop
\%code
@ -185,7 +185,7 @@ immediately
return {statements:%code, locals:%body_lua's "locals"}
immediately
immediately:
parse [for %var from %start to %stop %body] as: for %var from %start to %stop via 1 %body
parse [..]
for all %start to %stop by %step %body
@ -194,11 +194,11 @@ immediately
parse [for all %start to %stop %body] as: for all %start to %stop via 1 %body
# For-each loop (lua's "ipairs()")
immediately
compile [for %var in %iterable %body] to
immediately:
compile [for %var in %iterable %body] to:
%body_lua <- (%body as lua)
%body_statements <- ((%body_lua's "statements") or "\(%body_lua's "expr");")
if %body has subtree % where
if %body has subtree % where:
((%'s "type") = "FunctionCall") and
((%'s "stub") is "do next %") and
((3rd in (%'s "value"))'s "value") is (%var's "value")
@ -209,11 +209,11 @@ immediately
for i,\(%var as lua expr) in ipairs(\(%iterable as lua expr)) do
\%body_statements
end --foreach-loop
if %body has subtree % where
if %body has subtree % where:
((%'s "type") = "FunctionCall") and
((%'s "stub") is "stop %") and
((2nd in (%'s "value"))'s "value") is (%var's "value")
..
..:
%code <- ".."
do -- scope for stopping for-loop
\%code
@ -224,17 +224,17 @@ immediately
parse [for all %iterable %body] as: for % in %iterable %body
# Dict iteration (lua's "pairs()")
immediately
compile [for %key = %value in %iterable %body] to
immediately:
compile [for %key = %value in %iterable %body] to:
%body_lua <- (%body as lua)
%body_statements <- ((%body_lua's "statements") or "\(%body_lua's "expr");")
if %body has subtree % where
if %body has subtree % where:
((%'s "type") = "FunctionCall") and
((%'s "stub") is "do next %") and
((3rd in (%'s "value"))'s "value") is (%key's "value")
..: %body_statements +<- "\n::continue_\(%key as lua identifier)::;"
if %body has subtree % where
if %body has subtree % where:
((%'s "type") = "FunctionCall") and
((%'s "stub") is "do next %") and
((3rd in (%'s "value"))'s "value") is (%value's "value")
@ -249,13 +249,13 @@ immediately
end --foreach-loop
%stop_labels <- ""
if %body has subtree % where
if %body has subtree % where:
((%'s "type") = "FunctionCall") and
((%'s "stub") is "stop %") and
((2nd in (%'s "value"))'s "value") is (%key's "value")
..: %stop_labels +<- "\n::stop_\(%key as lua identifier)::;"
if %body has subtree % where
if %body has subtree % where:
((%'s "type") = "FunctionCall") and
((%'s "stub") is "stop %") and
((2nd in (%'s "value"))'s "value") is (%value's "value")
@ -269,14 +269,14 @@ immediately
return {statements:%code, locals:%body_lua's "locals"}
# Switch statement/multi-branch if
immediately
compile [when %body] to
immediately:
compile [when %body] to:
%code <- ""
%fallthroughs <- []
%locals <- []
%is_first <- (yes)
%seen_else <- (no)
for %func_call in (%body's "value")
for %func_call in (%body's "value"):
assume ((%func_call's "type") is "FunctionCall") or barf ".."
Invalid format for 'when' statement. Only '*' blocks are allowed.
with [..]
@ -284,7 +284,7 @@ immediately
%star <- (1st in %tokens)
%condition <- (2nd in %tokens)
%action <- (3rd in %tokens)
..
..:
assume (=lua "\%star and \%star.type == 'Word' and \%star.value == '*'") or barf ".."
Invalid format for 'when' statement. Lines must begin with '*'
assume %condition or barf ".."
@ -294,7 +294,7 @@ immediately
do next %func_call
%action <- (%action as lua)
%action_statements <- ((%action's "statements") or "\(%action's "expr");")
for %local in ((%action's "locals") or [])
for %local in ((%action's "locals") or []):
lua> "table.insert(\%locals, \%local);"
if: =lua "\%condition.type == 'Word' and \%condition.value == 'else'"
@ -304,7 +304,7 @@ immediately
else
\%action_statements
%seen_else <- (yes)
..else
..else:
assume (not %seen_else) or barf "'else' clause needs to be last in 'when' block"
lua> "table.insert(\%fallthroughs, \(%condition as lua expr));"
%condition_code <- (%fallthroughs joined with " or ")
@ -323,18 +323,18 @@ immediately
return {statements:%code, locals:%locals}
# Switch statement
immediately
compile [when %branch_value = ? %body, when %branch_value is ? %body] to
immediately:
compile [when %branch_value = ? %body, when %branch_value is ? %body] to:
%code <- ""
%fallthroughs <- []
%locals <- []
%is_first <- (yes)
%seen_else <- (no)
for %func_call in (%body's "value")
for %func_call in (%body's "value"):
assume ((%func_call's "type") is "FunctionCall") or barf ".."
Invalid format for 'when' statement. Only '*' blocks are allowed.
%tokens <- (%func_call's "value")
with [%star<-(1st in %tokens), %condition<-(2nd in %tokens), %action<-(3rd in %tokens)]
with [%star<-(1st in %tokens), %condition<-(2nd in %tokens), %action<-(3rd in %tokens)]:
assume (=lua "\%star and \%star.type == 'Word' and \%star.value == '*'") or barf ".."
Invalid format for 'when' statement. Lines must begin with '*'
assume %condition or barf ".."
@ -345,7 +345,7 @@ immediately
%action <- (%action as lua)
%action_statements <- ((%action's "statements") or "\(%action's "expr");")
for %local in ((%action's "locals") or [])
for %local in ((%action's "locals") or []):
lua> "table.insert(\%locals, \%local);"
if: =lua "\%condition.type == 'Word' and \%condition.value == 'else'"
@ -356,7 +356,7 @@ immediately
\%action_statements
end
%seen_else <- (yes)
..else
..else:
assume (not %seen_else) or barf "'else' clause needs to be last in 'when % = ?' block"
lua> "table.insert(\%fallthroughs, \(%condition as lua expr));"
for %i = % in %fallthroughs
@ -386,18 +386,18 @@ immediately
return {statements:%code, locals:%locals}
# Try/except
immediately
immediately:
compile [..]
try %action and if it succeeds %success or if it barfs %fallback
try %action and if it barfs %fallback or if it succeeds %success
..to
..to:
%locals <- []
%action_lua <- (%action as lua)
%success_lua <- (%success as lua)
%fallback_lua <- (%fallback as lua)
%fallback <- (%fallback as lua)
for %block in [%action_lua, %success_lua, %fallback_lua]
for %local in ((%block's "locals") or [])
for %block in [%action_lua, %success_lua, %fallback_lua]:
for %local in ((%block's "locals") or []):
lua> "table.insert(\%locals, \%local);"
lua> "utils.deduplicate(\%locals);"
return {..}
@ -418,18 +418,18 @@ immediately
return ret;
end
end
parse [try %action] as
parse [try %action] as:
try %action and if it succeeds: do nothing
..or if it barfs: do nothing
parse [try %action and if it barfs %fallback] as
parse [try %action and if it barfs %fallback] as:
try %action and if it succeeds: do nothing
..or if it barfs %fallback
parse [try %action and if it succeeds %success] as
parse [try %action and if it succeeds %success] as:
try %action and if it succeeds %success or if it barfs: do nothing
# Do/finally:
immediately
compile [do %action] to
immediately:
compile [do %action] to:
%action <- (%action as lua)
return {..}
locals: %action's "locals"
@ -438,12 +438,12 @@ immediately
\((%action's "statements") or "\(%action's "expr");")
end
compile [do %action then always %final_action] to
compile [do %action then always %final_action] to:
%action <- (%action as lua)
%final_action <- (%final_action as lua)
%locals <- []
for %sub_locals in [%action's "locals", %final_action's "locals"]
for %local in %sub_locals
for %sub_locals in [%action's "locals", %final_action's "locals"]:
for %local in %sub_locals:
lua> "table.insert(\%locals, \%local);"
lua> "utils.deduplicate(\%locals);"
return {..}

16
lib/math.nom
View File

@ -34,37 +34,37 @@ compile [log % base %base, log_%base %, log base %base %] to {expr:"math.log(\(%
compile [floor %] to {expr:"math.floor(\(% as lua expr))"}
compile [ceiling %, ceil %] to {expr:"math.ceil(\(% as lua expr))"}
compile [round %, % rounded] to {expr:"math.floor(\(% as lua expr) + .5)"}
action [%n to the nearest %rounder]
action [%n to the nearest %rounder]:
=lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)"
# Any/all/none
compile [all of %items, all %items] to
compile [all of %items, all %items] to:
unless: (%items' "type") is "List"
return {expr:"utils.all(\(%items as lua expr))"}
%clauses <- []
for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));"
return {expr:"(\(%clauses joined with " and "))"}
parse [not all of %items, not all %items] as: not (all of %items)
compile [any of %items, any %items] to
compile [any of %items, any %items] to:
unless: (%items' "type") is "List"
return {expr:"utils.any(\(%items as lua expr))"}
%clauses <- []
for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));"
return {expr:"(\(%clauses joined with " or "))"}
parse [none of %items, none %items] as: not (any of %items)
compile [sum of %items, sum %items] to
compile [sum of %items, sum %items] to:
unless: (%items' "type") is "List"
return {expr:"utils.sum(\(%items as lua expr))"}
%clauses <- []
for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));"
return {expr:"(\(%clauses joined with " + "))"}
compile [product of %items, product %items] to
compile [product of %items, product %items] to:
unless: (%items' "type") is "List"
return {expr:"utils.product(\(%items as lua expr))"}
%clauses <- []
for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));"
return {expr:"(\(%clauses joined with " * "))"}
action [avg of %items, average of %items]
action [avg of %items, average of %items]:
=lua "(utils.sum(\%items)/#\%items)"
compile [min of %items, smallest of %items, lowest of %items] to {..}
expr:"utils.min(\(%items as lua expr))"
@ -82,7 +82,7 @@ compile [max of %items by %value_expr] to {..}
end)
# Random functions
action [seed random with %]
action [seed random with %]:
lua> ".."
math.randomseed(\%);
for i=1,20 do math.random(); end
@ -91,5 +91,5 @@ compile [random number, random, rand] to {expr:"math.random()"}
compile [random int %n, random integer %n, randint %n] to {expr:"math.random(\(%n as lua expr))"}
compile [random from %low to %high, random number from %low to %high, rand %low %high] to
"math.random(\(%low as lua expr), \(%high as lua expr))"
action [random choice from %elements, random choice %elements, random %elements]
action [random choice from %elements, random choice %elements, random %elements]:
=lua "\%elements[math.random(#\%elements)]"

44
lib/metaprogramming.nom
View File

@ -3,7 +3,7 @@
functions to make that easier.
# Compile-time action to make compile-time actions:
immediately
immediately:
lua> ".."
nomsu:define_compile_action("compile %actions to %lua", \(!! code location !!), function(\%actions, \%lua)
local signature = {};
@ -37,8 +37,8 @@ immediately
end);
# Compile-time action to make actions
immediately
compile [action %actions %body] to
immediately:
compile [action %actions %body] to:
lua> ".."
local signature = {};
for i, action in ipairs(\%actions.value) do signature[i] = action:get_src(); end
@ -67,8 +67,8 @@ immediately
]]};
# Macro to make nomsu macros:
immediately
compile [parse %shorthand as %longhand] to
immediately:
compile [parse %shorthand as %longhand] to:
lua> ".."
local signature = {};
for i, action in ipairs(\%shorthand.value) do signature[i] = action:get_src(); end
@ -96,7 +96,7 @@ immediately
end);
]]};
action [remove action %stub]
action [remove action %stub]:
lua> ".."
local fn = ACTION[\%stub];
local metadata = ACTION_METADATA[fn];
@ -106,11 +106,11 @@ action [remove action %stub]
end
ACTION[\%stub] = nil;
immediately
action [%tree as lua]
immediately:
action [%tree as lua]:
=lua "nomsu:tree_to_lua(\%tree)"
action [%tree as lua expr]
action [%tree as lua expr]:
lua> ".."
local lua = nomsu:tree_to_lua(\%tree);
if lua.locals or not lua.expr then
@ -118,7 +118,7 @@ immediately
end
return lua.expr;
action [%tree as lua statements]
action [%tree as lua statements]:
lua> ".."
local lua = nomsu:tree_to_lua(\%tree);
local code = lua.statements or (lua.expr..";");
@ -127,24 +127,24 @@ immediately
end
return code;
action [%tree as value]
action [%tree as value]:
=lua "nomsu:tree_to_value(\%tree)"
immediately
immediately:
compile [%tree's source code, %tree' source code] to {expr:"\(%tree as lua expr):get_src()"}
compile [repr %obj] to {expr:"repr(\(%obj as lua expr))"}
compile [type of %obj] to {expr:"type(\(%obj as lua expr))"}
immediately
immediately:
compile [nomsu] to {expr:"nomsu"}
compile [%var as lua identifier] to {expr:"nomsu:var_to_lua_identifier(\(%var as lua expr))"}
action [action %names metadata]
action [action %names metadata]:
=lua "ACTION_METADATA[ACTION[\%names]]"
# Get the source code for a function
action [help %action]
action [help %action]:
lua> ".."
local metadata = \(action %action metadata);
if not metadata then
@ -154,13 +154,13 @@ action [help %action]
end
# Compiler tools
immediately
immediately:
compile [run %code] to {expr: "nomsu:run(\(%code as lua expr), '\(!! code location !!)')"}
parse [enable debugging] as: lua> "nomsu.debug = true;"
parse [disable debugging] as: lua> "nomsu.debug = false;"
immediately
compile [say %message] to
immediately:
compile [say %message] to:
lua> ".."
if \%message.type == "Text" then
return {statements="print("..\(%message as lua expr)..");"};
@ -169,17 +169,17 @@ immediately
end
# Return
immediately
immediately:
#.. 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.
compile [return] to {statements:"do return; end"}
compile [return %return_value] to {statements:"do return \(%return_value as lua expr); end"}
# Error functions
immediately
immediately:
compile [barf] to {statements:"error(nil, 0);"}
compile [barf %msg] to {statements:"error(\(%msg as lua expr), 0);"}
compile [assume %condition] to
compile [assume %condition] to:
lua> "local \%assumption = 'Assumption failed: '..\%condition:get_src();"
return {..}
statements:".."
@ -193,7 +193,7 @@ immediately
end
# Literals
immediately
immediately:
compile [yes] to {expr:"true"}
compile [no] to {expr:"false"}
compile [nothing, nil, null] to {expr:"nil"}

8
lib/object.nom
View File

@ -1,6 +1,6 @@
use "lib/core.nom"
compile [@%var] to
compile [@%var] to:
lua> ".."
local key_lua = repr(\%var.value);
local key_attr = (key_lua:match("'([a-zA-Z][a-zA-Z0-9]*)'")
@ -12,7 +12,7 @@ compile [@%var] to
end
return {expr="_me["..key_lua.."]"};
compile [@%var <- %val] to
compile [@%var <- %val] to:
lua> ".."
local val_lua = \(%val as lua expr);
local key_lua = repr(\%var.value);
@ -25,12 +25,12 @@ compile [@%var <- %val] to
end
return {statements="_me["..key_lua.."] = "..val_lua..";"};
compile [define object %classname %class_body] to
compile [define object %classname %class_body] to:
%class_identifier <- (=lua "nomsu:var_to_lua_identifier(\(%classname as value)):sub(2,-1)")
if: %class_identifier is ""
%class_identifier <- "class"
%methods <- []
for %line in (%class_body's "value")
for %line in (%class_body's "value"):
if: (%line's "type") is "Comment"
do next %line
assume (((%line's "type") == "FunctionCall") and ((%line's "stub") == "action % %"))

30
lib/operators.nom
View File

@ -4,7 +4,7 @@
use "lib/metaprogramming.nom"
# Indexing:
immediately
immediately:
#.. NOTE!!! It's critical that there are spaces around %key if it's a string,
otherwise, Lua will get confused and interpret %obj[[[foo]]] as %obj("[foo]")
instead of %obj[ "foo" ].
@ -14,7 +14,7 @@ immediately
compile [..]
%obj' %key, %obj's %key, %key in %obj, %key'th in %obj, %key of %obj,
%key st in %obj, %key nd in %obj, %key rd in %obj, %key th in %obj,
..to
..to:
lua> ".."
local obj_lua = \(%obj as lua expr);
if not obj_lua:sub(-1,-1):match("[a-zA-Z)]") then
@ -31,13 +31,13 @@ immediately
return {expr=obj_lua.."["..key_lua.."]"};
# Comparison Operators
immediately
immediately:
compile [%x < %y] to {expr:"(\(%x as lua expr) < \(%y as lua expr))"}
compile [%x > %y] to {expr:"(\(%x as lua expr) > \(%y as lua expr))"}
compile [%x <= %y] to {expr:"(\(%x as lua expr) <= \(%y as lua expr))"}
compile [%x >= %y] to {expr:"(\(%x as lua expr) >= \(%y as lua expr))"}
# TODO: optimize case of [%x,%y] = [1,2]
compile [%a is %b, %a = %b, %a == %b] to
compile [%a is %b, %a = %b, %a == %b] to:
lua> ".."
local safe = {Text=true, Number=true};
local a_lua, b_lua = nomsu:tree_to_lua(\%a).expr, nomsu:tree_to_lua(\%b).expr;
@ -46,7 +46,7 @@ immediately
else
return {expr="utils.equivalent("..a_lua..", "..b_lua..")"};
end
compile [%a isn't %b, %a is not %b, %a not= %b, %a != %b] to
compile [%a isn't %b, %a is not %b, %a not= %b, %a != %b] to:
lua> ".."
local safe = {Text=true, Number=true};
local a_lua, b_lua = nomsu:tree_to_lua(\%a).expr, nomsu:tree_to_lua(\%b).expr;
@ -59,8 +59,8 @@ immediately
compile [%'s id, id of %] to {expr:"nomsu.ids[\(% as lua expr)]"}
# Variable assignment operator
immediately
compile [%var <- %value] to
immediately:
compile [%var <- %value] to:
lua> "local \%var_lua = nomsu:tree_to_lua(\%var);"
assume (%var_lua's "expr") or barf "Invalid target for assignment: \(%var's source code)"
lua> "local \%value_lua = nomsu:tree_to_lua(\%value);"
@ -69,9 +69,9 @@ immediately
statements:"\(%var_lua's "expr") = \(%value_lua's "expr");"
locals: =lua "(\%var.type == 'Var' and {\%var_lua.expr} or nil)"
immediately
immediately:
# Simultaneous mutli-assignments like: x,y,z = 1,x,3;
compile [<- %assignments] to
compile [<- %assignments] to:
%locals <- []
%targets <- []
%values <- []
@ -93,15 +93,15 @@ immediately
utils.deduplicate(\%locals);
return {locals=\%locals, statements=(table.concat(\%targets, ", ").." = "..table.concat(\%values, ", ")..";")};
immediately
compile [export %var <- %value] to
immediately:
compile [export %var <- %value] to:
%var_lua <- (%var as lua)
assume (%var_lua's "expr") or barf "Invalid target for assignment: \(%var's source code)"
%value_lua <- (%value as lua)
assume (%value_lua's "expr") or barf "Invalid value for assignment: \(%value's source code)"
return {statements:"\(%var_lua's "expr") = \(%value_lua's "expr");"}
compile [exporting %exported %body] to
compile [exporting %exported %body] to:
%body_lua <- (%body as lua)
%leftover_locals <- (=lua "{unpack(\%body_lua.locals or {})}")
assume ((%exported's "type") = "List") or barf ".."
@ -116,7 +116,7 @@ immediately
end
return {locals:%leftover_locals, statements:=lua "\%body_lua.statements or (\%body_lua.expr..';')"}
compile [with %assignments %body] to
compile [with %assignments %body] to:
%body_lua <- (%body as lua)
%locals <- []
%declarations <- []
@ -158,7 +158,7 @@ immediately
%s
end]]):format(locals_code, declaration_code, \%body_lua.statements or (\%body_lua.expr..";"))};
immediately
immediately:
# Math Operators
compile [%x + %y] to {expr:"(\(%x as lua expr) + \(%y as lua expr))"}
compile [%x - %y] to {expr:"(\(%x as lua expr) - \(%y as lua expr))"}
@ -198,7 +198,7 @@ immediately
compile [not %] to {expr:"(not \(% as lua expr))"}
# Update operators
immediately
immediately:
parse [%var + <- %, %var +<- %] as: %var <- (%var + %)
parse [%var - <- %, %var -<- %] as: %var <- (%var - %)
parse [%var * <- %, %var *<- %] as: %var <- (%var * %)

10
lib/text.nom
View File

@ -5,18 +5,18 @@
use "lib/metaprogramming.nom"
# Text functions
action [%texts joined with %glue]
action [%texts joined with %glue]:
lua> ".."
local text_bits = {}
for i,bit in ipairs(\%texts) do text_bits[i] = stringify(bit) end
return table.concat(text_bits, \%glue)
parse [joined %texts, %texts joined] as: %texts joined with ""
compile [capitalized %text, %text capitalized] to
{expr:"((\(%text as lua expr)):gsub('%l', string.upper, 1))"}
compile [capitalized %text, %text capitalized] to {..}
expr:"((\(%text as lua expr)):gsub('%l', string.upper, 1))"
compile [%text with %sub instead of %patt, %text s/%patt/%sub] to
{expr:"((\(%text as lua expr)):gsub(\(%patt as lua expr), \(%sub as lua expr)))"}
compile [%text with %sub instead of %patt, %text s/%patt/%sub] to {..}
expr:"((\(%text as lua expr)):gsub(\(%patt as lua expr), \(%sub as lua expr)))"
# TODO: figure out whether indent/dedent should affect first line
compile [indented %text, %text indented] to {expr:"((\%text):gsub('\\n','\\n'..(' ')))"}

4
lib/training_wheels.nom
View File

@ -26,11 +26,11 @@ parse [error!, panic!, fail!, abort!] as: barf!
parse [error %, panic %, fail %, abort %] as: barf %
parse [assert %condition %message] as: assume %condition or barf %message
parse [%cond ? %if_true %if_false] as: %if_true if %cond else %if_false
compile [function %args %body, lambda %args %body] to
compile [function %args %body, lambda %args %body] to:
%body_lua <- (%body as lua)
%statements <- ((%body_lua's "statements") or "return \(%body_lua's "expr");")
%locals <- (% for all ((%body_lua's "locals") or []))
for all (%args's "value")
for all (%args's "value"):
lua> "utils.remove_from_list(\%locals, \(% as lua expr));"
if: (size of %locals) > 0
%statements <- "local \(%locals joined with ", ");\n\%statements"