From 376dd652786b39c8b599cef4789ae8763ed92ae5 Mon Sep 17 00:00:00 2001 From: Bruce Hill Date: Fri, 19 Jan 2018 18:13:02 -0800 Subject: [PATCH] Updated and fixed up how_do_i --- examples/how_do_i.nom | 174 ++++++++++++++++++++-------------------- lib/control_flow.nom | 2 +- lib/metaprogramming.nom | 2 +- 3 files changed, 88 insertions(+), 90 deletions(-) diff --git a/examples/how_do_i.nom b/examples/how_do_i.nom index 4e1a18d..28b70f9 100644 --- a/examples/how_do_i.nom +++ b/examples/how_do_i.nom @@ -8,182 +8,181 @@ indented area. # How do I import files? -require "lib/core.nom" +use "lib/core.nom" # Declare a variable? -%x = 1 -%str = "Hello world" +local %x +# Otherwise, variables are implicitly global (hah, sorry, I know that sucks) + +# Set a variable? +set %x = 1 +set %str = "Hello world" # Expressions that are more than just literal values require parentheses: -%x = (2 + 3) +set %x = (2 + 3) # Modify a variable? -%x = 100 +set %x = 100 %x += 1 # Print stuff? say "Hello world!" # Define a mutli-line string? -%mutli_str = ".." +set %mutli_str = ".." Start with "..", then put lines below it that are indented one level. The string will continue until the indentation ends. # Format a string? -%format_str = ".." +set %format_str = ".." Strings can contain a backslash followed by a variable, list, dict, or parenthesized expression. This escaped value will be converted to a readable string, like so: The value of %x is \%x, isn't that nice? The sum of 2 and 4 is \(2 + 4). If you need to use a plain ol' backslash, you can do \\ <-- that -%format_str2 = "Single-line strings can contain escape sequences like \", \\, \n, \065, and \x0A" +set %format_str2 = "Single-line strings can contain escape sequences like \", \\, \n, \065, and \x0A" # Define a list? -%my_list = [1,2,"hello"] +set %my_list = [1,2,"hello"] #.. Really long lists can use [..] followed by a bunch of indented values delimited by commas and/or newlines -%my_really_long_list = [..] +set %my_really_long_list = [..] 1,2,3,4 5,6 7 8,9,10 # Use a list? -%my_list = ["first item", "second item", "third item"] +set %my_list = ["first item", "second item", "third item"] # Lists are 1-indexed because they're implemented as Lua tables, so this prints "first item" say (%my_list->1) # These do the same thing: say (%my_list's 1) say (1 in %my_list) # List entries can be modified like this: -%my_list -> 1 = "ONE!!!" +set (%my_list -> 1) = "ONE!!!" say (size of %my_list) # Define a dictionary/hash map? -%my_dict = {x = 99, y = 101} -%my_dict = {..} - x = 101, y = 2 - "99 bottles" = 99 - 653 = 292 +set %my_dict = {x: 99, y: 101} +set %my_dict = {..} + x: 101, y: 2 + "99 bottles": 99 + 653: 292 # Use a dict? # Dicts are also implemented as Lua tables, so they're accessed and modified the same way as lists say (%my_dict->"x") -%my_dict->"x" = 9999 +set (%my_dict->"x") = 9999 # Do conditional branching? -if (1 < 10): +if: 1 < 10 say "1 is indeed < 10" -if (1 > 10): +if: 1 > 10 say "this won't print" -..else: +..else say "this will print" # There's no "elseif", so for longer conditionals, a "when" branch is the best option -when: +when * (3 > 6) * (3 > 5) - * (3 > 4): + * (3 > 4) say "this won't print" - * (3 > 3): + * (3 > 3) say "this won't print" - * (3 > 2): + * (3 > 2) say "this will print" - * else: + * else say "this is the default case" # Do a switch statement? -when 3 == ?: +when 3 = ? * 0 * 1 - * 2: + * 2 say "this won't print" - * 3: + * 3 say "this will print" - * else: + * else say "this won't print" # Loop over a list (a foreach loop)? -%list = [1,2,3] -for %x in %list: +set %list = [1,2,3] +for %x in %list say "For %x loop #\%x" # There's also a slightly more concise version that automatically populates a loop variable "%" -for all %list: +for all %list say "For all loop #\%" # Loop over a number range? # This is inclusive, so it will loop over 1,2, and 3 -for %i from 1 to 3: +for %i from 1 to 3 say "For %i from 1 to 3 loop #\%i" -for all 1 to 3: +for all 1 to 3 say "For all 1 to 3 loop #\%" # This will print 0,2, and 4 -for %even from 0 to 5 by 2: +for %even from 0 to 5 by 2 say "Even #\%even" -for %backwards from 3 to 1 by -1: +for %backwards from 3 to 1 by -1 say "Backwards #\%backwards" # While loops: -%x = 1 -repeat while (%x <= 3): +set %x = 1 +repeat while: %x <= 3 say "repeat while loop #\%x" %x += 1 -%x = 1 -repeat until (%x > 3): +set %x = 1 +repeat until: %x > 3 say "repeat until loop #\%x" %x += 1 # Infinite loop: -%x = 1 -repeat: +set %x = 1 +repeat say "repeat loop #\%x" %x += 1 - if (%x > 3): + if: %x > 3 stop repeat-loop # GOTOs: -do: - %x = 1 +do + set %x = 1 -> %again say "GOTO loop #\%x" %x += 1 - if (%x <= 3): + if: %x <= 3 go to %again say "finished going to" # Function definition: -rule [say both %first and also %second] =: +action [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): +action [first fibonacci above %n] + set %f1 = 0 + set %f2 = 1 + repeat + set %tmp = (%f1 + %f2) + set %f1 = %f2 + set %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 [..] +action [..] 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" @@ -195,7 +194,7 @@ I think "chihuahuas" are worse than "corgis" say both "Hello" and also "again!" # Functions can even have their name at the end: -rule [%what_she_said is what she said] =: +action [%what_she_said is what she said] say %what_she_said say "-- she said" @@ -203,7 +202,7 @@ rule [%what_she_said is what she said] =: #.. The language only reserves []{}().,:;% as special characters, so functions can have really funky names! -rule [>> %foo_bar $$$^ --> % @& _~-^-~_~-^ %1 !] =: +action [>> %foo_bar $$$^ --> % @& _~-^-~_~-^ %1 !] say %foo_bar say % say %1 @@ -213,31 +212,30 @@ rule [>> %foo_bar $$$^ --> % @& _~-^-~_~-^ %1 !] =: # 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] =: +action [%a ++ %b] 2 * (%a + %b) #.. The following are characters won't "stick" to their neighbors, so the compiler treats them as solitary single-character tokens: '~`!@$^&*-+=|<>?/ which means you can jam things together: -(5++2) == ( 5 ++ 2 ) -(5 ++ 2) == (5 + + 2) +assume: (5++2) is ( 5 ++ 2 ) # Do grouping? # Expressions can be grouped by enclosing parentheses: say (2 + 3) -# Or by a (..) followed by an indented region -say (..) +# Or by an indented region +say 2 + 3 # If you need to keep going after an indented region, you can start the next line with ".." -say both (..) +say both "Very long first argument that needs its own line" ..and also "short second arg" -rule [my favorite number] =: 21 + 2 +action [my favorite number]: 21 + 2 # This can be nested: -say both (..) +say both my favorite ..number ..and also "foo" @@ -245,33 +243,33 @@ say both (..) # Macros: # The "lua> %" and "=lua %" macros can be used to write raw lua code: -rule [say the time] =: +action [say the time] lua> ".." nomsu:writeln("The OS time is: "..os.time()); say the time say "Math expression result is: \(=lua "(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 "math.sqrt(vars.n)" +# Variables can be accessed via \%varname +action [square root of %n] + =lua "math.sqrt(\%n)" say "The square root of 2 is \(square root of 2)" -# Macros can be defined to transform one bit of nomsu code into another using "parse % as %": -parse [if %condition is untrue %body] as: - if (not %condition): %body +immediately + # Macros can be defined to transform one bit of nomsu code into another using "parse % as %": + parse [if %condition is untrue %body] as + if (not %condition) %body -# Or to transform nomsu code into custom lua code using "compile % to code %" -compile [if %condition on opposite day %body] to code: ".." - if not (\(%condition as lua)) then - \(%body as lua statements) - end + # Or to transform nomsu code into custom lua code using "compile % to code %" + compile [if %condition on opposite day %body] to code ".." + if not (\(%condition as lua)) then + \(%body as lua statements) + end -if (1 > 10) is untrue: +if (1 > 10) is untrue say "Nomsu parsing macros work!" say "It looks like a keyword, but there's no magic here!" -if (1 > 10) on opposite day: +if (1 > 10) on opposite day say "Lua compiling macros work!" say "It looks like a keyword, but there's no magic here!" diff --git a/lib/control_flow.nom b/lib/control_flow.nom index 269a2a5..b05862c 100644 --- a/lib/control_flow.nom +++ b/lib/control_flow.nom @@ -103,7 +103,7 @@ immediately ::stop_repeat::; end --while-loop label scope return %code - parse [repeat %body] as: repeat while (true) %body + parse [repeat %body] as: repeat while (yes) %body parse [repeat until %condition %body] as: repeat while (not %condition) %body # For loop control flow: diff --git a/lib/metaprogramming.nom b/lib/metaprogramming.nom index f07e2d1..5ff1ab3 100644 --- a/lib/metaprogramming.nom +++ b/lib/metaprogramming.nom @@ -97,7 +97,7 @@ immediately end template = repr(table.concat(template, "\\n")); else - template = repr(\%longhand.src); + template = repr(nomsu:dedent(\%longhand.src)); end local junk, arg_names, junk = nomsu:get_stub(\%shorthand.value[1]); local replacements = {};