From d52044e9130ad3d947a7a9378b6b191b98a2db5f Mon Sep 17 00:00:00 2001 From: Bruce Hill Date: Mon, 2 Oct 2017 19:24:47 -0700 Subject: [PATCH] Removed tutorial (redundant with examples/how_do_i.nom) --- examples/tutorial.nom | 280 ------------------------------------------ 1 file changed, 280 deletions(-) delete mode 100644 examples/tutorial.nom diff --git a/examples/tutorial.nom b/examples/tutorial.nom deleted file mode 100644 index 3608be2..0000000 --- a/examples/tutorial.nom +++ /dev/null @@ -1,280 +0,0 @@ -# One liner comments start with # and go till end of line -#.. Multi-line comments start with #.. and - continue until dedent - -# Import files like so: -require "lib/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 - -# Dictionaries (AKA hash maps): -dict [["x", 99], ["y", 101]] -dict [..] - ["z", 222] - [383, "howdy"] - -# Function calls: -say "Hello world!" - -# Variables use the % sign: -%str =: "Hello again" -say %str - -# There are +=:, -=:, *=:, /=:, ^=:, and=:, or=:, and mod=: operators for updating variables -%x =: 1 -%x +=: 100 -say %x - -# Conditionals look like this: -if (1 < 10): - say "1 is indeed < 10" - -if (1 > 10): - say "this won't print" -..else: - say "this will print" - -# For longer conditionals, a "when" branch is the best option -when: - * (1 > 4) - * (1 > 3): - say "this won't print" - * (1 > 2): - say "this won't print" - * else: - say "this will print" - -# When "when" is given an argument, it works like a switch statement -when 3 == ?: - * 1 - * 2: - say "this won't print" - * 3: - say "this will print" - * else: - say "this won't print" - -# Loops look like this: -for %x in [1,2,3]: - say ".."|for loop over list #\%x\ - -# If you want to iterate over a numeric range, you can use some built in functions like this: -for %x in (1 through 3): - say ".."|for loop over number range #\%x\ - -# While loops: -%x =: 1 -repeat while (%x <= 3): - say ".."|repeat while loop #\%x\ - %x +=: 1 - -%x =: 1 -repeat until (%x > 3): - say ".."|repeat until loop #\%x\ - %x +=: 1 - -# Infinite loop: -%x =: 1 -repeat: - say ".."|repeat loop #\%x\ - %x +=: 1 - if (%x > 3): - break - -# GOTOs: -do: - %x =: 1 - -> %again - say ".."|go to loop #\%x\ - %x +=: 1 - if (%x <= 3): - go to %again - say "finished going to" - - -# Function definition: -rule [say both %first and also %second] =: - say %first - # Function arguments are accessed just like variables - say %second - -# The last line of a function is the return value -rule [add %x and %y] =: - %result =: %x + %y - %result - -# Functions can use "return" to return a value early -rule [first fibonacci above %n] =: - %f1 =: 0 - %f2 =: 1 - repeat: - %tmp =: %f1 + %f2 - %f1 =: %f2 - %f2 =: %tmp - if (%f2 > %n): - return: %f2 - -say (first fibonacci above 10) - -# Functions can have aliases, which may or may not have the arguments in different order -rule [..] - I hate %worse-things more than %better-things - I think %worse-things are worse than %better-things - I like %better-things more than %worse-things -..=: - say ".."|\%better-things capitalized\ rule and \%worse-things\ drool! - -I like "dogs" more than "cats" -I think "chihuahuas" are worse than "corgis" - - -#.. 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!" ! - -# 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 starting the next line with ".." -say both "Bruce" -..and also "Lee" - -# This can be 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] =: 21 + 2 - -# Subexpressions are wrapped in parentheses: -say (my favorite number) -# There's a multi-line indented block form for subexpressions too: -say (..) - my favorite - ..number - -# Block strings can interpolate values by enclosing an expression in a pair of \s -say ".."|My favorite number is \my favorite number\! - -say ".." - |My favorite number is still \(..) - my favorite - ..number - ..\, but this time it uses an indented subexpression! - -rule [sing %starting-bottles bottles of beer] =: - for %n in (%starting-bottles down through 0): - say ".." - |\%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 -say "Done with math." -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 - -say "Done with math." - - -# Macros: -# The "lua block %" and "lua expr %" macros can be used to write raw lua code: -rule [say the time] =: - lua block ".." - |io.write("The OS time is: ") - |io.write(tostring(os.time()).."\\n") -say the time -say ".."|Math expression result is: \lua expr "(1 + 2*3 + 3*4)^2"\ - -#.. In the lua environment, "vars" can be used to get local variables/function args, and - "nomsu" can be used to access the compiler, function defs, and other things -rule [square root of %n] =: - lua expr "math.sqrt(vars.n)" -say ".."|The square root of 2 is \square root of 2\ - -# Macros can be defined as functions that take unprocessed syntax trees and return lua code -# "macro block %" is for defining macros that produce blocks of code, not values -macro block [unless %condition %body] =: ".." - |if not (\%condition as lua\) then - | \(lua expr "vars.body.value") as lua\ - |end - -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] =: ".." - |(not not (\%value as lua\)) -macro [yep] =: "true" -