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

Re-autoformatted everything. The main changes are: no longer adding a

Browse Source 
newline after 1-line indented code inside blocks, and forcing files to
have a trailing newline. The trailing newline thing created a lot of
spurious changes.
This commit is contained in:
Bruce Hill 2018-07-22 15:01:05 -07:00
parent 4fa9757fa2
commit addac10a47
36 changed files with 90 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
compatibility/2.4.nom
View File

@ -10,30 +10,23 @@ upgrade %tree to "2.4" as:
%new_lines = [] %new_lines = []
%body = (..) %body = (..)
(%tree.2 upgraded) if (%tree.2 is "Block" syntax tree) else [%tree.2 upgraded] (%tree.2 upgraded) if (%tree.2 is "Block" syntax tree) else [%tree.2 upgraded]
for %line in %body: for %line in %body:
if: if:
(not (%line is syntax tree)): (not (%line is syntax tree)):
compile error at %tree.source "WUT: %s" compile error at %tree.source "WUT: %s"
(not (%line is "Action" syntax tree)): (not (%line is "Action" syntax tree)):
add %line to %new_lines add %line to %new_lines
(%line.stub is "* %"): (%line.stub is "* %"):
add %line.2 to %conditions add %line.2 to %conditions
(%line.stub == "* else %"): (%line.stub == "* else %"):
add (\(else %block) with vars {block:%line.3}) to %new_lines add (\(else %block) with vars {block:%line.3}) to %new_lines
(%line.stub != "* % %"): (%line.stub != "* % %"):
add %line to %new_lines add %line to %new_lines
else: else:
add %line.2 to %conditions add %line.2 to %conditions
%action = %line.3 %action = %line.3
unless (%action is "Block" syntax tree): unless (%action is "Block" syntax tree):
%action = (=lua "Block(\%action.source, \%action)") %action = (=lua "Block(\%action.source, \%action)")
add %action to %conditions add %action to %conditions
add (=lua "Action(\%conditions[1].source, unpack(\%conditions))") to %new_lines add (=lua "Action(\%conditions[1].source, unpack(\%conditions))") to %new_lines
%conditions = [] %conditions = []
@ -46,27 +39,21 @@ upgrade %tree to "2.4" as:
%new_lines = [] %new_lines = []
%body = (..) %body = (..)
(%tree.5 upgraded) if (%tree.5 is "Block" syntax tree) else [%tree.5 upgraded] (%tree.5 upgraded) if (%tree.5 is "Block" syntax tree) else [%tree.5 upgraded]
for %line in %body: for %line in %body:
if: if:
(not (%line is "Action" syntax tree)): (not (%line is "Action" syntax tree)):
add %line to %new_lines add %line to %new_lines
(%line.stub is "* %"): (%line.stub is "* %"):
add %line.2 to %values add %line.2 to %values
(%line.stub == "* else %"): (%line.stub == "* else %"):
add (\(else %block) with vars {block:%line.3}) to %new_lines add (\(else %block) with vars {block:%line.3}) to %new_lines
(%line.stub != "* % %"): (%line.stub != "* % %"):
add %line to %new_lines add %line to %new_lines
else: else:
add %line.2 to %values add %line.2 to %values
%action = %line.3 %action = %line.3
unless (%action is "Block" syntax tree): unless (%action is "Block" syntax tree):
%action = (=lua "Block(\%action.source, \%action)") %action = (=lua "Block(\%action.source, \%action)")
add %action to %values add %action to %values
add (=lua "Action(\%values[1].source, unpack(\%values))") to %new_lines add (=lua "Action(\%values[1].source, unpack(\%values))") to %new_lines
%values = [] %values = []

2
compatibility/2.nom
View File

@ -8,11 +8,9 @@ upgrade %tree to "2" as:
%true_body = (%tree.3 upgraded) %true_body = (%tree.3 upgraded)
unless (%true_body is "Block" syntax tree): unless (%true_body is "Block" syntax tree):
%true_body = (=lua "Block(\%true_body.source, \%true_body)") %true_body = (=lua "Block(\%true_body.source, \%true_body)")
%false_body = (%tree.5 upgraded) %false_body = (%tree.5 upgraded)
unless (%false_body is "Block" syntax tree): unless (%false_body is "Block" syntax tree):
%false_body = (=lua "Block(\%false_body.source, \%false_body)") %false_body = (=lua "Block(\%false_body.source, \%false_body)")
return (..) return (..)
\(if %cond %true_body else %false_body) with vars {..} \(if %cond %true_body else %false_body) with vars {..}
cond:%tree.2 upgraded, true_body:%true_body, false_body:%false_body cond:%tree.2 upgraded, true_body:%true_body, false_body:%false_body

3
compatibility/compatibility.nom
View File

@ -10,7 +10,6 @@ action [upgrade to %version via %upgrade_fn]:
action [upgrade action %stub to %version via %upgrade_fn]: action [upgrade action %stub to %version via %upgrade_fn]:
unless %ACTION_UPGRADES.%version: unless %ACTION_UPGRADES.%version:
%ACTION_UPGRADES.%version = [] %ACTION_UPGRADES.%version = []
%ACTION_UPGRADES.%version.%stub = %upgrade_fn %ACTION_UPGRADES.%version.%stub = %upgrade_fn
parse [upgrade %tree to %version as %body] as (..) parse [upgrade %tree to %version as %body] as (..)
@ -58,10 +57,8 @@ action [..]
%versions = {} %versions = {}
for %v = % in %UPGRADES: for %v = % in %UPGRADES:
%versions.%v = (yes) %versions.%v = (yes)
for %v = % in %ACTION_UPGRADES: for %v = % in %ACTION_UPGRADES:
%versions.%v = (yes) %versions.%v = (yes)
%versions = ((keys in %versions) sorted by % -> (% as list)) %versions = ((keys in %versions) sorted by % -> (% as list))
for %ver in %versions: for %ver in %versions:
if ((%ver as list) <= (%start_version as list)): do next %ver if ((%ver as list) <= (%start_version as list)): do next %ver

11
core/collections.nom
View File

@ -29,7 +29,6 @@ test:
action [%item is in %list, %list contains %item, %list has %item]: action [%item is in %list, %list contains %item, %list has %item]:
for %key = %value in %list: for %key = %value in %list:
if (%key is %item): return (yes) if (%key is %item): return (yes)
return (no) return (no)
test: test:
@ -41,7 +40,6 @@ action [..]
..: ..:
for %key = %value in %list: for %key = %value in %list:
if (%key is %item): return (no) if (%key is %item): return (no)
return (yes) return (yes)
test: test:
@ -94,7 +92,6 @@ parse [%expression for %item in %iterable] as (..)
%comprehension = [] %comprehension = []
for %item in %iterable: for %item in %iterable:
add %expression to %comprehension add %expression to %comprehension
return %comprehension return %comprehension
parse [..] parse [..]
@ -105,7 +102,6 @@ parse [..]
%comprehension = [] %comprehension = []
for %index in %start to %stop via %step: for %index in %start to %stop via %step:
add %expression to %comprehension add %expression to %comprehension
return %comprehension return %comprehension
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -127,10 +123,8 @@ parse [..]
%comprehension = [] %comprehension = []
for %key = %value in %iterable: for %key = %value in %iterable:
add %expression to %comprehension add %expression to %comprehension
return %comprehension return %comprehension
# Dict comprehensions # Dict comprehensions
test: test:
assume (((% * %) = % for % in [1, 2, 3]) == {1:1, 4:2, 9:3}) assume (((% * %) = % for % in [1, 2, 3]) == {1:1, 4:2, 9:3})
@ -141,7 +135,6 @@ parse [%key = %value for %item in %iterable, %key %value for %item in %iterable]
%comprehension = {} %comprehension = {}
for %item in %iterable: for %item in %iterable:
%comprehension.%key = %value %comprehension.%key = %value
return %comprehension return %comprehension
test: test:
@ -155,7 +148,6 @@ parse [..]
%comprehension = {} %comprehension = {}
for %src_key = %src_value in %iterable: for %src_key = %src_value in %iterable:
%comprehension.%key = %value %comprehension.%key = %value
return %comprehension return %comprehension
parse [..] parse [..]
@ -166,7 +158,6 @@ parse [..]
%comprehension = {} %comprehension = {}
for %item in %start to %stop via %step: for %item in %start to %stop via %step:
%comprehension.%key = %value %comprehension.%key = %value
return %comprehension return %comprehension
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -186,7 +177,6 @@ action [%lists flattened]:
%flat = [] %flat = []
for %list in %lists: for %list in %lists:
for %item in %list: add %item to %flat for %item in %list: add %item to %flat
return %flat return %flat
test: test:
@ -222,7 +212,6 @@ compile [%dict with fallback %key -> %value] to (..)
return value return value
end}) end})
# Sorting # Sorting
test: test:
%x = [3, 1, 2] %x = [3, 1, 2]

67
core/control_flow.nom
View File

@ -76,7 +76,6 @@ compile [..]
end end
end)()) end)())
# GOTOs # GOTOs
test: test:
%i = 0 %i = 0
@ -125,10 +124,8 @@ compile [repeat while %condition %body] to:
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
to %lua write "\n ::continue::" to %lua write "\n ::continue::"
if (%body has subtree \(do next repeat)): if (%body has subtree \(do next repeat)):
to %lua write "\n ::continue_repeat::" to %lua write "\n ::continue_repeat::"
to %lua write "\nend --while-loop" to %lua write "\nend --while-loop"
if (%body has subtree \(stop repeating)): if (%body has subtree \(stop repeating)):
%lua = (..) %lua = (..)
@ -142,7 +139,6 @@ compile [repeat while %condition %body] to:
parse [repeat %body] as (repeat while (yes) %body) parse [repeat %body] as (repeat while (yes) %body)
parse [repeat until %condition %body] as (repeat while (not %condition) %body) parse [repeat until %condition %body] as (repeat while (not %condition) %body)
test: test:
%x = 0 %x = 0
repeat 10 times: %x += 1 repeat 10 times: %x += 1
@ -156,10 +152,8 @@ compile [repeat %n times %body] to:
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
to %lua write "\n ::continue::" to %lua write "\n ::continue::"
if (%body has subtree \(do next repeat)): if (%body has subtree \(do next repeat)):
to %lua write "\n ::continue_repeat::" to %lua write "\n ::continue_repeat::"
to %lua write "\nend --numeric for-loop" to %lua write "\nend --numeric for-loop"
if (%body has subtree \(stop repeating)): if (%body has subtree \(stop repeating)):
%lua = (..) %lua = (..)
@ -195,8 +189,10 @@ test:
if (%inner == 2): if (%inner == 2):
add -2 to %nums add -2 to %nums
do next %inner do next %inner
add %inner to %nums add %inner to %nums
if (%inner == 5): stop %outer if (%inner == 5): stop %outer
assume (%nums == [1, -2, 3, -2, 3, 4, 3, 4, 5]) assume (%nums == [1, -2, 3, -2, 3, 4, 3, 4, 5])
# Numeric range for loops # Numeric range for loops
@ -208,7 +204,6 @@ compile [..]
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
unless (%var.type is "Var"): unless (%var.type is "Var"):
compile error at %var.source "Loop expected variable, not: %s" compile error at %var.source "Loop expected variable, not: %s"
%lua = (..) %lua = (..)
Lua ".." Lua ".."
for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(..) for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(..)
@ -218,10 +213,8 @@ compile [..]
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
to %lua write "\n ::continue::" to %lua write "\n ::continue::"
if (%body has subtree (\(do next %v) with vars {v:%var})): if (%body has subtree (\(do next %v) with vars {v:%var})):
to %lua write "\n \(compile as (===next %var ===))" to %lua write "\n \(compile as (===next %var ===))"
to %lua write "\nend --numeric for-loop" to %lua write "\nend --numeric for-loop"
if (%body has subtree (\(stop %v) with vars {v:%var})): if (%body has subtree (\(stop %v) with vars {v:%var})):
%lua = (..) %lua = (..)
@ -248,6 +241,7 @@ test:
if (%x == 10): do next %x if (%x == 10): do next %x
if (%x == 50): stop %x if (%x == 50): stop %x
add %x to %b add %x to %b
assume (%b == [20, 30, 40]) assume (%b == [20, 30, 40])
# For-each loop (lua's "ipairs()") # For-each loop (lua's "ipairs()")
@ -256,7 +250,6 @@ compile [for %var in %iterable %body] to:
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
unless (%var.type is "Var"): unless (%var.type is "Var"):
compile error at %var.source "Loop expected variable, not: %s" compile error at %var.source "Loop expected variable, not: %s"
%lua = (..) %lua = (..)
Lua ".." Lua ".."
for i,\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do for i,\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
@ -264,10 +257,8 @@ compile [for %var in %iterable %body] to:
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
to %lua write "\n ::continue::" to %lua write "\n ::continue::"
if (%body has subtree (\(do next %v) with vars {v:%var})): if (%body has subtree (\(do next %v) with vars {v:%var})):
to %lua write (Lua "\n\(compile as (===next %var ===))") to %lua write (Lua "\n\(compile as (===next %var ===))")
to %lua write "\nend --foreach-loop" to %lua write "\nend --foreach-loop"
if (%body has subtree (\(stop %v) with vars {v:%var})): if (%body has subtree (\(stop %v) with vars {v:%var})):
%lua = (..) %lua = (..)
@ -286,6 +277,7 @@ test:
if (%k == "a"): do next %k if (%k == "a"): do next %k
if (%v == 20): do next %v if (%v == 20): do next %v
add "\%k = \%v" to %result add "\%k = \%v" to %result
assume ((%result sorted) == ["c = 30", "d = 40", "e = 50"]) assume ((%result sorted) == ["c = 30", "d = 40", "e = 50"])
# Dict iteration (lua's "pairs()") # Dict iteration (lua's "pairs()")
@ -296,10 +288,8 @@ compile [..]
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
unless (%key.type is "Var"): unless (%key.type is "Var"):
compile error at %key.source "Loop expected variable, not: %s" compile error at %key.source "Loop expected variable, not: %s"
unless (%value.type is "Var"): unless (%value.type is "Var"):
compile error at %value.source "Loop expected variable, not: %s" compile error at %value.source "Loop expected variable, not: %s"
%lua = (..) %lua = (..)
Lua ".." Lua ".."
for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(..) for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(..)
@ -309,21 +299,16 @@ compile [..]
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
to %lua write "\n ::continue::" to %lua write "\n ::continue::"
if (%body has subtree (\(do next %v) with vars {v:%key})): if (%body has subtree (\(do next %v) with vars {v:%key})):
to %lua write (Lua "\n\(compile as (===next %key ===))") to %lua write (Lua "\n\(compile as (===next %key ===))")
if (%body has subtree (\(do next %v) with vars {v:%value})): if (%body has subtree (\(do next %v) with vars {v:%value})):
to %lua write (Lua "\n\(compile as (===next %value ===))") to %lua write (Lua "\n\(compile as (===next %value ===))")
to %lua write "\nend --foreach-loop" to %lua write "\nend --foreach-loop"
%stop_labels = (Lua "") %stop_labels = (Lua "")
if (%body has subtree (\(stop %v) with vars {v:%key})): if (%body has subtree (\(stop %v) with vars {v:%key})):
to %stop_labels write "\n\(compile as (===stop %key ===))" to %stop_labels write "\n\(compile as (===stop %key ===))"
if (%body has subtree (\(stop %v) with vars {v:%value})): if (%body has subtree (\(stop %v) with vars {v:%value})):
to %stop_labels write "\n\(compile as (===stop %value ===))" to %stop_labels write "\n\(compile as (===stop %value ===))"
if ((length of "\%stop_labels") > 0): if ((length of "\%stop_labels") > 0):
%lua = (..) %lua = (..)
Lua ".." Lua ".."
@ -337,11 +322,15 @@ compile [..]
test: test:
if: if:
(1 == 2) (100 < 0): barf "bad conditional" (1 == 2) (100 < 0):
(1 == 0) (1 == 1) (%not_a_variable.x): do nothing barf "bad conditional"
(1 == 1): barf "bad conditional" (1 == 0) (1 == 1) %not_a_variable.x: do nothing
(1 == 2): barf "bad conditional" (1 == 1):
else: barf "bad conditional" barf "bad conditional"
(1 == 2):
barf "bad conditional"
else:
barf "bad conditional"
# Multi-branch conditional (if..elseif..else) # Multi-branch conditional (if..elseif..else)
compile [if %body, when %body] to: compile [if %body, when %body] to:
@ -350,7 +339,6 @@ compile [if %body, when %body] to:
%else_allowed = (yes) %else_allowed = (yes)
unless (%body.type is "Block"): unless (%body.type is "Block"):
compile error at %body.source "'if' expected a Block, but got: %s" compile error at %body.source "'if' expected a Block, but got: %s"
for %line in %body: for %line in %body:
unless (..) unless (..)
((%line.type is "Action") and ((length of %line) >= 2)) and (..) ((%line.type is "Action") and ((length of %line) >= 2)) and (..)
@ -364,7 +352,6 @@ compile [if %body, when %body] to:
if ((%line.1 is "else") and ((length of %line) == 2)): if ((%line.1 is "else") and ((length of %line) == 2)):
unless %else_allowed: unless %else_allowed:
compile error at %line.source "Can't have two 'else' blocks" compile error at %line.source "Can't have two 'else' blocks"
unless ((length of "\%code") > 0): unless ((length of "\%code") > 0):
compile error at %line.source ".." compile error at %line.source ".."
Can't have an 'else' block without a preceeding condition Can't have an 'else' block without a preceeding condition
@ -385,7 +372,6 @@ compile [if %body, when %body] to:
if (%i > 1): if (%i > 1):
to %code write " or " to %code write " or "
to %code write (%line.%i as lua expr) to %code write (%line.%i as lua expr)
to %code write ".." to %code write ".."
@ -396,16 +382,18 @@ compile [if %body, when %body] to:
if ((length of "\%code") == 0): if ((length of "\%code") == 0):
compile error at %body.source "'if' block has an empty body" compile error at %body.source "'if' block has an empty body"
to %code write "\nend --when" to %code write "\nend --when"
return %code return %code
test: test:
if 5 is: if 5 is:
1 2 3: barf "bad switch statement" 1 2 3:
barf "bad switch statement"
4 5: do nothing 4 5: do nothing
5 6: barf "bad switch statement" 5 6:
else: barf "bad switch statement" barf "bad switch statement"
else:
barf "bad switch statement"
# Switch statement # Switch statement
compile [if %branch_value is %body, when %branch_value is %body] to: compile [if %branch_value is %body, when %branch_value is %body] to:
@ -414,7 +402,6 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
%else_allowed = (yes) %else_allowed = (yes)
unless (%body.type is "Block"): unless (%body.type is "Block"):
compile error at %body.source "'if' expected a Block, but got: %s" compile error at %body.source "'if' expected a Block, but got: %s"
for %line in %body: for %line in %body:
unless (..) unless (..)
((%line.type is "Action") and ((length of %line) >= 2)) and (..) ((%line.type is "Action") and ((length of %line) >= 2)) and (..)
@ -428,7 +415,6 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
if ((%line.1 is "else") and ((length of %line) == 2)): if ((%line.1 is "else") and ((length of %line) == 2)):
unless %else_allowed: unless %else_allowed:
compile error at %line.source "Can't have two 'else' blocks" compile error at %line.source "Can't have two 'else' blocks"
unless ((length of "\%code") > 0): unless ((length of "\%code") > 0):
compile error at %line.source ".." compile error at %line.source ".."
Can't have an 'else' block without a preceeding condition Can't have an 'else' block without a preceeding condition
@ -449,7 +435,6 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
if (%i > 1): if (%i > 1):
to %code write " or " to %code write " or "
to %code write "branch_value == \(%line.%i as lua expr)" to %code write "branch_value == \(%line.%i as lua expr)"
to %code write ".." to %code write ".."
@ -460,7 +445,6 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
if ((length of "\%code") == 0): if ((length of "\%code") == 0):
compile error at %body.source "'if % is % %' block has an empty body" compile error at %body.source "'if % is % %' block has an empty body"
to %code write "\nend --when" to %code write "\nend --when"
return (..) return (..)
Lua ".." Lua ".."
@ -469,7 +453,6 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
\%code \%code
end --if % is end --if % is
# Do/finally # Do/finally
compile [do %action] to (..) compile [do %action] to (..)
Lua ".." Lua ".."
@ -483,9 +466,9 @@ test:
do: do:
%d.x = "bad" %d.x = "bad"
barf barf
..then always: ..then always: %d.x = "good"
%d.x = "good"
..and if it barfs: do nothing ..and if it barfs: do nothing
assume (%d.x == "good") assume (%d.x == "good")
compile [do %action then always %final_action] to (..) compile [do %action then always %final_action] to (..)
@ -502,11 +485,10 @@ compile [do %action then always %final_action] to (..)
end end
test: test:
assume ((result of: return 99) == 99) assume ((result of (: return 99)) == 99)
# Inline thunk: # Inline thunk:
compile [result of %body] to (Lua value "(\(compile as ([] -> %body)))()") compile [result of %body] to (Lua value "(\(compile as ([] -> %body)))()")
test: test:
%t = [1, [2, [[3], 4], 5, [[[6]]]]] %t = [1, [2, [[3], 4], 5, [[[6]]]]]
%flat = [] %flat = []
@ -522,7 +504,6 @@ compile [for %var in recursive %structure %body] to (..)
with local compile actions: with local compile actions:
compile [recurse %v on %x] to (..) compile [recurse %v on %x] to (..)
Lua "table.insert(stack\(%v as lua id), \(%x as lua expr))" Lua "table.insert(stack\(%v as lua id), \(%x as lua expr))"
%lua = (..) %lua = (..)
Lua ".." Lua ".."
do do
@ -533,14 +514,10 @@ compile [for %var in recursive %structure %body] to (..)
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
to %lua write "\n ::continue::" to %lua write "\n ::continue::"
if (%body has subtree (\(do next %v) with vars {v:%var})): if (%body has subtree (\(do next %v) with vars {v:%var})):
to %lua write "\n \(compile as (===next %var ===))" to %lua write "\n \(compile as (===next %var ===))"
to %lua write "\n end -- Recursive loop" to %lua write "\n end -- Recursive loop"
if (%body has subtree (\(stop %v) with vars {v:%var})): if (%body has subtree (\(stop %v) with vars {v:%var})):
to %lua write "\n \(compile as (===stop %var ===))" to %lua write "\n \(compile as (===stop %var ===))"
to %lua write "\nend -- Recursive scope" to %lua write "\nend -- Recursive scope"
return %lua return %lua

1
core/errors.nom
View File

@ -14,7 +14,6 @@ compile [compile error at %source %msg] to (..)
compile [assume %condition] to: compile [assume %condition] to:
lua> ".." lua> ".."
local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\%condition)) local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\%condition))
return (..) return (..)
Lua ".." Lua ".."
if not \(%condition as lua expr) then if not \(%condition as lua expr) then

10
core/math.nom
View File

@ -10,7 +10,8 @@ use "core/collections.nom"
# Literals: # Literals:
test: test:
assume (all of [inf, NaN, pi, tau, golden ratio, e]) or barf "math constants failed" assume (all of [inf, NaN, pi, tau, golden ratio, e]) or barf ".."
math constants failed
%nan = (NaN) %nan = (NaN)
assume (%nan != %nan) or barf "NaN failed" assume (%nan != %nan) or barf "NaN failed"
@ -62,7 +63,6 @@ compile [log % base %base, log base %base of %] to (..)
compile [floor %] to (Lua value "math.floor(\(% as lua expr))") compile [floor %] to (Lua value "math.floor(\(% as lua expr))")
compile [ceiling %, ceil %] to (Lua value "math.ceil(\(% as lua expr))") compile [ceiling %, ceil %] to (Lua value "math.ceil(\(% as lua expr))")
compile [round %, % rounded] to (Lua value "math.floor(\(% as lua expr) + .5)") compile [round %, % rounded] to (Lua value "math.floor(\(% as lua expr) + .5)")
test: test:
assume ((463 to the nearest 100) == 500) or barf "rounding failed" assume ((463 to the nearest 100) == 500) or barf "rounding failed"
assume ((2.6 to the nearest 0.25) == 2.5) or barf "rounding failed" assume ((2.6 to the nearest 0.25) == 2.5) or barf "rounding failed"
@ -70,12 +70,10 @@ test:
action [%n to the nearest %rounder] (..) action [%n to the nearest %rounder] (..)
=lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)" =lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)"
# Any/all/none # Any/all/none
compile [all of %items, all %items] to: compile [all of %items, all %items] to:
unless (%items.type is "List"): unless (%items.type is "List"):
return (Lua value "utils.all(\(%items as lua expr))") return (Lua value "utils.all(\(%items as lua expr))")
%clauses = ((% as lua expr) for % in %items) %clauses = ((% as lua expr) for % in %items)
return (Lua value "(\(%clauses joined with " and "))") return (Lua value "(\(%clauses joined with " and "))")
@ -83,7 +81,6 @@ 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"): unless (%items.type is "List"):
return (Lua value "utils.any(\(%items as lua expr))") return (Lua value "utils.any(\(%items as lua expr))")
%clauses = ((% as lua expr) for % in %items) %clauses = ((% as lua expr) for % in %items)
return (Lua value "(\(%clauses joined with " or "))") return (Lua value "(\(%clauses joined with " or "))")
@ -91,14 +88,12 @@ 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"): unless (%items.type is "List"):
return (Lua value "utils.sum(\(%items as lua expr))") return (Lua value "utils.sum(\(%items as lua expr))")
%clauses = ((% as lua expr) for % in %items) %clauses = ((% as lua expr) for % in %items)
return (Lua value "(\(%clauses joined with " + "))") return (Lua value "(\(%clauses joined with " + "))")
compile [product of %items, product %items] to: compile [product of %items, product %items] to:
unless (%items.type is "List"): unless (%items.type is "List"):
return (Lua value "utils.product(\(%items as lua expr))") return (Lua value "utils.product(\(%items as lua expr))")
%clauses = ((% as lua expr) for % in %items) %clauses = ((% as lua expr) for % in %items)
return (Lua value "(\(%clauses joined with " * "))") return (Lua value "(\(%clauses joined with " * "))")
@ -133,7 +128,6 @@ parse [max of %items by %item = %value_expr] as (..)
return %best return %best
# Random functions # Random functions
action [seed random with %] (..) action [seed random with %] (..)
lua> ".." lua> ".."

29
core/metaprogramming.nom
View File

@ -30,10 +30,13 @@ lua> ".."
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test: compile [five] to (Lua value "5") test:
compile [five] to (Lua value "5")
test: test:
assume ((five) == 5) or barf "Compile to expression failed." assume ((five) == 5) or barf "Compile to expression failed."
compile [loc x] to (Lua "local _x = 99;") compile [loc x] to (Lua "local _x = 99;")
test: test:
lua> "do" lua> "do"
loc x loc x
@ -43,6 +46,7 @@ test:
compile [asdf] to: compile [asdf] to:
%tmp = "" %tmp = ""
return (Lua %tmp) return (Lua %tmp)
test: test:
asdf asdf
assume (%tmp is (nil)) or barf "compile to is leaking variables" assume (%tmp is (nil)) or barf "compile to is leaking variables"
@ -81,9 +85,7 @@ compile [call %fn with %args] to (..)
return lua return lua
test: test:
local action [foo %x]: local action [foo %x]: return "outer"
return "outer"
with local [action (foo %)]: with local [action (foo %)]:
local action [foo %x]: local action [foo %x]:
%y = (%x + 1) %y = (%x + 1)
@ -137,7 +139,6 @@ test:
assume ((action (say %)) == (=lua "A_say_1")) assume ((action (say %)) == (=lua "A_say_1"))
compile [action %action] to (Lua value (%action as lua id)) compile [action %action] to (Lua value (%action as lua id))
test: test:
parse [swap %x and %y] as (..) parse [swap %x and %y] as (..)
do: do:
@ -150,7 +151,6 @@ test:
swap %1 and %2 swap %1 and %2
assume ((%1 == 2) and (%2 == 1)) or barf ".." assume ((%1 == 2) and (%2 == 1)) or barf ".."
'parse % as %' failed on 'swap % and %' 'parse % as %' failed on 'swap % and %'
set {%tmp:1, %tmp2:2} set {%tmp:1, %tmp2:2}
swap %tmp and %tmp2 swap %tmp and %tmp2
assume ((%tmp == 2) and (%tmp2 == 1)) or barf ".." assume ((%tmp == 2) and (%tmp2 == 1)) or barf ".."
@ -270,10 +270,14 @@ compile [to %lua write %code joined by %glue] to (..)
\(%lua as lua expr):concat_append(\(%code as lua expr), \(%glue as lua expr)); \(%lua as lua expr):concat_append(\(%code as lua expr), \(%glue as lua expr));
test: test:
assume ((quote "one\n\"two\"") == "\"one\\n\\\"two\\\"\"") assume (..)
(..)
quote ".."
one
"two"
..== "\"one\\n\\\"two\\\"\""
compile [quote %s] to (Lua value "repr(\(%s as lua expr))") compile [quote %s] to (Lua value "repr(\(%s as lua expr))")
test: test:
assume ((type of {}) == "table") or barf "type of failed." assume ((type of {}) == "table") or barf "type of failed."
@ -284,9 +288,7 @@ compile [type of %obj] to (Lua value "type(\(%obj as lua expr))")
test: test:
assume ((parse "foo %") == \(foo %)) assume ((parse "foo %") == \(foo %))
compile [parse %text] to (..) compile [parse %text] to (Lua value "nomsu:parse(\(%text as lua expr))")
Lua value "nomsu:parse(\(%text as lua expr))"
compile [parse %text from %filename] to (..) compile [parse %text from %filename] to (..)
Lua value ".." Lua value ".."
nomsu:parse(NomsuCode(Source(\(%filename as lua expr), 1, #\(%text as lua expr)), \(..) nomsu:parse(NomsuCode(Source(\(%filename as lua expr), 1, #\(%text as lua expr)), \(..)
@ -296,7 +298,8 @@ compile [parse %text from %filename] to (..)
test: test:
assume ((run "return (2 + 99)") == 101) assume ((run "return (2 + 99)") == 101)
external %passed = (no) external %passed = (no)
run \: external %passed = (yes) run \:
external %passed = (yes)
assume %passed assume %passed
compile [run %nomsu_code] to (..) compile [run %nomsu_code] to (..)
@ -312,14 +315,12 @@ action [run tree %tree, %tree as value] (lua> "return nomsu:run(\%tree)")
compile [compile %block, compiled %block, %block compiled] to (..) compile [compile %block, compiled %block, %block compiled] to (..)
Lua value "nomsu:compile(\(%block as lua))" Lua value "nomsu:compile(\(%block as lua))"
# Return statement is wrapped in a do..end block because Lua is unhappy if you # 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. put code after a return statement, unless you wrap it in a block.
compile [return] to (Lua "do return; end") compile [return] to (Lua "do return; end")
compile [return %return_value] to (..) compile [return %return_value] to (..)
Lua "do return \(%return_value as lua expr) end" Lua "do return \(%return_value as lua expr) end"
# Literals # Literals
compile [yes] to (Lua value "true") compile [yes] to (Lua value "true")
compile [no] to (Lua value "false") compile [no] to (Lua value "false")

12
core/operators.nom
View File

@ -16,7 +16,6 @@ compile [%a is %b, %a == %b] to (..)
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 value "(\(%a as lua expr) ~= \(%b as lua expr))" Lua value "(\(%a as lua expr) ~= \(%b as lua expr))"
# For strict identity checking, use (%x's id) is (%y's id) # For strict identity checking, use (%x's id) is (%y's id)
lua> ".." lua> ".."
do do
@ -59,12 +58,10 @@ compile [%var = %value] to:
end end
return lua return lua
# Simultaneous mutli-assignments like: x,y,z = 1,x,3; # Simultaneous mutli-assignments like: x,y,z = 1,x,3;
compile [set %assignments] to: compile [set %assignments] to:
assume (%assignments.type is "Dict") or barf ".." assume (%assignments.type is "Dict") or barf ".."
Expected a Dict for the assignments part of '<- %' statement, not \%assignments Expected a Dict for the assignments part of '<- %' statement, not \%assignments
lua> ".." lua> ".."
local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source) local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source)
for i, item in ipairs(\%assignments) do for i, item in ipairs(\%assignments) do
@ -107,7 +104,6 @@ compile [with external %externs %body] to:
%body_lua = (%body as lua statements) %body_lua = (%body as lua statements)
lua> ".." lua> ".."
\%body_lua:remove_free_vars(table.map(\%externs, function(v) return tostring(nomsu:compile(v)) end)) \%body_lua:remove_free_vars(table.map(\%externs, function(v) return tostring(nomsu:compile(v)) end))
return %body_lua return %body_lua
compile [with %assignments %body] to: compile [with %assignments %body] to:
@ -144,12 +140,10 @@ compile [with %assignments %body] to:
\%lua \%lua
end -- 'with' block end -- 'with' block
# Math Operators # Math Operators
compile [%x wrapped around %y, %x mod %y] to (..) compile [%x wrapped around %y, %x mod %y] to (..)
Lua value "(\(%x as lua expr) % \(%y as lua expr))" Lua value "(\(%x as lua expr) % \(%y as lua expr))"
# 3-part chained comparisons # 3-part chained comparisons
# (uses a lambda to avoid re-evaluating middle value, while still being an expression) # (uses a lambda to avoid re-evaluating middle value, while still being an expression)
parse [%x < %y < %z] as (..) parse [%x < %y < %z] as (..)
@ -176,7 +170,6 @@ parse [%x > %y >= %z] as (..)
parse [%x >= %y >= %z] as (..) parse [%x >= %y >= %z] as (..)
=lua "(function(x,y,z) return x >= y and y >= z; end)(\%x,\%y,\%z)" =lua "(function(x,y,z) return x >= y and y >= z; end)(\%x,\%y,\%z)"
# TODO: optimize for common case where x,y,z are all either variables or number literals # TODO: optimize for common case where x,y,z are all either variables or number literals
# Boolean Operators # Boolean Operators
compile [%x and %y] to (Lua value "(\(%x as lua expr) and \(%y as lua expr))") compile [%x and %y] to (Lua value "(\(%x as lua expr) and \(%y as lua expr))")
@ -201,7 +194,6 @@ compile [%x RSHIFT %shift, %x >>> %shift] to (..)
compile [%x ARSHIFT %shift, %x >> %shift] to (..) compile [%x ARSHIFT %shift, %x >> %shift] to (..)
Lua value "(\(%x as lua expr) >> \(%shift as lua expr))" Lua value "(\(%x as lua expr) >> \(%shift as lua expr))"
# TODO: implement OR, XOR, AND for multiple operands? # TODO: implement OR, XOR, AND for multiple operands?
# Unary operators # Unary operators
compile [- %] to (Lua value "(- \(% as lua expr))") compile [- %] to (Lua value "(- \(% as lua expr))")
@ -209,7 +201,9 @@ compile [not %] to (Lua value "(not \(% as lua expr))")
test: test:
assume ((length of [1, 2, 3]) == 3) assume ((length of [1, 2, 3]) == 3)
compile [length of %list, len %list, || %list ||] to (Lua value "(#\(%list as lua expr))") compile [length of %list, len %list, || %list ||] to (..)
Lua value "(#\(%list as lua expr))"
compile [%list is empty] to (Lua value "(#\(%list as lua expr) == 0)") compile [%list is empty] to (Lua value "(#\(%list as lua expr) == 0)")
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
core/scopes.nom
View File

@ -20,10 +20,8 @@ compile [with local %locals %body, with local %locals do %body] to:
"List": "List":
declare locals ("\(% as lua)" for % in %locals) in %body_lua declare locals ("\(% as lua)" for % in %locals) in %body_lua
"Var" "Action": "Var" "Action":
declare locals ["\(%locals as lua)"] in %body_lua declare locals ["\(%locals as lua)"] in %body_lua
else: else:
compile error at %locals.source "Unexpected locals: %s" compile error at %locals.source "Unexpected locals: %s"

4
core/text.nom
View File

@ -54,9 +54,7 @@ compile [%text matches %pattern] to (..)
(\(%text as lua expr):match(\(%pattern as lua expr)) and true or false) (\(%text as lua expr):match(\(%pattern as lua expr)) and true or false)
compile [%text matching %pattern] to (..) compile [%text matching %pattern] to (..)
Lua value ".." Lua value "\(%text as lua expr):match(\(%pattern as lua expr))"
\(%text as lua expr):match(\(%pattern as lua expr))
# Text literals # Text literals
lua> ".." lua> ".."

18
examples/how_do_i.nom
View File

@ -41,7 +41,6 @@ say %one_two
The text will continue until the indentation ends, skipping trailing newlines. The text will continue until the indentation ends, skipping trailing newlines.
# How do I put values inside text? (AKA string formatting, string interpolation) # How do I put values inside text? (AKA string formatting, string interpolation)
say ".." say ".."
Text can contain a backslash followed by a variable, list, dict, or parenthesized Text can contain a backslash followed by a variable, list, dict, or parenthesized
@ -100,52 +99,41 @@ if (1 > 10):
..else: ..else:
say "this will print" say "this will print"
# There's no "elseif", so for longer conditionals, a "when" branch is the best option # There's no "elseif", so for longer conditionals, a "when" branch is the best option
if: if:
(3 > 6) (3 > 5) (3 > 4): (3 > 6) (3 > 5) (3 > 4):
say "this won't print" say "this won't print"
(3 > 3): (3 > 3):
say "this won't print" say "this won't print"
(3 > 2): (3 > 2):
say "this will print" say "this will print"
else: else:
say "this is the default case" say "this is the default case"
# How do I do a switch statement? # How do I do a switch statement?
if 3 is: if 3 is:
0 1 2: 0 1 2:
say "this won't print" say "this won't print"
3: 3:
say "this will print" say "this will print"
else: else:
say "this won't print" say "this won't print"
# How do I loop over a list (a foreach loop)? # How do I loop over a list (a foreach loop)?
%list = [1, 2, 3] %list = [1, 2, 3]
for %x in %list: for %x in %list:
say "For %x loop #\%x" say "For %x loop #\%x"
# How do I loop over a number range? # How do I loop over a number range?
# This is inclusive, so it will loop over 1,2, and 3 # This is inclusive, so it will loop over 1,2, and 3
for %i in 1 to 3: for %i in 1 to 3:
say "For %i in 1 to 3 loop #\%i" say "For %i in 1 to 3 loop #\%i"
# This will print 0,2, and 4 # This will print 0,2, and 4
for %even in 0 to 5 by 2: say "Even #\%even" for %even in 0 to 5 by 2: say "Even #\%even"
for %backwards in 3 to 1 by -1: for %backwards in 3 to 1 by -1:
say "Backwards #\%backwards" say "Backwards #\%backwards"
# How do I do a 'while' loop? # How do I do a 'while' loop?
%x = 1 %x = 1
repeat while (%x <= 3): repeat while (%x <= 3):
@ -157,7 +145,6 @@ repeat until (%x > 3):
say "repeat until loop #\%x" say "repeat until loop #\%x"
%x += 1 %x += 1
# How do I do an infinite loop? # How do I do an infinite loop?
%x = 1 %x = 1
repeat: repeat:
@ -165,7 +152,6 @@ repeat:
%x += 1 %x += 1
if (%x > 3): stop repeating if (%x > 3): stop repeating
# How do I do a 'goto'? # How do I do a 'goto'?
do: do:
%x = 1 %x = 1
@ -175,7 +161,6 @@ do:
if (%x <= 3): go to %again if (%x <= 3): go to %again
say "finished going to" say "finished going to"
# How do I define a function/method/procedure? # How do I define a function/method/procedure?
# In nomsu, they're called "action"s, and they can be declared like this: # In nomsu, they're called "action"s, and they can be declared like this:
action [say both %first and also %second]: action [say both %first and also %second]:
@ -184,7 +169,6 @@ action [say both %first and also %second]:
# Function arguments are accessed just like variables # Function arguments are accessed just like variables
say %second say %second
# Actions can use "return" to return a value early # Actions can use "return" to return a value early
action [first fibonacci above %n]: action [first fibonacci above %n]:
%f1 = 0 %f1 = 0
@ -277,7 +261,6 @@ compile [if %condition on opposite day %body] to (..)
\(%body as lua statements) \(%body as lua statements)
end end
# Constants can be defined as macros # Constants can be defined as macros
parse [TWENTY] as 20 parse [TWENTY] as 20
@ -297,7 +280,6 @@ if (1 > (TWENTY)) on opposite day:
say "Lua compiling macros work!" say "Lua compiling 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!"
# How do I use an action as a value? # How do I use an action as a value?
# Well... it's always *possible* to fall back to Lua behavior for something like this: # Well... it's always *possible* to fall back to Lua behavior for something like this:
action [best of %items according to %key_fn]: action [best of %items according to %key_fn]:

1
lib/object.nom
View File

@ -11,7 +11,6 @@ compile [method %actions %body] to:
declare locals in %lua declare locals in %lua
for % in %actions: for % in %actions:
to %lua write "\nclass.\(% as lua id) = \(% as lua id)" to %lua write "\nclass.\(% as lua id) = \(% as lua id)"
return (..) return (..)
Lua ".." Lua ".."
do -- Method: \(%actions.(1).stub) do -- Method: \(%actions.(1).stub)

1
lib/training_wheels.nom
View File

@ -38,7 +38,6 @@ compile [function %args %body, lambda %args %body] to:
lua> "\%body:convert_to_statements('return ');" lua> "\%body:convert_to_statements('return ');"
for % in %args.value: for % in %args.value:
lua> "\%body:remove_free_vars(\%);" lua> "\%body:remove_free_vars(\%);"
to %lua write %body to %lua write %body
to %lua write "\nend)" to %lua write "\nend)"
return %lua return %lua

4
tests/control_flow.nom
View File

@ -9,10 +9,8 @@ action [test conditionals]:
if (yes): %loc1 = (yes) if (yes): %loc1 = (yes)
if (no): if (no):
barf "entered if 'no' conditional" barf "entered if 'no' conditional"
unless (yes): unless (yes):
barf "entered unless 'yes' conditional" barf "entered unless 'yes' conditional"
if (yes): %loc2 = (yes) if (yes): %loc2 = (yes)
..else: ..else:
barf "entered if 'yes' else conditional" barf "entered if 'yes' else conditional"
@ -125,7 +123,6 @@ if:
(no): barf "'when' fail" (no): barf "'when' fail"
(no) (3 > 4): (no) (3 > 4):
barf "'when' fail 2" barf "'when' fail 2"
(yes) (barfer): do nothing (yes) (barfer): do nothing
(99 > 1): (99 > 1):
barf "Fell through incorrectly" barf "Fell through incorrectly"
@ -146,7 +143,6 @@ assume (not %leaked) or barf "'when' is leaking locals"
if 4 is: if 4 is:
1 2: 1 2:
barf "'when = ?' fail" barf "'when = ?' fail"
3 4 (barfer): 3 4 (barfer):
%when_worked = (yes) %when_worked = (yes)

1
tests/metaprogramming.nom
View File

@ -60,7 +60,6 @@ swap %tmp and %tmp2
assume ((%tmp == 2) and (%tmp2 == 1)) or barf ".." assume ((%tmp == 2) and (%tmp2 == 1)) or barf ".."
'parse % as %' variable mangling failed. 'parse % as %' variable mangling failed.
# #
remove action (foo %) remove action (foo %)
try: foo 99 try: foo 99

8
tools/parse.nom
View File

@ -1,6 +1,7 @@
#!/usr/bin/env nomsu -V2.4.4.3 #!/usr/bin/env nomsu -V2.5.4.3
use "core" use "core"
use "lib/os.nom" use "lib/os.nom"
action [print tree %t at indent %indent]: action [print tree %t at indent %indent]:
if %t.type is: if %t.type is:
"Action": "Action":
@ -8,12 +9,13 @@ action [print tree %t at indent %indent]:
for %arg in %t: for %arg in %t:
if (%arg is syntax tree): if (%arg is syntax tree):
print tree %arg at indent "\%indent " print tree %arg at indent "\%indent "
"Number": "Number":
say "\(%indent)\(%t.1)" say "\%indent\(%t.1)"
"Var": "Var":
say "\(%indent)%\(%t.1)" say "\(%indent)%\(%t.1)"
else: else:
say "\(%indent)\(%t.type):" say "\%indent\(%t.type):"
for %arg in %t: for %arg in %t:
if: if:
(%arg is syntax tree): (%arg is syntax tree):

5
tools/test.nom
View File

@ -17,6 +17,7 @@ for %path in (command line args):
for %src = %test in %tests: for %src = %test in %tests:
if (%src.filename == %filename): if (%src.filename == %filename):
add {test:%test, source:%src} to %file_tests add {test:%test, source:%src} to %file_tests
unless (%file_tests is empty): unless (%file_tests is empty):
sort %file_tests by % -> %.source sort %file_tests by % -> %.source
lua> "io.write('[ .. ] ', \%filename); io.flush()" lua> "io.write('[ .. ] ', \%filename); io.flush()"
@ -25,7 +26,7 @@ for %path in (command line args):
if %verbose: if %verbose:
say " \(yellow (%.test with "\n" replaced by "\n "))" say " \(yellow (%.test with "\n" replaced by "\n "))"
run %.test run %.test
if %verbose:
say (green "PASS") if %verbose: say (green "PASS")
..else: ..else:
say "\r[\(green "PASS")" say "\r[\(green "PASS")"