From a387fd86a870bd1a34f206ec89c32d9d5c4d1c77 Mon Sep 17 00:00:00 2001 From: Bruce Hill Date: Wed, 31 Jan 2018 15:31:06 -0800 Subject: [PATCH] Added colons for aesthetics. --- lib/collections.nom | 54 +++++++++--------- lib/control_flow.nom | 122 ++++++++++++++++++++-------------------- lib/math.nom | 16 +++--- lib/metaprogramming.nom | 44 +++++++-------- lib/object.nom | 8 +-- lib/operators.nom | 30 +++++----- lib/text.nom | 10 ++-- lib/training_wheels.nom | 4 +- 8 files changed, 144 insertions(+), 144 deletions(-) diff --git a/lib/collections.nom b/lib/collections.nom index 5b74d85..a8cb20f 100644 --- a/lib/collections.nom +++ b/lib/collections.nom @@ -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));" diff --git a/lib/control_flow.nom b/lib/control_flow.nom index cfaa7ad..75cf6fd 100644 --- a/lib/control_flow.nom +++ b/lib/control_flow.nom @@ -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 {..} diff --git a/lib/math.nom b/lib/math.nom index 13c6cc3..70e7de4 100644 --- a/lib/math.nom +++ b/lib/math.nom @@ -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)]" diff --git a/lib/metaprogramming.nom b/lib/metaprogramming.nom index c6bf491..544ae59 100644 --- a/lib/metaprogramming.nom +++ b/lib/metaprogramming.nom @@ -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"} diff --git a/lib/object.nom b/lib/object.nom index f3fcd86..4d8932a 100644 --- a/lib/object.nom +++ b/lib/object.nom @@ -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 % %")) diff --git a/lib/operators.nom b/lib/operators.nom index 670e7b7..5d5a7a8 100644 --- a/lib/operators.nom +++ b/lib/operators.nom @@ -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 * %) diff --git a/lib/text.nom b/lib/text.nom index cd424b9..2a111fe 100644 --- a/lib/text.nom +++ b/lib/text.nom @@ -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'..(' ')))"} diff --git a/lib/training_wheels.nom b/lib/training_wheels.nom index c4a9903..30c20fc 100644 --- a/lib/training_wheels.nom +++ b/lib/training_wheels.nom @@ -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"