diff options
Diffstat (limited to 'tutorial.nom')
| -rw-r--r-- | tutorial.nom | 211 |
1 files changed, 0 insertions, 211 deletions
diff --git a/tutorial.nom b/tutorial.nom deleted file mode 100644 index 1b25f69..0000000 --- a/tutorial.nom +++ /dev/null @@ -1,211 +0,0 @@ -(# Comments use (# ... #), and can be nested #) - -(# Import files like so: #) -run file "core.nom" - -(# Numbers: #) -23 -4.5 -(# Since this language cross-compiles to lua, integers and floating point numbers are - both represented using the same primitive. #) - -(# Strings: #) -"asdf" -".." - |This is a multi-line string - |that starts with ".." and includes each indented line that starts with a "|" - |until the indentation ends - -(# Lists: #) -[1,2,3] -[..] - "like multi-line strings, lists have an indented form", "that can use commas too" - "or just newlines to separate items" - 5 - 6,7,8 - -(# Function calls: #) -say "Hello world!" - -(# Function definition: #) -rule "say both %first and also %second": - (# Variables use the "%" sign: #) - say %first - say %second - -(# Function calls can have parts of the function's name spread throughout. - Everything that's not a literal value is treated as part of the function's name #) -say both "Hello" and also "again!" - -(# Functions can even have their name at the end: #) -rule "%what-she-said is what she said": - say %what-she-said - say "-- she said" -"Howdy pardner" is what she said - -(# The language only reserves []{}().,:;% as special characters, so functions and variables - can have really funky names! #) -rule ">> %foo-bar###^ --> %@@& _~-^-~_~-^ %1 !": - say %foo-bar###^ - say %@@& - say %1 ->> "wow" --> "so flexible!" _~-^-~_~-^ "even numbers can be variables!" ! -(# Though literals can't be used in function names #) - -(# Math and logic operations are just treated the same as function calls in the syntax #) -say (2 + 3) -(# So it's easy to define your own operators #) -rule "%a ++ %b": 2 * (%a + %b) -say (2 ++ 3) - - -(# Code blocks start with ":" and either continue until the end of the line - or are indented blocks #) - -(# One liner: #) -: say "hi" - -(# Block version: #) -: - say "one" - say "two" - -(# So the function definitions above are actually just passing a regular string, like - "say both %first and also %second", and a code block to a function called "rule % %" - that takes two arguments. #) - -(# Line continuations work by either ending a line with ".." and continuing with an indented block: #) -say.. - both "Tom" and - also - "Sawyer" - -(# Or by starting the next line with ".." #) -say both "Bruce" -..and also "Lee" - -(# This can be mixed and matched: #) -say both.. - "Rick" -..and also.. - "Moranis" - -(# And combined with the block forms of literals: #) -say both ".." - |Four score and seven years ago our fathers brought forth, upon this continent, - |a new nation, conceived in liberty, and dedicated to the proposition that - |"all men are created equal" -..and also.. - "-- Abraham Lincoln" - -rule "my favorite number": return 23 -(# Subexpressions are wrapped in parentheses: #) -(# printf takes a list of bits that are converted to strings and concatenated together, and printed #) -printf ["My favorite number is ", my favorite number] -(# There's a multi-line indented block form for subexpressions too: #) -printf [..] - "My favorite number is still ", (..) - my favorite - number - -(# There's a few macros in the language for things like conditional branches and logic/math - operations, but they can be thought of as basically the same as functions. - There are no keywords in the language! #) -if (1 < 10): - say "One is less than ten" -..else: - say "One is not less than ten" - -(# Breakdown of the above: #) -(# Function call (actually a macro) to "if % % else %" #) -(# First argument is a subexpression that is a function call (also a macro) to "% < %" - that performs a comparison on its arguments, 1 and 10 #) -(# Second argument is a block of code that includes a function call to "say %", the "if" body #) -(# Third argument is a block of code that includes a different function call to "say %", the "else" body #) - -(# Line continuations can be used for "elseif" #) -if (1 > 10): - say "First condition" -..else: if (1 > 5): - say "Second condition" -..else: - say "Last condition" - -(# ^that's the same as: #) -if (1 > 10): - say "First condition" -..else: - if (1 > 5): - say "Second condition" - ..else: - say "Last condition" - -(# Variables are modified with a macro, "let % = %" #) -let "numbers" = [5,6,7] - -(# Looping: #) -printf ["Looping over: ",%numbers,"!"] -for "number" in %numbers: - say (%number + 100) - -rule "sing %starting-bottles bottles of beer": - for "n" in (%starting-bottles down through 0): - printf [..] - (%n if (%n > 0) else "No more") - (" bottle" if (%n == 1) else " bottles") - " of beer on the wall." - ("" if (%n == 0) else " Take one down, pass it around...") - -sing 9 bottles of beer - - -(# Note that because math and logic operations are just macros, they require a lot - of parentheses to disambiguate. There's no PEMDAS. #) -say (5 + (4 * (- (1 + (6 + 2))))) -(# For convenience, +,*,"and", and "or" have been hand defined to work with up to 4 operands: #) -1 + 2 + 3 + 4 -1 * 2 * 3 * 4 -1 and 2 and 3 and 4 -1 or 2 or 3 or 4 -(# Longer lists can use "sum of %", "product of %", "all of %", and "any of %", respectively, or lots of parentheses. #) -sum of [1,2,3,4,5,6,7] -product of [1,2,3,4,5,6,7] -all of [1,1,1,1,0,1,1] -any of [0,0,0,0,1,0,0] -(# And 3-operand chained inequality comparisons have been defined: #) -1 < 2 <= 3 - - -(# Macros: #) -(# The "lua block %" and "lua expr %" macros can be used to write raw lua code: #) -rule "say time": - lua block ".." - |io.write("The OS time is: ") - |io.write(tostring(os.time()).."\n") -say time -printf ["Math expression: ", lua expr "(1 + 2*3 + 3*4)^2"] -(# In the lua environment, "vars" can be used to get local variables/function args, and "game" - can be used to access the compiler, function defs, and other things #) -rule "square root of %n": - return (lua expr "math.sqrt(vars.n)") -printf ["the square root of 2 is ", square root of 2] - -(# Macros can be defined as functions that take unprocessed syntax trees and return lua code #) -(# "macro block %" is for defining macros that produce blocks of code, not values #) -macro block "unless %condition %body": - concat [..] - (# "% as lua expr" and "% as lua block" are two useful helper functions here. #) - "if not (", %condition as lua expr, ") then" - (# Extract the inner part of the code block's body and insert it: #) - "\n ", (lua expr "vars.body.value.value") as lua block - "\nend" - -unless (1 > 10): - say "Macros work!" - say "It looks like a keyword, but there's no magic here!" - -(# and "macro %" is for defining macros that produce an expression #) -macro "%value as a boolean": - concat ["(not not (", %value as lua expr, "))"] -macro "yep": "true" - |