Reworked {} a bit and added dicts to the core language. Did some more

testing on string interpolations too.

lib/collections.nom

@@ -18,15 +18,6 @@ compile [..]
 parse [first in %list, first %list] as: 1 st in %list
 parse [last in %list, last %list] as: 1 st to last in %list
 
-# Dict iteration convenience function. This could also be accomplished with: for all (entries in %dict): ...
-compile [for %key = %value in %dict %body] to code: ".."
-    do
-        for k, v in pairs(\(%dict as lua)) do
-            \(%key as lua), \(%value as lua) = k, v;
-            \(%body as lua statements)
-        end
-    end
-
 # Membership testing
 rule [%item is in %list, %list contains %item, %list has %item] =:
     for %key = %value in %list:
@@ -60,7 +51,7 @@ compile [%list ->* %indices] to:
     %ret = "\(%list as lua)"
     for %index in (%indices's "value"):
         %ret join= "[\(%index as lua)]"
-    "\(%ret)"
+    "\%ret"
 
 # Assignment
 compile [..]
@@ -87,43 +78,16 @@ rule [flatten %lists] =:
             add %item to %flat
     %flat
 
-rule [dict from entries %items] =:
+rule [dict %items] =:
     %dict = []
     for %pair in %items:
         %dict -> (%pair -> 1) = (%pair -> 2)
     %dict
 
-compile [dict %items, d %items] to:
-    if ((%items's "type") == "Thunk"):
-        %item_codes = []
-        for %func_call in (%items's "value"):
-            assert ((%func_call's "type") == "FunctionCall") ".."
-                Invalid format for 'dict' expression. Only literals are allowed.
-            %tokens = (%func_call's "value")
-            %equals = (%tokens -> 2)
-            assert (=lua "#\(%tokens) == 3 and \(%equals) and \(%equals).type == 'Word' and \(%equals).value == '='") ".."
-                Invalid format for 'dict' expression. Lines must only have the "% = %" format, not \(%func_call's "src")
-            %key = (%tokens -> 1)
-            lua> ".."
-                if \(%key).type == "Word" and \(%key).value:match("^[a-zA-Z_][a-zA-Z0-9_]*$") then
-                    \(%key_code) = \(%key).value;
-                elseif \(%key).type == "Word" then
-                    \(%key_code) = "["..nomsu:repr(\(%key).value).."]";
-                else
-                    \(\{%key_code = "[\((%key as lua))]"} as lua statements)
-                end
-            add "\(%key_code) = \((%tokens -> 3) as lua)" to %item_codes
-        return "{\(join %item_codes with glue ",\n")}"
-    ..else:
-        return (..)
-            (..)
-                nomsu "replaced_vars" [\(dict from entries %items), =lua "vars"]
-            ..as lua
-
 rule [entries in %dict] =:
     %entries = []
     for %k = %v in %dict:
-        add (dict {key = %k; value = %v}) to %entries
+        add {key=%k, value=%v} to %entries
     %entries
 
 rule [keys in %dict] =:
@@ -137,20 +101,35 @@ rule [values in %dict] =:
     %values
 
 # List Comprehension
-compile [%expression for %var in %iterable] to:
+compile [%expression for %item in %iterable] to:
-    assert ((%var's "type") == "Var") ".."
+    assert ((%item's "type") == "Var") ".."
-        List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%var's "type")
+        List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item's "type")
     ".."
-        (function(game, vars);
+        (function(nomsu, vars);
             local comprehension = {};
-            for i,value in ipairs(\(%iterable as lua)) do;
+            for i,item in ipairs(\(%iterable as lua)) do;
-                \(%var as lua) = value;
+                \(%item as lua) = item;
                 comprehension[i] = \(%expression as lua);
             end;
             return comprehension;
-        end)(game, setmetatable({}, {__index=vars}))
+        end)(nomsu, setmetatable({}, {__index=vars}))
 parse [%expression for all %iterable] as: %expression for % in %iterable
 
+compile [%expression for %key = %value in %iterable] to:
+    assert ((%key's "type") == "Var") ".."
+        List comprehension has the wrong type for the key loop variable. Expected Var, but got: \(%key's "type")
+    assert ((%value's "type") == "Var") ".."
+        List comprehension has the wrong type for the value loop variable. Expected Var, but got: \(%value's "type")
+    ".."
+        (function(nomsu, vars);
+            local comprehension = {};
+            for key,value in pairs(\(%iterable as lua)) do;
+                \(%key as lua), \(%value as lua) = key, value;
+                comprehension[i] = \(%expression as lua);
+            end;
+            return comprehension;
+        end)(nomsu, setmetatable({}, {__index=vars}))
+
 rule [%items sorted] =:
     %copy = (% for all %items)
     sort %copy
@@ -160,7 +139,7 @@ rule [%items sorted by %key] =:
     sort %copy by %key
     %copy
 rule [unique %items] =:
-    keys in (dict from entries ([%,yes] for all %items))
+    keys in (dict ([%,yes] for all %items))
 
 # Metatable stuff
 compile [counter] to: "setmetatable({}, {__index=function() return 0; end})"
@@ -173,17 +152,42 @@ compile [default dict] to: ".."
 rule [chain %dict to %fallback] =:
     when (type of %fallback) == ?:
         * "table":
-            =lua "setmetatable(\(%dict), \(%fallback))"
+            =lua "setmetatable(\%dict, \%fallback)"
         * "function":
-            =lua "setmetatable(\(%dict), {__index=function(self, key) return (\(%fallback))(nomsu, {['']=key, self=self}); end})"
+            =lua "setmetatable(\%dict, {__index=function(self, key) return (\%fallback)(nomsu, {['']=key, self=self}); end})"
         * else:
-            =lua "setmetatable(\(%dict), {__index=function(self, key) return (\(%fallback)); end})"
+            =lua "setmetatable(\%dict, {__index=function(self, key) return (\%fallback); end})"
 
 
 # TODO: maybe make a generator/coroutine?
 
-#.. Dict comprehensions can be accomplished okay by doing:
+# Dict comprehensions
-    dict ([%'s "key", %'s "value"] for all (entries in %dict))
+compile [%key = %value for %item in %iterable] to:
-    or something similar
+    assert ((%item's "type") == "Var") ".."
-# TODO: fix compiler bugs
+        Dict comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item's "type")
-pass
+    ".."
+        (function(nomsu, vars);
+            local comprehension = {};
+            for i,value in ipairs(\(%iterable as lua)) do;
+                \(%item as lua) = value;
+                comprehension[\(%key as lua)] = \(%value as lua);
+            end;
+            return comprehension;
+        end)(nomsu, setmetatable({}, {__index=vars}))
+parse [%key = %value for all %iterable] as: %key = %value for % in %iterable
+
+compile [%key = %value for %src_key = %src_value in %iterable] to:
+    assert ((%src_key's "type") == "Var") ".."
+        Dict comprehension has the wrong type for the key loop variable. Expected Var, but got: \(%src_key's "type")
+    assert ((%src_value's "type") == "Var") ".."
+        Dict comprehension has the wrong type for the value loop variable. Expected Var, but got: \(%src_value's "type")
+    ".."
+        (function(nomsu, vars);
+            local comprehension = {};
+            for key,value in pairs(\(%iterable as lua)) do;
+                \(%src_key as lua), \(%src_value as lua) = key, value;
+                comprehension[\(%key as lua)] = \(%value as lua);
+            end;
+            return comprehension;
+        end)(nomsu, setmetatable({}, {__index=vars}))
+

lib/control_flow.nom

@@ -31,8 +31,8 @@ compile [go to %label] to code: ".."
 
 rule [tree %tree has function call %call] =:
     lua> ".."
-        local target = (\(%call)).stub;
+        local target = (\%call).stub;
-        for subtree,_ in coroutine.wrap(function() nomsu:walk_tree(\(%tree)); end) do
+        for subtree,_ in coroutine.wrap(function() nomsu:walk_tree(\%tree); end) do
             if type(subtree) == 'table' and subtree.type == "FunctionCall"
             and subtree.stub == target then
                 return true;
@@ -48,12 +48,13 @@ compile [repeat while %condition %body] to code:
         "\n::continue_repeat::;" if (tree %body has function call \(do next repeat-loop)) else ""
     %code = ".."
         while \(%condition as lua) do
-        \(%body as lua statements)\(%continue_labels)
+        \(%body as lua statements)\
+        ..\%continue_labels
         end --while-loop
     if (tree %body has function call \(stop repeat-loop)):
         return ".."
             do --while-loop label scope
-            \(%code)
+            \%code
             ::stop_repeat::;
             end --while-loop label scope
     return %code
@@ -76,22 +77,24 @@ compile [..]
     %continue_labels = ""
     if (tree %body has function call \(do next for-loop)):
         %continue_labels join= "\n::continue_for::;"
-    if (tree %body has function call (nomsu "replaced_vars" [\(do next %), =lua "{['']=\(%var)}"])):
+    if (tree %body has function call (tree \(do next %) with {""=%var})):
         %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;"
     # This trashes the loop variables, just like in Python.
     %code = ".."
         for i=\(%start as lua),\(%stop as lua),\(%step as lua) do
         \(%var as lua) = i;
-        \(%body as lua statements)\(%continue_labels)
+        \(%body as lua statements)\
+        ..\%continue_labels
         end --numeric for-loop
     %stop_labels = ""
     if (tree %body has function call \(stop for-loop)):
         %stop_labels join= "\n::stop_for::;"
-    if (tree %body has function call (nomsu "replaced_vars" [\(stop %), =lua "{['']=\(%var)}"])):
+    if (tree %body has function call (tree \(stop %) with {""=%var})):
         %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;"
     if (%stop_labels != ""): ".."
         do --for-loop label scope
-        \(%code)\(%stop_labels)
+        \%code\
+        ..\%stop_labels
         end --for-loop label scope
     ..else: %code
 parse [for %var from %start to %stop %body] as: for %var from %start to %stop via 1 %body
@@ -105,26 +108,56 @@ compile [for %var in %iterable %body] to code:
     %continue_labels = ""
     if (tree %body has function call \(do next for-loop)):
         %continue_labels join= "\n::continue_for::;"
-    if (tree %body has function call (nomsu "replaced_vars" [\(do next %), =lua "{['']=\(%var)}"])):
+    if (tree %body has function call (tree \(do next %) with {""=%var})):
         %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;"
     # This trashes the loop variables, just like in Python.
     %code = ".."
         for i,value in ipairs(\(%iterable as lua)) do
         \(%var as lua) = value;
-        \(%body as lua statements)\(%continue_labels)
+        \(%body as lua statements)\
+        ..\%continue_labels
         end --foreach-loop
     %stop_labels = ""
     if (tree %body has function call \(stop for-loop)):
         %stop_labels join= "\n::stop_for::;"
-    if (tree %body has function call (nomsu "replaced_vars" [\(stop %), =lua "{['']=\(%var)}"])):
+    if (tree %body has function call (tree \(stop %) with {""=%var})):
         %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;"
     if (%stop_labels != ""): ".."
         do --for-loop label scope
-        \(%code)\(%stop_labels)
+        \%code\%stop_labels
         end --for-loop label scope
     ..else: %code
 parse [for all %iterable %body] as: for % in %iterable %body
 
+# Dict iteration (lua's "pairs()")
+compile [for %key = %value in %iterable %body] to code:
+    %continue_labels = ""
+    if (tree %body has function call \(do next for-loop)):
+        %continue_labels join= "\n::continue_for::;"
+    if (tree %body has function call (tree \(do next %x) with {x=%key})):
+        %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%key])::;"
+    if (tree %body has function call (tree \(do next %) with {""=%value})):
+        %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%value])::;"
+    # This trashes the loop variables, just like in Python.
+    %code = ".."
+        for key,value in ipairs(\(%iterable as lua)) do
+        \(%key as lua), \(%value as lua) = key, value;
+        \(%body as lua statements)\
+        ..\%continue_labels
+        end --foreach-loop
+    %stop_labels = ""
+    if (tree %body has function call \(stop for-loop)):
+        %stop_labels join= "\n::stop_for::;"
+    if (tree %body has function call (tree \(stop %) with {""=%key})):
+        %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%key])::;"
+    if (tree %body has function call (tree \(stop %) with {""=%value})):
+        %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%value])::;"
+    if (%stop_labels != ""): ".."
+        do --for-loop label scope
+        \%code\
+        ..\%stop_labels
+        end --for-loop label scope
+    ..else: %code
 
 # Switch statement/multi-branch if
 compile [when %body] to code:
@@ -160,7 +193,7 @@ compile [when %body] to code:
                 %condition join= " or \(% as lua)"
             %result join= ".."
                 
-                \("if" if %first else "elseif") \(%condition) then
+                \("if" if %first else "elseif") \%condition then
                 \(%action as lua statements)
 
         %fallthroughs = []
@@ -204,7 +237,7 @@ compile [when %branch_value == ? %body] to code:
                 %condition join= " or (branch_value == \(% as lua))"
             %result join= ".."
                 
-                \("if" if %first else "elseif") \(%condition) then
+                \("if" if %first else "elseif") \%condition then
                 \(%action as lua statements)
 
         %fallthroughs = []
@@ -213,7 +246,8 @@ compile [when %branch_value == ? %body] to code:
     if (%result != ""):
         %result = ".."
             do --when == ?
-            local branch_value = \(%branch_value as lua);\(%result)
+            local branch_value = \(%branch_value as lua);\
+            ..\%result
             end
             end --when == ?
     %result
@@ -239,11 +273,13 @@ compile [..]
         end
     end
 parse [try %action] as:
-    try %action and if it succeeds {pass} or if it fails {pass}
+    try %action and if it succeeds: pass
+    ..or if it fails: pass
 parse [try %action and if it fails %fallback] as:
-    try %action and if it succeeds {pass} or if it fails %fallback
+    try %action and if it succeeds: pass
+    ..or if it fails %fallback
 parse [try %action and if it succeeds %success] as:
-    try %action and if it succeeds %success or if it fails {pass}
+    try %action and if it succeeds %success or if it fails: pass
 
 # Do/finally:
 compile [do %action then always %final_action] to code: ".."

lib/metaprogramming.nom

@@ -107,6 +107,8 @@ rule [%tree as lua statements] =:
 compile [nomsu] to: "nomsu"
 compile [nomsu's %key] to: "nomsu[\(%key as lua)]"
 compile [nomsu %method %args] to: "nomsu[\(%method as lua)](nomsu, unpack(\(%args as lua)))"
+compile [tree %tree with %replacements] to: ".."
+    nomsu:replaced_vars(\(%tree as lua), \(%replacements as lua))
 
 parse [rule %signature] as:
     (nomsu's "defs")->(nomsu "get_stub" [\%signature])

lib/operators.nom

@@ -32,7 +32,17 @@ compile [..]
 compile [%obj'%key, %obj's %key, %obj -> %key] to: "(\(%obj as lua))[\(%key as lua)]"
 
 # Variable assignment operator, and += type versions
-compile [%var = %val] to code: "\(%var as lua) = \(%val as lua);"
+compile [%var = %val] to code:
+    lua> ".."
+        if \%var.type == 'List' and \%val.type == 'List' then
+            local lhs = {};
+            for i,x in ipairs(\%var.value) do lhs[i] = nomsu:tree_to_lua(x); end
+            local rhs = {};
+            for i,x in ipairs(\%val.value) do rhs[i] = nomsu:tree_to_lua(x); end
+            return table.concat(lhs, ", ").." = "..table.concat(rhs, ", ")..";";
+        else
+            return \(%var as lua).." = "..\(%val as lua)..";";
+        end
 compile [%var += %val] to code: "\(%var as lua) = \(%var as lua) + \(%val as lua);"
 compile [%var -= %val] to code: "\(%var as lua) = \(%var as lua) - \(%val as lua);"
 compile [%var *= %val] to code: "\(%var as lua) = \(%var as lua) * \(%val as lua);"
@@ -53,7 +63,7 @@ lua do> ".."
         end
         nomsu:defmacro("%a "..nomsu_alias.." %b", (function(nomsu, vars)
             return "("..nomsu:tree_to_lua(vars.a).." "..op.." "..nomsu:tree_to_lua(vars.b)..")";
-        end), [["(\\(%a) ]]..op..[[ \\(%b))"]]);
+        end), [["(\\%a ]]..op..[[ \\(%b))"]]);
     end
 
 # TODO: implement OR, XOR, AND for multiple operands

lib/scopes.nom

@@ -21,7 +21,7 @@ parse [using %scoped do %actions] as:
             getmetatable(nomsu.defs["#vars"]).__newindex = getmetatable(nomsu.defs["#vars"]).__index;
         do %actions
 
-parse [scoped %actions] as: using %actions do {pass}
+parse [scoped %actions] as: using %actions do (:pass)
 
 rule [from %filename import %rules] =:
     using:

lib/utils2.nom

@@ -27,7 +27,7 @@ compile [with %assignments %action] to code:
         assert (=lua "vars.eq and vars.eq.type == 'Word' and vars.eq.value == '='") ".."
             Invalid format for 'with' statement. List entries must have the form %var = (value)
         %value = (%tokens -> 3)
-        add (d{i=%i; var=%var; value=%value}) to %data
+        add {i=%i, var=%var, value=%value} to %data
     %foo = (..)
         join (..)
             "local old_value\(%->"i") = \((%->"var") as lua); \((%->"var") as lua) = \((%->"value") as lua);"

nomsu.lua

@@ -740,6 +740,8 @@ end);]]):format(concat(buffer, "\n"))
         else
           return longbuff, false
         end
+      elseif "Dict" == _exp_0 then
+        return error("Sorry, not yet implemented.")
       elseif "Number" == _exp_0 then
         return repr(tree.value), true
       elseif "Var" == _exp_0 then
@@ -955,6 +957,32 @@ end)]]):format(concat(lua_bits, "\n"))
           insert(items, expr)
         end
         return self.__class:comma_separated_items("{", items, "}"), nil
+      elseif "Dict" == _exp_0 then
+        local items = { }
+        local _list_0 = tree.value
+        for _index_0 = 1, #_list_0 do
+          local entry = _list_0[_index_0]
+          local key_expr, key_statement
+          if entry.dict_key.type == "Word" then
+            key_expr, key_statement = repr(entry.dict_key.value), nil
+          else
+            key_expr, key_statement = self:tree_to_lua(entry.dict_key, filename)
+          end
+          if key_statement then
+            self:error("Cannot use [[" .. tostring(entry.dict_key.src) .. "]] as a dict key, since it's not an expression.")
+          end
+          local value_expr, value_statement = self:tree_to_lua(entry.dict_value, filename)
+          if value_statement then
+            self:error("Cannot use [[" .. tostring(entry.dict_value.src) .. "]] as a dict value, since it's not an expression.")
+          end
+          local key_str = key_expr:match([=[["']([a-zA-Z_][a-zA-Z0-9_]*)['"]]=])
+          if key_str then
+            insert(items, tostring(key_str) .. "=" .. tostring(value_expr))
+          else
+            insert(items, "[" .. tostring(key_expr) .. "]=" .. tostring(value_expr))
+          end
+        end
+        return self.__class:comma_separated_items("{", items, "}"), nil
       elseif "Number" == _exp_0 then
         return repr(tree.value), nil
       elseif "Var" == _exp_0 then
@@ -982,6 +1010,13 @@ end)]]):format(concat(lua_bits, "\n"))
           local v = _list_0[_index_0]
           self:walk_tree(v, depth + 1)
         end
+      elseif "Dict" == _exp_0 then
+        local _list_0 = tree.value
+        for _index_0 = 1, #_list_0 do
+          local e = _list_0[_index_0]
+          self:walk_tree(e.dict_key, depth + 1)
+          self:walk_tree(e.dict_value, depth + 1)
+        end
       else
         self:walk_tree(tree.value, depth + 1)
       end
@@ -1034,6 +1069,28 @@ end)]]):format(concat(lua_bits, "\n"))
           end
           tree.value = new_value
         end
+      elseif "Dict" == _exp_0 then
+        local dirty = false
+        local replacements = { }
+        for i, e in ipairs(tree.value) do
+          local new_key = self:replaced_vars(e.dict_key, vars)
+          local new_value = self:replaced_vars(e.dict_value, vars)
+          dirty = dirty or (new_key ~= e.dict_key or new_value ~= e.dict_value)
+          replacements[i] = {
+            dict_key = new_key,
+            dict_value = new_value
+          }
+        end
+        if dirty then
+          do
+            local _tbl_0 = { }
+            for k, v in pairs(tree) do
+              _tbl_0[k] = v
+            end
+            tree = _tbl_0
+          end
+          tree.value = replacements
+        end
       elseif nil == _exp_0 then
         local new_values = { }
         local any_different = false

nomsu.moon

@@ -491,6 +491,9 @@ end);]])\format(concat(buffer, "\n"))
                 else
                     return longbuff, false
 
+            when "Dict"
+                error("Sorry, not yet implemented.")
+
             when "Number"
                 return repr(tree.value), true
 
@@ -629,6 +632,26 @@ end)]])\format(concat(lua_bits, "\n"))
                     insert items, expr
                 return @@comma_separated_items("{", items, "}"), nil
 
+            when "Dict"
+                items = {}
+                for entry in *tree.value
+                    local key_expr,key_statement
+                    if entry.dict_key.type == "Word"
+                        key_expr,key_statement = repr(entry.dict_key.value),nil
+                    else
+                        key_expr,key_statement = @tree_to_lua entry.dict_key, filename
+                    if key_statement
+                        @error "Cannot use [[#{entry.dict_key.src}]] as a dict key, since it's not an expression."
+                    value_expr,value_statement = @tree_to_lua entry.dict_value, filename
+                    if value_statement
+                        @error "Cannot use [[#{entry.dict_value.src}]] as a dict value, since it's not an expression."
+                    key_str = key_expr\match([=[["']([a-zA-Z_][a-zA-Z0-9_]*)['"]]=])
+                    if key_str
+                        insert items, "#{key_str}=#{value_expr}"
+                    else
+                        insert items, "[#{key_expr}]=#{value_expr}"
+                return @@comma_separated_items("{", items, "}"), nil
+
             when "Number"
                 return repr(tree.value), nil
 
@@ -649,6 +672,10 @@ end)]])\format(concat(lua_bits, "\n"))
             when "List", "File", "Thunk", "FunctionCall", "String"
                 for v in *tree.value
                     @walk_tree(v, depth+1)
+            when "Dict"
+                for e in *tree.value
+                    @walk_tree(e.dict_key, depth+1)
+                    @walk_tree(e.dict_value, depth+1)
             else @walk_tree(tree.value, depth+1)
         return nil
 
@@ -697,6 +724,17 @@ end)]])\format(concat(lua_bits, "\n"))
                 if new_value != tree.value
                     tree = {k,v for k,v in pairs(tree)}
                     tree.value = new_value
+            when "Dict"
+                dirty = false
+                replacements = {}
+                for i,e in ipairs tree.value
+                    new_key = @replaced_vars e.dict_key, vars
+                    new_value = @replaced_vars e.dict_value, vars
+                    dirty or= new_key != e.dict_key or new_value != e.dict_value
+                    replacements[i] = {dict_key:new_key, dict_value:new_value}
+                if dirty
+                    tree = {k,v for k,v in pairs(tree)}
+                    tree.value = replacements
             when nil -- Raw table, probably from one of the .value of a multi-value tree (e.g. List)
                 new_values = {}
                 any_different = false

nomsu.peg

@@ -15,10 +15,10 @@ statement: functioncall / expression
 noeol_statement: noeol_functioncall / noeol_expression
 inline_statement: inline_functioncall / inline_expression
 
-inline_thunk (Thunk): {| "{" %ws* inline_statements %ws* "}" |}
+inline_thunk (Thunk): {| "(" %ws* ":" %ws* inline_statements %ws* ")" |}
 eol_thunk (Thunk): {| ":" %ws* noeol_statements eol |}
 indented_thunk (Thunk):
-    {| (":" / "{..}") indent
+    {| ":" indent
             statements (nodent statements)*
         (dedent / (("" -> "Error while parsing thunk") => error))
     |}
@@ -28,10 +28,10 @@ eol_nomsu (Nomsu): "\" noeol_expression
 indented_nomsu (Nomsu): "\" expression
 
 inline_expression:
-    number / variable / inline_string / inline_list / inline_nomsu
+    number / variable / inline_string / inline_list / inline_dict / inline_nomsu
     / inline_thunk / ("(" %ws* inline_statement %ws* ")")
 noeol_expression:
-    indented_string / indented_nomsu / indented_list / indented_thunk
+    indented_string / indented_nomsu / indented_list / indented_dict / indented_thunk
     / ("(..)" indent
         statement
     (dedent / (("" -> "Error while parsing indented expression") => error))
@@ -55,10 +55,13 @@ inline_string (String):
     |} '"'
 indented_string (String):
     '".."' %ws* line_comment? %nl %gt_nodented? {|
-        ({~ (("\\" -> "\") / (%nl+ {~ %gt_nodented -> "" ~}) / [^%nl\])+ ~} / string_interpolation)*
+        ({~
+            (("\\" -> "\") / (("\" eol %nl %gt_nodented "..") -> "")
+            / (%nl+ {~ %gt_nodented -> "" ~}) / [^%nl\])+
+        ~} / string_interpolation)*
     |} ((!.) / (&(%nl+ !%gt_nodented)) / (("" -> "Error while parsing String") => error))
-
+string_interpolation:
-string_interpolation: "\" ((noeol_expression dotdot?) / dotdot)
+    "\" (variable / inline_list / inline_dict / inline_thunk / ("(" %ws* inline_statement %ws* ")"))
 
 number (Number): (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / ([0-9]+)))-> tonumber)
 
@@ -78,6 +81,19 @@ list_line:
     / (functioncall / expression)
 inline_list_item: inline_functioncall / inline_expression
 
+inline_dict (Dict):
+    "{" %ws* {| (inline_dict_item (comma inline_dict_item)* comma?)? |} %ws* "}"
+indented_dict (Dict):
+    "{..}" indent {|
+        dict_line (nodent dict_line)*
+    |}
+    (dedent / (("" -> "Error while parsing dict") => error))
+dict_line:
+    (inline_dict_item (comma inline_dict_item)* (comma (functioncall / expression)?)?)
+    / {| {:dict_key: inline_expression / word :} %ws* "=" %ws* {:dict_value: functioncall / expression :} |}
+inline_dict_item:
+    {| {:dict_key: inline_expression / word :} %ws* "=" %ws* {:dict_value: inline_functioncall / inline_expression :} |}
+
 block_comment: "#.." [^%nl]* (%nl (%ws* &%nl))* %nl %indented [^%nl]+ (%nl ((%ws* ((!.) / &%nl)) / (!%dedented [^%nl]+)))*
 line_comment: "#" [^%nl]*