Removed utils.lua, simplified some metaprogramming stuff, added native support

for calling functions with (%a %b %c) instead of (call %a with [%b,
%c]), renamed _List -> List, _Dict -> Dict, improved example code.

Makefile

@@ -14,7 +14,7 @@ MOON_FILES= code_obj.moon error_handling.moon files.moon nomsu.moon nomsu_compil
 			syntax_tree.moon containers.moon bitops.moon parser.moon pretty_errors.moon \
 			string2.moon
 LUA_FILES= code_obj.lua consolecolors.lua error_handling.lua files.lua nomsu.lua nomsu_compiler.lua \
-		   syntax_tree.lua containers.lua bitops.lua utils.lua parser.lua pretty_errors.lua \
+		   syntax_tree.lua containers.lua bitops.lua parser.lua pretty_errors.lua \
 		   string2.lua
 CORE_NOM_FILES= $(wildcard core/*.nom)
 CORE_LUA_FILES= $(patsubst %.nom,%.lua,$(CORE_NOM_FILES))

README.md

@@ -52,7 +52,6 @@ All `.moon` files have been precompiled into corresponding `.lua` files, so you
 * [syntax\_tree.moon](syntax_tree.moon) - Datastructures used for Nomsu Abstract Syntax Trees.
 * [code\_obj.moon](code_obj.moon) - Datastructures used for incrementally building generated code, while preserving code origins.
 * [error\_handling.moon](error_handling.moon) - The logic for producing good error messages within Lua that reference the Nomsu source code that led to them.
-* [utils.lua](utils.lua) - A set of utility actions used by nomsu.moon.
 * [consolecolors.lua](consolecolors.lua) - Lua module that defines ANSI color codes for colored console output (used internally in nomsu.moon).
 * [examples/how\_do\_i.nom](examples/how_do_i.nom) - A simple walkthrough of some of the features of Nomsu, written in Nomsu code. **This is a good place to start.**
 * [core/\*.nom](core) - Core language definitions of stuff like control flow, operators, and metaprogramming, broken down into different files.

code_obj.lua

@@ -409,7 +409,7 @@ do
       return {
         nomsu_filename = self.source.filename,
         lua_filename = tostring(self.source) .. ".lua",
-        lua_file = self:stringify(),
+        lua_file = self:text(),
         lua_to_nomsu = lua_to_nomsu,
         nomsu_to_lua = nomsu_to_lua
       }

code_obj.moon

@@ -245,7 +245,7 @@ class LuaCode extends Code
         walk self, 1
         return {
             nomsu_filename:@source.filename
-            lua_filename:tostring(@source)..".lua", lua_file:@stringify!
+            lua_filename:tostring(@source)..".lua", lua_file:@text!
             :lua_to_nomsu, :nomsu_to_lua
         }
 

containers.lua

@@ -1,16 +1,9 @@
+local List, Dict
 local insert, remove, concat
 do
   local _obj_0 = table
   insert, remove, concat = _obj_0.insert, _obj_0.remove, _obj_0.concat
 end
-local equivalent, nth_to_last, size
-do
-  local _obj_0 = require('utils')
-  equivalent, nth_to_last, size = _obj_0.equivalent, _obj_0.nth_to_last, _obj_0.size
-end
-local lpeg = require('lpeg')
-local re = require('re')
-local List, Dict
 local as_nomsu
 as_nomsu = function(self)
   if type(self) == 'number' then
@@ -47,9 +40,23 @@ as_lua = function(self)
   end
   return tostring(self)
 end
+local nth_to_last
+nth_to_last = function(self, n)
+  return self[#self - n + 1]
+end
 local _list_mt = {
   __type = "List",
-  __eq = equivalent,
+  __eq = function(self, other)
+    if not (type(other) == 'table' and getmetatable(other) == getmetatable(self) and #other == #self) then
+      return false
+    end
+    for i, x in ipairs(self) do
+      if not (x == other[i]) then
+        return false
+      end
+    end
+    return true
+  end,
   __tostring = function(self)
     return "[" .. concat((function()
       local _accum_0 = { }
@@ -75,7 +82,7 @@ local _list_mt = {
     end)(), ", ") .. "]"
   end,
   as_lua = function(self)
-    return "_List{" .. concat((function()
+    return "List{" .. concat((function()
       local _accum_0 = { }
       local _len_0 = 1
       for _index_0 = 1, #self do
@@ -242,8 +249,29 @@ walk_items = function(self, i)
 end
 local _dict_mt = {
   __type = "Dict",
-  __eq = equivalent,
+  __eq = function(self, other)
-  __len = size,
+    if not (type(other) == 'table' and getmetatable(other) == getmetatable(self)) then
+      return false
+    end
+    for k, v in pairs(self) do
+      if not (v == other[k]) then
+        return false
+      end
+    end
+    for k, v in pairs(other) do
+      if not (v == self[k]) then
+        return false
+      end
+    end
+    return true
+  end,
+  __len = function(self)
+    local n = 0
+    for _ in pairs(self) do
+      n = n + 1
+    end
+    return n
+  end,
   __tostring = function(self)
     return "{" .. concat((function()
       local _accum_0 = { }
@@ -267,7 +295,7 @@ local _dict_mt = {
     end)(), ", ") .. "}"
   end,
   as_lua = function(self)
-    return "_Dict{" .. concat((function()
+    return "Dict{" .. concat((function()
       local _accum_0 = { }
       local _len_0 = 1
       for k, v in pairs(self) do

containers.moon

@@ -1,11 +1,6 @@
--- This file contains container classes, i.e. Lists, Dicts, and Sets
+-- This file contains container classes, i.e. Lists and Dicts, plus some extended string functionality
-
-{:insert,:remove,:concat} = table
-{:equivalent, :nth_to_last, :size} = require 'utils'
-lpeg = require 'lpeg'
-re = require 're'
-
 local List, Dict
+{:insert,:remove,:concat} = table
 
 as_nomsu = =>
     if type(@) == 'number'
@@ -23,19 +18,26 @@ as_lua = =>
             return _as_lua(@)
     return tostring(@)
 
+nth_to_last = (n)=> @[#@-n+1]
+
 -- List and Dict classes to provide basic equality/tostring functionality for the tables
 -- used in Nomsu. This way, they retain a notion of whether they were originally lists or dicts.
 
 _list_mt =
     __type: "List"
-    __eq:equivalent
+    __eq: (other)=>
+        unless type(other) == 'table' and getmetatable(other) == getmetatable(@) and #other == #@
+            return false
+        for i,x in ipairs(@)
+            return false unless x == other[i]
+        return true
     -- Could consider adding a __newindex to enforce list-ness, but would hurt performance
     __tostring: =>
         "["..concat([as_nomsu(b) for b in *@], ", ").."]"
     as_nomsu: =>
         "["..concat([as_nomsu(b) for b in *@], ", ").."]"
     as_lua: =>
-        "_List{"..concat([as_lua(b) for b in *@], ", ").."}"
+        "List{"..concat([as_lua(b) for b in *@], ", ").."}"
     __lt: (other)=>
         assert type(@) == 'table' and type(other) == 'table', "Incompatible types for comparison"
         for i=1,math.max(#@, #other)
@@ -65,7 +67,6 @@ _list_mt =
         last: (=> @[#@]), first: (=> @[1])
         _1_st_to_last:nth_to_last, _1_nd_to_last:nth_to_last
         _1_rd_to_last:nth_to_last, _1_th_to_last:nth_to_last
-        -- TODO: use stringify() to allow joining misc. objects?
         joined: => table.concat([tostring(x) for x in *@]),
         joined_with: (glue)=> table.concat([tostring(x) for x in *@], glue),
         has: (item)=>
@@ -105,14 +106,24 @@ walk_items = (i)=>
 
 _dict_mt =
     __type: "Dict"
-    __eq:equivalent
+    __eq: (other)=>
-    __len:size
+        unless type(other) == 'table' and getmetatable(other) == getmetatable(@)
+            return false
+        for k,v in pairs(@)
+            return false unless v == other[k]
+        for k,v in pairs(other)
+            return false unless v == @[k]
+        return true
+    __len: =>
+        n = 0
+        for _ in pairs(@) do n += 1
+        return n
     __tostring: =>
         "{"..concat(["#{as_nomsu(k)}: #{as_nomsu(v)}" for k,v in pairs @], ", ").."}"
     as_nomsu: =>
         "{"..concat(["#{as_nomsu(k)}: #{as_nomsu(v)}" for k,v in pairs @], ", ").."}"
     as_lua: =>
-        "_Dict{"..concat(["[ #{as_lua(k)}]= #{as_lua(v)}" for k,v in pairs @], ", ").."}"
+        "Dict{"..concat(["[ #{as_lua(k)}]= #{as_lua(v)}" for k,v in pairs @], ", ").."}"
     __ipairs: => walk_items, {table:@, key:nil}, 0
     __band: (other)=>
         Dict{k,v for k,v in pairs(@) when other[k] != nil}

core/control_flow.nom

@@ -560,7 +560,7 @@ test:
         %lua = (..)
             Lua "\
                 ..do
-                    local \(mangle "stack \(%var.1)") = _List{\(%structure as lua expr)}
+                    local \(mangle "stack \(%var.1)") = List{\(%structure as lua expr)}
                     while #\(mangle "stack \(%var.1)") > 0 do
                         \(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)"
         %lua::append "\n        "

core/math.nom

@@ -76,27 +76,54 @@ test:
 externally (%n to the nearest %rounder) means (..)
     =lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)"
 
-# Any/all/none
+# Any/all
+externally [all of %items, all %items] all mean:
+    for % in %items:
+        unless %: return (no)
+    return (yes)
 [all of %items, all %items] all compile to:
     unless (%items.type is "List"):
-        return (Lua value "utils.all(\(%items as lua expr))")
+        return %tree
     %clauses = (((% as lua expr)::text) for % in %items)
     return (Lua value "(\(%clauses::joined with " and "))")
-
 [not all of %items, not all %items] all parse as (not (all of %items))
+
+externally [any of %items, any %items] all mean:
+    for % in %items:
+        if %: return (yes)
+    return (no)
 [any of %items, any %items] all compile to:
     unless (%items.type is "List"):
-        return (Lua value "utils.any(\(%items as lua expr))")
+        return %tree
     %clauses = (((% as lua expr)::text) for % in %items)
     return (Lua value "(\(%clauses::joined with " or "))")
-
 [none of %items, none %items] all parse as (not (any of %items))
+
+# Sum/product
+externally [sum of %items, sum %items] all mean:
+    %total = 0
+    for % in %items: %total += %
+    return %total
 [sum of %items, sum %items] all compile to:
     unless (%items.type is "List"):
-        return (Lua value "utils.sum(\(%items as lua expr))")
+        return %tree
     %clauses = (((% as lua expr)::text) for % in %items)
     return (Lua value "(\(%clauses::joined with " + "))")
 
+externally [product of %items, product %items] all mean:
+    %prod = 1
+    for % in %items: %prod *= %
+    return %prod
+[product of %items, product %items] all compile to:
+    unless (%items.type is "List"):
+        return %tree
+    %clauses = (((% as lua expr)::text) for % in %items)
+    return (Lua value "(\(%clauses::joined with " * "))")
+
+externally [avg of %items, average of %items] all mean (..)
+    (sum of %items) / (size of %items)
+
+# Shorthand for control flow
 [if all of %items %body, if all of %items then %body] all parse as (..)
     if (all of %items) %body
 
@@ -136,42 +163,44 @@ externally (%n to the nearest %rounder) means (..)
     unless none of %items %body else %else, unless none of %items then %body else %else
 ..all parse as (if (any of %items) %body else %else)
 
-[product of %items, product %items] all compile to:
+# Min/max
-    unless (%items.type is "List"):
+externally [min of %items, smallest of %items, lowest of %items] all mean:
-        return (Lua value "utils.product(\(%items as lua expr))")
+    %best = (nil)
-    %clauses = (((% as lua expr)::text) for % in %items)
+    for % in %items:
-    return (Lua value "(\(%clauses::joined with " * "))")
+        if ((%best == (nil)) or (% < %best)):
+            %best = %
+    return %best
 
-externally [avg of %items, average of %items] all mean (..)
+externally [max of %items, biggest of %items, largest of %items, highest of %items] all mean:
-    =lua "(utils.sum(\%items)/#\%items)"
+    %best = (nil)
-
+    for % in %items:
-[min of %items, smallest of %items, lowest of %items] all compile to (..)
+        if ((%best == (nil)) or (% > %best)):
-    Lua value "utils.min(\(%items as lua expr))"
+            %best = %
-
+    return %best
-[max of %items, biggest of %items, largest of %items, highest of %items] all compile \
-..to (Lua value "utils.max(\(%items as lua expr))")
 
 test:
     assume ((min of [3, -4, 1, 2] by % = (% * %)) == 1)
     assume ((max of [3, -4, 1, 2] by % = (% * %)) == -4)
 (min of %items by %item = %value_expr) parses as (..)
     result of:
-        set {%best:nil, %best_key:nil}
+        %best = (nil)
+        %best_key = (nil)
         for %item in %items:
             %key = %value_expr
             if ((%best == (nil)) or (%key < %best_key)):
-                set {%best:%item, %best_key:%key}
+                %best = %item
-        
+                %best_key = %key
         return %best
 
 (max of %items by %item = %value_expr) parses as (..)
     result of:
-        set {%best:nil, %best_key:nil}
+        %best = (nil)
+        %best_key = (nil)
         for %item in %items:
             %key = %value_expr
             if ((%best == (nil)) or (%key > %best_key)):
-                set {%best:%item, %best_key:%key}
+                %best = %item
-        
+                %best_key = %key
         return %best
 
 # Random functions

core/metaprogramming.nom

@@ -63,29 +63,33 @@ test:
     asdf
     assume (%tmp is (nil)) or barf "compile to is leaking variables"
 lua> "\
-    ..COMPILE_ACTIONS["1 compiles to"] = function(nomsu, tree, \%actions, \%body)
+    ..COMPILE_ACTIONS["1 compiles to"] = function(nomsu, tree, \%action, \%body)
-        if \%actions.type ~= "List" then \%actions = {\%actions, type="List"} end
+        local \%args = List{\(\%nomsu), \(\%tree), unpack(\%action:get_args())}
-        local \%args = {"nomsu", "tree", unpack(table.map(\%actions[1]:get_args(), function(a) return nomsu:compile(a):text() end))}
+        local lua = LuaCode(tree.source, "COMPILE_ACTIONS[", \%action.stub:as_lua(),
-        local lua = LuaCode(tree.source, "COMPILE_ACTIONS[", \%actions[1].stub:as_lua(),
             "] = ", \(what (%args -> %body) compiles to))
+        return lua
+    end"
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+(%actions all compile to %body) compiles to:
+    lua> "\
+        ..if \%actions.type ~= "List" then
+            nomsu:compile_error(\%actions, "This should be a list of actions.")
+        end
+        local lua = LuaCode(tree.source, \(what (%actions.1 compiles to %body) compiles to))
+        local \%args = List{\(\%nomsu), \(\%tree), unpack(\%actions[1]:get_args())}
         for i=2,#\%actions do
             local alias = \%actions[i]
-            local \%alias_args = {"nomsu", "tree", unpack(table.map(alias:get_args(), function(a) return nomsu:compile(a):text() \
+            local \%alias_args = List{\(\%nomsu), \(\%tree), unpack(alias:get_args())}
-    ..end))}
             lua:append("\\nCOMPILE_ACTIONS[", alias.stub:as_lua(), "] = ")
-            if utils.equivalent(\%args, \%alias_args) then
+            if \%alias_args == \%args then
                 lua:append("COMPILE_ACTIONS[", \%actions[1].stub:as_lua(), "]")
             else
-                lua:append("function(")
+                lua:append(\(what (%alias_args -> \(what %actions.1 compiles to)) compiles to))
-                lua:concat_append(\%alias_args, ", ")
-                lua:append(")\\n    return COMPILE_ACTIONS[", \%actions[1].stub:as_lua(), "](")
-                lua:concat_append(\%args, ", ")
-                lua:append(")\\nend")
             end
         end
-        return lua
+        return lua"
-    end
-    COMPILE_ACTIONS["1 all compile to"] = COMPILE_ACTIONS["1 compiles to"]"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -112,27 +116,29 @@ test:
         (baz %) parses as (foo %)
     
     assume ((foo 1) == "outer")
-[%actions means %body, %actions all mean %body] all compile to:
+
+(%action means %body) compiles to:
     lua> "\
-        ..if \%actions.type ~= "List" then \%actions = {\%actions, type="List"} end
+        ..local fn_name = \%action.stub:as_lua_id()
-        local fn_name = \%actions[1].stub:as_lua_id()
+        local \%args = \%action:get_args()
-        local \%args = table.map(\%actions[1]:get_args(), function(a) return nomsu:compile(a):text() end)
         local lua = LuaCode(tree.source, fn_name, " = ", \(what (%args -> %body) compiles to))
         lua:add_free_vars({fn_name})
+        return lua"
+(%actions all mean %body) compiles to:
+    lua> "\
+        ..local fn_name = \%actions[1].stub:as_lua_id()
+        local \%args = List(\%actions[1]:get_args())
+        local lua = LuaCode(tree.source, \(what (%actions.1 means %body) compiles to))
         for i=2,#\%actions do
             local alias = \%actions[i]
             local alias_name = alias.stub:as_lua_id()
             lua:add_free_vars({alias_name})
-            local \%alias_args = table.map(alias:get_args(), function(a) return nomsu:compile(a):text() end)
+            local \%alias_args = List(alias:get_args())
             lua:append("\\n", alias_name, " = ")
-            if utils.equivalent(\%args, \%alias_args) then
+            if \%args == \%alias_args then
                 lua:append(fn_name)
             else
-                lua:append("function(")
+                lua:append(\(what (%alias_args -> %actions.1) compiles to))
-                lua:concat_append(\%alias_args, ", ")
-                lua:append(")\\n    return ", fn_name, "(")
-                lua:concat_append(\%args, ", ")
-                lua:append(")\\nend")
             end
         end
         return lua"
@@ -143,10 +149,14 @@ test:
 test:
     assume ((baz1) == "baz1")
     assume ((baz2) == "baz2")
-[externally %actions means %body, externally %actions all mean %body] all compile to:
+(externally %action means %body) compiles to:
     lua> "\
-        ..local lua = \(what (%actions means %body) compiles to)
+        ..local lua = \(what (%action means %body) compiles to)
-        if \%actions.type ~= "List" then \%actions = {\%actions, type="List"} end
+        lua:remove_free_vars({\%action.stub:as_lua_id()})
+        return lua"
+(externally %actions all mean %body) compiles to:
+    lua> "\
+        ..local lua = \(what (%actions all mean %body) compiles to)
         lua:remove_free_vars(table.map(\%actions, function(a) return a.stub:as_lua_id() end))
         return lua"
 
@@ -169,10 +179,12 @@ test:
     swap %tmp and %tmp2
     assume ((%tmp == 2) and (%tmp2 == 1)) or barf "\
         ..'parse % as %' variable mangling failed."
-[%actions parses as %body, %actions all parse as %body] all compile to:
+(%actions all parse as %body) compiles to:
     lua> "\
         ..local replacements = {}
-        if \%actions.type ~= "List" then \%actions = {\%actions, type="List"} end
+        if \%actions.type ~= "List" then
+            nomsu:compile_error(\%actions, "This should be a list.")
+        end
         for i,arg in ipairs(\%actions[1]:get_args()) do
             replacements[arg[1]] = nomsu:compile(arg):text()
         end
@@ -208,10 +220,12 @@ test:
         local \%new_body = LuaCode(\%body.source,
             "local mangle = mangler()",
             "\\nreturn ", make_tree(\%body))
-        local ret = \(what (%actions compiles to %new_body) compiles to)
+        local ret = \(what (%actions all compile to %new_body) compiles to)
         return ret"
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+[%action parses as %body] all parse as ([%action] all parse as %body)
 
 # TODO: add check for .is_value
 (%tree as lua expr) compiles to (..)
@@ -287,10 +301,10 @@ externally (%tree with vars %replacements) means (..)
 
 externally (match %tree with %patt) means:
     lua> "\
-        ..if \%patt.type == "Var" then return _Dict{[\%patt[1]]=\%tree} end
+        ..if \%patt.type == "Var" then return Dict{[\%patt[1]]=\%tree} end
         if \%patt.type == "Action" and \%patt.stub ~= \%tree.stub then return nil end
         if #\%patt ~= #\%tree then return nil end
-        local matches = _Dict{}
+        local matches = Dict{}
         for \%i=1,#\%patt do
             if SyntaxTree:is_instance(\%tree[\%i]) then
                 local submatch = \(match %tree.%i with %patt.%i)
@@ -341,11 +355,11 @@ externally (type of %) means:
     lua> "\
         ..local lua_type = \(lua type of %)
         if lua_type == 'string' then return 'Text'
-        elseif lua_type == 'table' then
+        elseif lua_type == 'table' or lua_type == 'userdata' then
             local mt = getmetatable(\%)
             if mt and mt.__type then return mt.__type end
-            return 'Lua table'
+        end
-        else return lua_type end"
+        return lua_type"
 
 [% is a %type, % is an %type] all parse as ((type of %) == %type)
 [% isn't a %type, % isn't an %type, % is not a %type, % is not an %type] all parse as (..)

core/text.nom

@@ -22,10 +22,10 @@ test:
     assume ("asdf"::uppercase) == "ASDF"
     assume ("asdf"::with "s" -> "X") == "aXdf"
     assume ("one\ntwo\n"::lines) == ["one", "two", ""]
-    (アクション %spec %body) parses as (externally %spec means %body)
+    (%spec とは %body) parses as (%spec means %body)
 test:
     %こんにちは = "こんにちは"
-    アクション [% と言う] "\(%)世界"
+    (% と言う) とは "\(%)世界"
     assume (%こんにちは と言う) == "こんにちは世界"
 (%expr for %match in %text matching %patt) compiles to (..)
     Lua value "\

examples/how_do_i.nom

@@ -16,6 +16,7 @@ use "lib"
 say "Hello world!"
 
 # How do I set a variable?
+# Variables have "%" prefix:
 %foobar = 1
 %text = "Hello world"
 
@@ -31,7 +32,7 @@ say %one_two
 %foobar += 1
 
 # How do I define a mutli-line string?
-# In Nomsu, "strings" are called "text", and multi-line text looks like:
+# In Nomsu, the name "text" is used, rather than "string", and multi-line text looks like:
 %mutli_text = "\
     ..Start with a quote mark and a backslash and an indented "..", then put indented
     lines below it. The indented lines will not include the indentation, except when
@@ -47,7 +48,7 @@ say "\
     ..Text can contain a backslash followed by a variable, list, dict, or parenthesized
     expression. This escaped value will be converted to readable text, like so:
     The value of %foobar is \%foobar, isn't that nice?
-    These are some numbers: \[1 + 1, 2 + 1, 3 + 1]
+    These are some numbers: \[1, 2, 3]
     The sum of 2 and 4 is \(2 + 4).
     
     A backslash not followed by any of these, and not at the end of a line
@@ -66,16 +67,16 @@ say "\
 say "Single-line text can contain escape sequences like \", \\, \000, and \n"
 
 # How do I define a list?
-%my_list = [1, 2, "hello"]
+%my_list = ["first", "second", "third", 4]
 
 # Really long lists can use [..] followed by a bunch of indented values delimited
     by commas and/or newlines
-%my_really_long_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+%my_really_long_list = [..]
+    10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000, 100000, 110000
+    120000, 130000, 140000, 150000, 160000, 170000
 
 # How do I use a list?
-%my_list = ["first item", "second item", "third item"]
+# Lists are 1-indexed because they're implemented as Lua tables, so this prints "first"
-
-# Lists are 1-indexed because they're implemented as Lua tables, so this prints "first item"
 say %my_list.1
 
 # List entries can be modified like this:
@@ -86,12 +87,15 @@ say %my_list.1
 %my_list::pop
 
 # How do I define a dictionary/hash map?
-%my_dict = {x:99, y:101}
+    One-word text keys don't need quotes, otherwise the key is an expression.
-%my_dict = {x:101, y:2, "99 bottles":99, 653:292}
+    If the expression is more complex than a literal, it needs parentheses:
+%my_dict = {x:101, y:2, "how many bottles":99, 653:292, (5 + 6):11}
 
 # How do I 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
+say %my_dict."how many bottles"
+say %my_dict.653
 %my_dict.x = 9999
 
 # How do I do conditional branching?
@@ -104,21 +108,21 @@ if (1 > 10):
     say "this will print"
 
 # There's no "elseif", so for longer conditionals, a "when" branch is the best option
-if:
+when:
-    (3 > 6) (3 > 5) (3 > 4):
-        say "this won't print"
     (3 > 3):
         say "this won't print"
+    (3 > 6) (3 > 5) (3 > 4):
+        say "this won't print because none of the conditions on the line above are true"
     (3 > 2):
         say "this will print"
     else:
         say "this is the default case"
 
 # How do I do a switch statement?
-if 3 is:
+if (1 + 2) is:
-    0 1 2:
+    0 1:
         say "this won't print"
-    3:
+    2 3:
         say "this will print"
     else:
         say "this won't print"
@@ -159,20 +163,22 @@ repeat:
 # How do I do a 'goto'?
 do:
     %x = 1
-    === %again ===
+    === (my loop) ===
     say "GOTO loop #\%x"
     %x += 1
-    if (%x <= 3): go to %again
+    if (%x <= 3): go to (my loop)
     say "finished going to"
 
 # How do I define a function/method/procedure?
 # In nomsu, they're called "action"s, and they can be declared like this:
 (say both %first and also %second) means:
     say %first
-    
-    # Function arguments are accessed just like variables
     say %second
 
+# Actions can have parts of the action's name spread throughout.
+    Everything that's not a literal value is treated as part of the action's name
+say both "Hello" and also "world!"
+
 # Actions can use "return" to return a value early
 (first fibonacci above %n) means:
     %f1 = 0
@@ -196,10 +202,6 @@ say (first fibonacci above 10)
 I like "dogs" more than "cats"
 I think "chihuahuas" are worse than "corgis"
 
-# Actions can have parts of the action's name spread throughout.
-    Everything that's not a literal value is treated as part of the action's name
-say both "Hello" and also "again!"
-
 # Actions can even start with a parameter
 (%what_she_said is what she said) means:
     say %what_she_said
@@ -207,14 +209,14 @@ say both "Hello" and also "again!"
 
 "Howdy pardner" is what she said
 
-# The language only reserves []{}().,:;% as special characters, so actions
+# The language only reserves []{}().,:;%#\ as special characters, so actions
     can have really funky names!
-(>> %foo_bar $$$^ --> % @&_~-^-~_~-^ %1 !) means:
+(>> %foo_bar $@&' --> % @&_~-^-~_~-^ %1 !) means:
     say %foo_bar
     say %
     say %1
 
->> "wow" $$$^ --> "so flexible!" @&_~-^-~_~-^ "even numbers can be variables!" !
+>> "wow" $@&' --> "so flexible!" @&_~-^-~_~-^ "even numbers can be variables!" !
 
 # There's also full unicode support
 %こんにちは = "こんにちは"
@@ -251,9 +253,9 @@ say both (my favorite number) and also "foo"
     lua> "io.write(\"The OS time is: \", os.time(), \"\\n\");"
 
 say the time
-say "Math expression result is: \(=lua "(1 + 2*3 + 3*4)^2")"
+say "Math expression result is: \(=lua "(1 + 2*3 + 3*4)^2 % 5")"
 
-# Variables can be accessed via \%varname
+# Variables can be accessed via \%var
 (square root of %n) means (=lua "math.sqrt(\%n)")
 say "The square root of 2 is \(square root of 2)"
 
@@ -261,11 +263,13 @@ say "The square root of 2 is \(square root of 2)"
 (if %condition is untrue %body) parses as (if (not %condition) %body)
 
 # Or to transform nomsu code into custom lua code using "compile % to %"
-(if %condition on opposite day %body) compiles to (..)
+(debug only %body) compiles to:
-    Lua "\
+    if %DEBUG_ENABLED:
-        ..if not \(%condition as lua expr) then
+        return (Lua "-- Debug code:\n\(%body as lua statements)")
-            \(%body as lua statements)
+    ..else:
-        end"
+        return (Lua "-- (debug code removed for production)")
+
+%DEBUG_ENABLED = (yes)
 
 # Constants can be defined as macros
 (TWENTY) parses as 20
@@ -282,34 +286,41 @@ if (1 > (TWENTY)) is untrue:
     say "Nomsu parsing macros work!"
     say "It looks like a keyword, but there's no magic here!"
 
-if (1 > (TWENTY)) on opposite day:
+debug only:
     say "Lua compiling macros work!"
-    say "It looks like a keyword, but there's no magic here!"
 
 # How do I use an action as a value?
 # Well... it's always *possible* to fall back to Lua behavior for something like this:
 (best of %items according to %key_fn) means:
-    set {%best:nil, %best_key:nil}
+    %best = (nil)
+    %best_key = (nil)
     for %item in %items:
-        %key = (=lua "\%key_fn(\%item)")
+        %key = (%key_fn %item)
         if ((%best is (nil)) or (%key > %best_key)):
-            set {%best:%item, %best_key:%key}
+            %best = %item
+            %best_key = %key
     
     return %best
 
+# Function literals look like: [%x] -> (%x * %x)
 say (best of [2, -3, 4, -8] according to ([%x] -> (%x * %x)))
 
-# But nomsu was mostly designed so that you don't *need* to. Instead of creating a
+# Or, you can use ((foo %)'s meaning) to access the function that gets called by (foo %)
-    one-off function to pass to another function and get called a bunch of times, you
+(%x squared) means (%x * %x)
-    could use a macro to generate a single block of code that inlines the expression you
+say (best of [2, -3, 4, -8] according to ((% squared)'s meaning))
-    want to use:
+
-(best of %items where %item_var has score %key_expr) parses as (..)
+# But nomsu was designed with flexible alternatives that are often better than passing functions.
+    For example, instead of calling a key function on every item, you could instead define a macro
+    that gives you a value based on an inlined expression:
+(best of %items where %item has score %key_expr) parses as (..)
     result of:
-        set {%best:nil, %best_key:nil}
+        %best = (nil)
-        for %item_var in %items:
+        %best_key = (nil)
+        for %item in %items:
             %key = %key_expr
             if ((%best is (nil)) or (%key > %best_key)):
-                set {%best:%item_var, %best_key:%key}
+                %best = %item
+                %best_key = %key
         
         return %best
 

lib/object.nom

@@ -54,25 +54,21 @@ test:
 (my action %actions %body) compiles to:
     lua> "\
         ..local fn_name = \%actions[1].stub:as_lua_id()
-        local \%args = table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(a)) end)
+        local \%args = List(\%actions[1]:get_args())
-        table.insert(\%args, 1, \(\%me as lua id))
+        table.insert(\%args, 1, \(\%me))
         local lua = LuaCode(tree.source, "class.", fn_name, " = ", \(..)
             what (%args -> %body) compiles to
         ..)
         for i=2,#\%actions do
             local alias = \%actions[i]
             local alias_name = alias.stub:as_lua_id()
-            local \%alias_args = table.map(alias:get_args(), function(a) return tostring(nomsu:compile(a)) end)
+            local \%alias_args = List(alias:get_args())
-            table.insert(\%alias_args, 1, \(\%me as lua id))
+            table.insert(\%alias_args, 1, \(\%me))
             lua:append("\\nclass.", alias_name, " = ")
-            if utils.equivalent(\%args, \%alias_args) then
+            if \%args == \%alias_args then
                 lua:append("class.", fn_name)
             else
-                lua:append("function(")
+                lua:append(\(what (%alias_args -> %actions.1) compiles to))
-                lua:concat_append(\%alias_args, ", ")
-                lua:append(")\\n    return class.", fn_name, "(")
-                lua:concat_append(\%args, ", ")
-                lua:append(")\\nend")
             end
         end
         return lua"

lib/os.nom

@@ -32,7 +32,7 @@ test:
 (%expr for file %f in %path) compiles to (..)
     Lua value "\
         ..(function()
-            local ret = _List{}
+            local ret = List{}
             for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
                 ret[#ret+1] = \(%expr as lua statements)
             end

nomsu.lua

@@ -131,7 +131,7 @@ if not args or args.help then
   os.exit(EXIT_FAILURE)
 end
 local nomsu = NomsuCompiler
-nomsu.environment.arg = NomsuCompiler.environment._List(args.nomsu_args)
+nomsu.environment.arg = NomsuCompiler.environment.List(args.nomsu_args)
 if args.version then
   nomsu:run([[(: use "core"; say (Nomsu version))]])
   os.exit(EXIT_SUCCESS)

nomsu.moon

@@ -86,7 +86,7 @@ if not args or args.help
     os.exit(EXIT_FAILURE)
 
 nomsu = NomsuCompiler
-nomsu.environment.arg = NomsuCompiler.environment._List(args.nomsu_args)
+nomsu.environment.arg = NomsuCompiler.environment.List(args.nomsu_args)
 
 if args.version
     nomsu\run [[(: use "core"; say (Nomsu version))]]

nomsu_compiler.lua

@@ -2,10 +2,7 @@ local lpeg = require('lpeg')
 local R, P, S
 R, P, S = lpeg.R, lpeg.P, lpeg.S
 local re = require('re')
-local utils = require('utils')
 local Files = require('files')
-local stringify, equivalent
-stringify, equivalent = utils.stringify, utils.equivalent
 local List, Dict, Text
 do
   local _obj_0 = require('containers')
@@ -187,10 +184,8 @@ do
     load = load,
     pairs = pairs,
     ipairs = ipairs,
-    _List = List,
+    List = List,
-    _Dict = Dict,
+    Dict = Dict,
-    stringify = stringify,
-    utils = utils,
     lpeg = lpeg,
     re = re,
     Files = Files,
@@ -431,6 +426,22 @@ do
   end
   NomsuCompiler.environment.COMPILE_ACTIONS = setmetatable({
     __imported = Dict({ }),
+    [""] = function(self, tree, fn, ...)
+      local lua = LuaCode.Value(tree.source)
+      lua:append(self:compile(fn, compile_actions))
+      if not (lua:text():is_lua_id()) then
+        lua:parenthesize()
+      end
+      lua:append("(")
+      for i = 1, select('#', ...) do
+        if i > 1 then
+          lua:append(", ")
+        end
+        lua:append(self:compile(select(i, ...), compile_actions))
+      end
+      lua:append(")")
+      return lua
+    end,
     ["Lua"] = function(self, tree, code)
       return add_lua_string_bits(self, 'statements', code)
     end,
@@ -710,15 +721,12 @@ do
           local filename = Source:from_string(info.source).filename
           self:compile_error(tree, "The compile-time action here (" .. tostring(stub) .. ") failed to return any value.", "Look at the implementation of (" .. tostring(stub) .. ") in " .. tostring(filename) .. ":" .. tostring(info.linedefined) .. " and make sure it's returning something.")
         end
-        if SyntaxTree:is_instance(ret) then
+        if not (SyntaxTree:is_instance(ret)) then
-          if ret == tree then
+          return ret
-            local info = debug.getinfo(compile_action, "S")
-            local filename = Source:from_string(info.source).filename
-            self:compile_error(tree, "The compile-time action here (" .. tostring(stub) .. ") is producing an endless loop.", "Look at the implementation of (" .. tostring(stub) .. ") in " .. tostring(filename) .. ":" .. tostring(info.linedefined) .. " and make sure it's not just returning the original tree.")
         end
+        if ret ~= tree then
           return self:compile(ret, compile_actions)
         end
-        return ret
       end
       local lua = LuaCode.Value(tree.source)
       if tree.target then
@@ -871,7 +879,7 @@ do
             lua:append("..")
           end
           if bit.type ~= "Text" then
-            bit_lua = LuaCode.Value(bit.source, "stringify(", bit_lua, ")")
+            bit_lua = LuaCode.Value(bit.source, "tostring(", bit_lua, ")")
           end
           lua:append(bit_lua)
           _continue_0 = true
@@ -891,7 +899,7 @@ do
       end
       return lua
     elseif "List" == _exp_0 then
-      local lua = LuaCode.Value(tree.source, "_List{")
+      local lua = LuaCode.Value(tree.source, "List{")
       lua:concat_append((function()
         local _accum_0 = { }
         local _len_0 = 1
@@ -905,7 +913,7 @@ do
       lua:append("}")
       return lua
     elseif "Dict" == _exp_0 then
-      local lua = LuaCode.Value(tree.source, "_Dict{")
+      local lua = LuaCode.Value(tree.source, "Dict{")
       lua:concat_append((function()
         local _accum_0 = { }
         local _len_0 = 1

nomsu_compiler.moon

@@ -12,9 +12,7 @@
 lpeg = require 'lpeg'
 {:R,:P,:S} = lpeg
 re = require 're'
-utils = require 'utils'
 Files = require 'files'
-{:stringify, :equivalent} = utils
 {:List, :Dict, :Text} = require 'containers'
 export colors, colored
 colors = require 'consolecolors'
@@ -101,9 +99,9 @@ with NomsuCompiler
         :table, :assert, :dofile, :loadstring, lua_type_of:type, :select, :math, :io, :load,
         :pairs, :ipairs,
         -- Nomsu types:
-        _List:List, _Dict:Dict,
+        List:List, Dict:Dict,
         -- Utilities and misc.
-        stringify:stringify, utils:utils, lpeg:lpeg, re:re, Files:Files,
+        lpeg:lpeg, re:re, Files:Files,
         :SyntaxTree, TESTS: Dict({}), globals: Dict({}),
         :LuaCode, :NomsuCode, :Source
         nomsu:NomsuCompiler
@@ -242,6 +240,17 @@ with NomsuCompiler
         return lua
     .environment.COMPILE_ACTIONS = setmetatable({
         __imported: Dict{}
+        [""]: (tree, fn, ...)=>
+            lua = LuaCode.Value(tree.source)
+            lua\append @compile(fn, compile_actions)
+            lua\parenthesize! unless lua\text!\is_lua_id!
+            lua\append "("
+            for i=1,select('#',...)
+                lua\append(", ") if i > 1
+                lua\append @compile(select(i, ...), compile_actions)
+            lua\append ")"
+            return lua
+
         ["Lua"]: (tree, code)=>
             return add_lua_string_bits(@, 'statements', code)
     
@@ -415,15 +424,10 @@ with NomsuCompiler
                         @compile_error tree,
                             "The compile-time action here (#{stub}) failed to return any value.",
                             "Look at the implementation of (#{stub}) in #{filename}:#{info.linedefined} and make sure it's returning something."
-                    if SyntaxTree\is_instance(ret)
+                    unless SyntaxTree\is_instance(ret)
-                        if ret == tree
-                            info = debug.getinfo(compile_action, "S")
-                            filename = Source\from_string(info.source).filename
-                            @compile_error tree,
-                                "The compile-time action here (#{stub}) is producing an endless loop.",
-                                "Look at the implementation of (#{stub}) in #{filename}:#{info.linedefined} and make sure it's not just returning the original tree."
-                        return @compile(ret, compile_actions)
                         return ret
+                    if ret != tree
+                        return @compile(ret, compile_actions)
 
                 lua = LuaCode.Value(tree.source)
                 if tree.target -- Method call
@@ -524,7 +528,7 @@ with NomsuCompiler
                             "Can't this as a string interpolation value, since it's not an expression."
                     if #lua.bits > 0 then lua\append ".."
                     if bit.type != "Text"
-                        bit_lua = LuaCode.Value(bit.source, "stringify(",bit_lua,")")
+                        bit_lua = LuaCode.Value(bit.source, "tostring(",bit_lua,")")
                     lua\append bit_lua
 
                 if string_buffer ~= "" or #lua.bits == 0
@@ -536,13 +540,13 @@ with NomsuCompiler
                 return lua
 
             when "List"
-                lua = LuaCode.Value tree.source, "_List{"
+                lua = LuaCode.Value tree.source, "List{"
                 lua\concat_append([@compile(e, compile_actions) for e in *tree], ", ", ",\n  ")
                 lua\append "}"
                 return lua
 
             when "Dict"
-                lua = LuaCode.Value tree.source, "_Dict{"
+                lua = LuaCode.Value tree.source, "Dict{"
                 lua\concat_append([@compile(e, compile_actions) for e in *tree], ", ", ",\n  ")
                 lua\append "}"
                 return lua

utils.lua

@@ -1,334 +0,0 @@
--- A collection of helper utility functions
---
-local match, gmatch, gsub = string.match, string.gmatch, string.gsub
-local function is_list(t)
-    if type(t) ~= 'table' then
-        return false
-    end
-    local i = 1
-    for _ in pairs(t) do
-        if t[i] == nil then
-            return false
-        end
-        i = i + 1
-    end
-    return true
-end
-
-local function size(t)
-    local n = 0
-    for _ in pairs(t) do
-        n = n + 1
-    end
-    return n
-end
-
-local repr_behavior = function(x)
-    local mt = getmetatable(x)
-    if mt then
-        local fn = rawget(mt, "__repr")
-        if fn then return fn(x) end
-    end
-end
-local function repr(x, mt_behavior)
-    -- Create a string representation of the object that is close to the lua code that will
-    -- reproduce the object (similar to Python's "repr" function)
-    mt_behavior = mt_behavior or repr_behavior
-    local x_type = type(x)
-    if x_type == 'table' then
-        local ret = mt_behavior(x)
-        if ret then return ret end
-        local ret = {}
-        local i = 1
-        for k, v in pairs(x) do
-            if k == i then
-                ret[#ret+1] = repr(v, mt_behavior)
-                i = i + 1
-            elseif type(k) == 'string' and match(k,"[_a-zA-Z][_a-zA-Z0-9]*") then
-                ret[#ret+1] = k.."= "..repr(v, mt_behavior)
-            else
-                ret[#ret+1] = "["..repr(k, mt_behavior).."]= "..repr(v, mt_behavior)
-            end
-        end
-        return "{"..table.concat(ret, ", ").."}"
-    elseif x_type == 'string' then
-        local escaped = gsub(x, "\\", "\\\\")
-        escaped = gsub(escaped, "\n", "\\n")
-        escaped = gsub(escaped, '"', '\\"')
-        escaped = gsub(escaped, "[%c%z]", function(c) return ("\\%03d"):format(c:byte()) end)
-        return '"'..escaped..'"'
-    else
-        return tostring(x)
-    end
-end
-
-local stringify_behavior = function(x)
-    local mt = getmetatable(x)
-    if mt then
-        local fn = rawget(mt, "__tostring")
-        if fn then return fn(x) end
-    end
-end
-local function stringify(x)
-    if type(x) == 'string' then
-        return x
-    else
-        return repr(x, stringify_behavior)
-    end
-end
-
-local function split(str, sep)
-    if sep == nil then
-        sep = "%s"
-    end
-    local ret = {}
-    for chunk in gmatch(str, "[^"..sep.."]+") do
-        ret[#ret+1] = chunk
-    end
-    return ret
-end
-
-local function remove_from_list(list, item)
-    local deleted, N = 0, #list
-    for i=1,N do
-        if list[i] == item then
-            deleted = deleted + 1
-        else
-            list[i-deleted] = list[i]
-        end
-    end
-    for i=N-deleted+1,N do list[i] = nil end
-end
-
-local function accumulate(co)
-    local bits = {}
-    for bit in coroutine.wrap(co) do
-        bits[#bits+1] = bit
-    end
-    return bits
-end
-
-local function nth_to_last(list, n)
-    return list[#list - n + 1]
-end
-
-local function keys(t)
-    local ret = {}
-    for k in pairs(t) do
-        ret[#ret+1] = k
-    end
-    return ret
-end
-
-local function values(t)
-    local ret = {}
-    for _,v in pairs(t) do
-        ret[#ret+1] = v
-    end
-    return ret
-end
-
-local function set(list)
-    local ret = {}
-    for i=1,#list do
-        ret[list[i]] = true
-    end
-    return ret
-end
-
-local function deduplicate(list)
-    local seen, deleted = {}, 0
-    for i, item in ipairs(list) do
-        if seen[item] then
-            deleted = deleted + 1
-        else
-            seen[item] = true
-            list[i-deleted] = list[i]
-        end
-    end
-end
-
-local function sum(t)
-    local tot = 0
-    for i=1,#t do
-        tot = tot + t[i]
-    end
-    return tot
-end
-
-local function product(t)
-    if #t > 5 and 0 < t[1] and t[1] < 1 then
-        local log, log_prod = math.log, 0
-        for i=1,#t do
-            log_prod = log_prod + log(t[i])
-        end
-        return math.exp(log_prod)
-    else
-        local prod = 1
-        for i=1,#t do
-            prod = prod * t[i]
-        end
-        return prod
-    end
-end
-
-local function all(t)
-    for i=1,#t do
-        if not t[i] then return false end
-    end
-    return true
-end
-
-local function any(t)
-    for i=1,#t do
-        if t[i] then return true end
-    end
-    return false
-end
-
-local function min(list, keyFn)
-    if keyFn == nil then
-        keyFn = (function(x)
-            return x
-        end)
-    end
-    if type(keyFn) == 'table' then
-        local keyTable = keyFn
-        keyFn = function(k)
-            return keyTable[k]
-        end
-    end
-    local best = list[1]
-    local bestKey = keyFn(best)
-    for i = 2, #list do
-        local key = keyFn(list[i])
-        if key < bestKey then
-            best, bestKey = list[i], key
-        end
-    end
-    return best
-end
-
-local function max(list, keyFn)
-    if keyFn == nil then
-        keyFn = (function(x)
-            return x
-        end)
-    end
-    if type(keyFn) == 'table' then
-        local keyTable = keyFn
-        keyFn = function(k)
-            return keyTable[k]
-        end
-    end
-    local best = list[1]
-    local bestKey = keyFn(best)
-    for i = 2, #list do
-        local key = keyFn(list[i])
-        if key > bestKey then
-            best, bestKey = list[i], key
-        end
-    end
-    return best
-end
-
-local function sort(list, keyFn, reverse)
-    if keyFn == nil then
-        keyFn = (function(x)
-            return x
-        end)
-    end
-    if reverse == nil then
-        reverse = false
-    end
-    if type(keyFn) == 'table' then
-        local keyTable = keyFn
-        keyFn = function(k)
-            return keyTable[k]
-        end
-    end
-    table.sort(list, reverse
-        and (function(x,y) return keyFn(x) > keyFn(y) end)
-        or  (function(x,y) return keyFn(x) < keyFn(y) end))
-    return list
-end
-
-local function equivalent(x, y, depth)
-    depth = depth or 0
-    if rawequal(x, y) then
-        return true
-    end
-    if type(x) ~= type(y) then
-        return false
-    end
-    if type(x) ~= 'table' then return false end
-    if getmetatable(x) ~= getmetatable(y) then
-        return false
-    end
-    if depth >= 99 then
-        error("Exceeded maximum comparison depth")
-    end
-    local checked = {}
-    for k, v in pairs(x) do
-        if not equivalent(y[k], v, depth + 1) then
-            return false
-        end
-        checked[k] = true
-    end
-    for k, v in pairs(y) do
-        if not checked[k] and not equivalent(x[k], v, depth + 1) then
-            return false
-        end
-    end
-    return true
-end
-
-local function key_for(t, value)
-    for k, v in pairs(t) do
-        if v == value then
-            return k
-        end
-    end
-    return nil
-end
-
-local function clamp(x, min, max)
-    if x < min then
-        return min
-    elseif x > max then
-        return max
-    else
-        return x
-    end
-end
-
-local function mix(min, max, amount)
-    return (1 - amount) * min + amount * max
-end
-
-local function sign(x)
-    if x == 0 then
-        return 0
-    elseif x < 0 then
-        return -1
-    else
-        return 1
-    end
-end
-
-local function round(x, increment)
-    if increment == nil then
-        increment = 1
-    end
-    if x >= 0 then
-        return math.floor(x / increment + .5) * increment
-    else
-        return math.ceil(x / increment - .5) * increment
-    end
-end
-
-return {is_list=is_list, size=size, repr=repr, stringify=stringify, split=split,
-    remove_from_list=remove_from_list, accumulate=accumulate, nth_to_last=nth_to_last,
-    keys=keys, values=values, set=set, deduplicate=deduplicate, sum=sum, product=product,
-    all=all, any=any, min=min, max=max, sort=sort, equivalent=equivalent, key_for=key_for,
-    clamp=clamp, mix=mix, round=round}