Initial commit. Note: this is broken right now.

main.lua

@@ -0,0 +1,166 @@
+require("interpret")
+
+local nelli_scope = Scope()
+local function B(abstract,callback)
+  nelli_scope:insert(
+    Binding(
+      interpret(abstract),
+      callback
+    )
+  )
+end 
+B("print (text)",function(s,e)
+  log(s:evaluate(e.text))
+end)
+B("text (literal)",function(s,e)
+  return e.literal:text()
+end)
+B("do (expressions)",function(s,e)
+  scope = Scope()
+  scope.parent = s
+  local res
+  print(e.expressions)
+  for item in iterate(e.expressions.items) do
+    if type_of(item) ~= Expression then 
+      error(
+        string.format(
+          "Unexpected words '%s' in 'do' expression.",
+          tostring(item)
+        )
+      )
+    end
+    res = scope:evaluate(item)
+  end
+  return res
+end)
+B("if (predicate) then (expression)",function(s,e)
+  if s:evaluate(e.predicate) then
+    return s:evaluate(e.expression)
+  end
+end)
+B("true",function(s,e) return true end)
+B("false",function(s,e) return false end)
+B("(constant) = (expression)",function(s,e)
+  local value = s:evaluate(e.expression)
+  s:insert(
+    Binding(e.constant:text(),function(s,e)
+      return value
+    end)
+  )
+end)
+B("format (string) with (terms)",function(s,e)
+  local items = {}
+  for expression in iterate(e.terms.items) do
+    table.insert(items,s:evaluate(expression))
+  end
+  return string.format(
+    s:evaluate(e.string),
+    table.unpack(items)
+  )
+end)
+B("while (predicate) (expression)",function(s,e)
+  while s:evaluate(e.predicate) do
+    s:evaluate(e.expression)
+  end
+end)
+B("repeat (expression) while (predicate)",function(s,e)
+  while true do
+    s:evaluate(e.expression)
+    if not s:evaluate(e.predicate) then
+      break
+    end
+  end
+end
+B("repeat (expression) until (predicate)",function(s,e)
+  while true do
+    s:evaluate(e.expression)
+    if s:evaluate(e.predicate) then
+      break
+    end
+  end
+end
+B("new table",function(s,e)
+  return {}
+end)
+B("(index) of (table)",function(s,e)
+  return s:evaluate(e.table)[s:evaluate(e.index)]
+end)
+B("set (index) of (table) to (item)",function(s,e)
+  s:evaluate(e.table)[s:evaluate(e.index)]
+end)
+B("macro (macro) expands to (expression)",function(s,e)
+  s:insert(Binding(e.abstract,function(_s,_e)
+    for identifier,expression in pairs(_e) do
+      
+    end
+    _s:evaluate(e.expression)
+  end)
+end)
+B("define (abstract) as (expression)",function(s,e)
+  s:insert(Binding(e.abstract,function(_s,_e)
+    return s:evaluate(e.expression)
+  end))
+end)
+local List = class("List")
+function List:new(...) do
+  self.items = {...}
+end
+B("new list",function(s,e)
+  return List()
+end)
+B("insert (item) into (list)",function(s,e)
+
+end)
+B("insert (item) into (list) at (index)",function(s,e)
+
+end)
+B("remove (needle) from (haystack)",function(s,e)
+
+end)
+B("remove from (haystack) at (index)",function(s,e)
+  s:evaluate(e.haystack)
+end)
+
+local Variable = class()
+function Variable:new()
+end
+function Variable:set(item)
+  self.data = item
+end
+function Variable:get()
+  return self.data
+end
+B("let (variable)",function(s,e)
+  local variable = Variable()
+  s:insert(
+    Binding(e.variable,function(s,e)
+      return variable
+    end)
+  )
+  return variable
+end)
+B("set (variable) to (expression)",function(s,e)
+  local var = s:evaluate(e.variable)
+  local value = s:evaluate(e.expression)
+  assert_meta(Variable)(var)
+  var:set(value)
+end)
+B("get (variable)",function(s,e)
+  local var = s:evaluate(e.variable)
+  assert_meta(Variable)(var)
+  return var:get(value)
+end)
+for item in iterate(nelli_scope.bindings) do
+  print(item.template)
+end
+
+local args = {...}
+local function main()
+  -- Take arguments as neli files to read and interpret
+  for _,parameter in pairs(args) do
+    local root = interpret(read(parameter))
+    nelli_scope:evaluate(root)
+  end
+end
+
+main()