Sync

Proto: meaning etc.
Renaming.
2026-03-29 11:46:50 +01:00 · 2026-03-08 18:59:45 +00:00 · 2026-03-03 14:22:18 +00:00 · 2026-02-27 19:05:01 +00:00 · 2026-02-27 16:46:43 +00:00 · 2026-02-22 17:51:11 +00:00
24 changed files with 501 additions and 1228 deletions
--- a/archive/nelli.lua
+++ b/archive/nelli.lua
@@ -1,327 +0,0 @@
 require("interpret")
 function B(scope,abstract,callback)
  scope:insert(
    Binding(
      interpret(abstract),
      callback
    )
  )
 end 
 function R(scope,expression,chain,name)
  name = name or "?"
  assert_meta(Expression)(expression,"Arg 'expression' #2: %s")
  assert_meta(Chain)(chain,"Arg 'chain' #3: %s")
  local chain = Chain(expression:link(name)):from(chain)
  return scope:run(expression,chain,scope)
 end
 NelliScope = Scope()
 local ns = NelliScope
 B(ns,"print (text)",function(s,e,c)
  log(R(s,e.text,c,"print: text"))
 end)
 B(ns,"text (literal)",function(s,e,c)
  return e.literal:text()
 end)
 -- Replace all :text() occurrences with ones in 'exp_map'
 local function substitute(target,exp_map)
  local text = target:text()
  if text then -- Replace the parameter
    local map = exp_map[text]
    if map then
      return Expression({map})
    else
      return target
    end
  else
    local new = Expression()
    for sub in iterate(target.items) do
      local t = type_of(sub)
      if t == "string" then
        new:insert(sub)
      elseif t == Expression then
        new:insert(substitute(sub,exp_map))
      end
    end
    return new
  end
 end
 -- Iterate over all :text() occurrences
 local function traverse(expression,callback)
  for sub in iterate(expression.items) do
    if type_of("sub") == Expression then
      traverse(sub,callback)
    else
      callback(sub)
    end
  end
 end
 local function Bmeans(s,e,c)
  local scope
  if e.scope then
    scope = R(s,e.scope,c,"means: using: scope: %s")
  end
  local bound = {}
  for sub in iterate(e.abstract.items) do
    local t = type_of(sub)
    if t == Expression then
      local text = sub:text()
      if not text:match("'.+'") then
        --[[error(string.format(
          "nel: Abstract parameter \"%s\" not in 'quotes'.",
          text
        ))]]
      else
        table.insert(bound,text)
      end
    end
  end
  return Binding(e.abstract,function(_s,_e,_c)
    local map = {}
    for binding in iterate(bound) do
      map[binding] = _e[binding]
    end
    local expanded = substitute(e.expression,map)
    return R(scope or _s,expanded,_c,"means: "..tostring(expanded))
  end)
 end
 B(ns,"(abstract) means (expression) using (scope)",Bmeans)
 local function Bdo(s,e,c)
  local scope
  if e.scope then
    scope = R(s,e.scope,c,"do: scope")
  else
    scope = Scope()
    scope.parent = s
  end
  local res
  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 = R(scope,item,c,"do: line")
  end
  return res
 end
 B(ns,"do (expressions)",Bdo)
 B(ns,"do (expression) in (scope)",function(s,e,c)
  local scope = R(s,e.scope,c,"do: scope")
  assert_meta(Scope)(scope,"nel: (do: scope): %s")
  R(scope,e.expression,c,"do: expression")
 end)
 B(ns,"error (text)",function(s,e,c)
  error("nel: "..R(s,e.text,c,"error: message"))
 end)
 B(ns,"if (predicate) then (expression)",function(s,e,c)
  if R(s,e.predicate,c,"if: predicate") then
    return R(s,e.expression,c,"if: result")
  end
 end)
 B(ns,"true",function(s,e,c) return true end)
 B(ns,"false",function(s,e,c) return false end)
 B(ns,"constant (constant) = (expression)",function(s,e,c)
  local value = R(s,e.expression,c,"constant: expression")
  e.constant:text()
  s:insert(
    Binding(e.constant,function(s,e,c)
      return value
    end)
  )
 end)
 B(ns,"format (string) with (terms)",function(s,e,c)
  local items = {}
  for expression in iterate(e.terms.items) do
    table.insert(items,R(s,expression),c,"format: term")
  end
  return string.format(
    R(s,e.string,c,"format: string"),
    table.unpack(items)
  )
 end)
 B(ns,"while (predicate) (expression)",function(s,e,c)
  while R(s,e.predicate,c,"while: predicate") do
    R(s,e.expression,c,"while: loop")
  end
 end)
 B(ns,"repeat (expression) while (predicate)",function(s,e,c)
  while true do
    R(s,e.expression,c,"repeat: expression")
    if not R(s,e.predicate,c,"repeat: predicate") then
      break
    end
  end
 end)
 B(ns,"repeat (expression) until (predicate)",function(s,e,c)
  while true do
    R(s,e.expression,c,"repeat: expression")
    if R(s,e.predicate,c,"repeat: predicate") then
      break
    end
  end
 end)
 B(ns,"new table",function(s,e,c)
  return {}
 end)
 B(ns,"(index) of (table)",function(s,e,c)
  return (R(s,e.table,"of: index"))[R(s,e.index,c,"of: table")]
 end)
 B(ns,"set (index) of (table) to (item)",function(s,e,c)
  R(s,e.table,c,"of-to: index")[R(s,e.index,c,"of-to: table")] = s:run(e.item,c,"of-to: item")
 end)
 B(ns,"remove (index) of (table)",function(s,e,c)
  (R(s,e.table,"remove: table"))[R(s,e.index,c,"remove: index")] = nil
 end)
 B(ns,"nothing",function(s,e,c)
  return nil
 end)
 --[[ Note
 A macro executes in the same scope of the callee.
 A defintion executes in the scope it was defined.
 I would argue that macros are more unpredictable!
 However, they allow for some very clean code.
 --]]
 B(ns,"here",function(s,e,c)
  return s
 end)
 B(ns,"return (object)",function(s,e,c)
  return R(s,e.object,c,"return: object")
 end)
 B(ns,"this scope",function(s,e,c)
  return s
 end)
 B(ns,"in scope (scope) (expressions)",function(s,e,c)
  return R(R(s,e.scope,c,"in scope: scope"),e.scope,c,"in scope: expression")
 end)
 local function Bdef(s,e,c)
  if e.scope then
    s = R(s,e.scope,c,"define: scope")
  end
  s:insert(Binding(e.abstract,function(_s,_e,_c)
    local scope = Scope()
    scope.parent = s
    for identifier,expression in pairs(_e) do
      scope:insert(
        Binding(
          Expression({identifier}),
          R(_s,expression,_c,string.format(
            "define: param: \"%s\"",
            identifier
          ))
        )
      )
    end
    return R(scope,e.expression,_c,string.format(
            "define: expression:\n\t\t%s\n\t",
            table.concat(c:flatten(),"\n\t")
          ))
  end))
 end
 B(ns,"define (abstract) as (expression)",Bdef)
 B(ns,"define (abstract) as (expression) in (scope)",Bdef)
 -- Create a constant binding
 B(ns,"(abstract) is (expression)",function(s,e,c)
  local result = R(s,e.expression,c,"be: expression")
  return Binding(e.abstract,result)
 end)
 -- Insert a binding into the current scope
 B(ns,"here (bindings)",function(s,e,c)
  for meaning in e.binding:iterate() do
    for sub in e.binding:iterate() do
      local t = type_of(sub)
      if t ~= Expression then
        print(t,getmetatable(t))
        error(string.format(
          "nel: (here: bindings): %s%s\n\t%s",
          "Expected subexpressions only got: ",
          tostring(sub),
          "Note: Are you using '{...}' style brackets?"
        ))
      else
        local bind = R(s,sub,c,"here: binding")
        assert_meta(Binding)(bind,"nel: (here: binding): %s")
        s:insert(bind)
      end
    end
  end
 end)
 -- Insert a binding into a scope
 B(ns,"in (scope) let (binding)",function(s,e,c)
  assert_meta(Binding)(e.binding,"nel: (here: binding): %s")
  assert_meta(Scope)(e.scope,"nel: (here: scope): %s")
  R(s,e.scope,c,"let: scope"):insert(R(s,e.binding,c,"let: binding"))
 end)
 B(ns,[[
 define (abstract)
 as (expression)
 in (scope)
 using (parameter_scope)
 ]],Bdef)
 local List = class("List")
 function List:new(...)
  self.items = {...}
 end
 B(ns,"new list",function(s,e,c)
  return List()
 end)
 B(ns,"insert (item) into (list)",function(s,e,c)
  table.insert(R(s,e.list).items,R(s,e.item),c,c)
 end)
 B(ns,"insert (item) into (list) at (index)",function(s,e,c)
  table.insert(s:evaulate(e.list).items,R(s,e.index),R(s,item),c,c)
 end)
 B(ns,"remove (needle) from (haystack)",function(s,e,c)
  local tab = R(s,e.haystack,c)
  table.remove(tab,table.find(tab,R(s,e.needle)),c)
 end)
 B(ns,"remove from (haystack) at (index)",function(s,e,c)
  table.remove(R(s,e.list),R(s,e.index),c,c)
 end)
 -- Create a scope parented to the current scope as an object
 B(ns,"new scope here",function(s,e,c)
  local scope = Scope
  scope.parent = s
  return scope 
 end)
 -- Create a scope with nothing in it as an object (weird)
 B(ns,"new scope",function(s,e,c)
  return Scope()
 end)
 -- Read a file in the current directly, more for compiling
 B(ns,"read (path)",function(s,e,c)
  return read(R(s,e.path,c,"read: path"))
 end)
 -- Take some text and interpret it into an expression
 B(ns,"include (text)",function(s,e,c)
  return R(s,interpret(R(s,e.text,c,"include: source")),c,"include: result")
 end)
 interpret([[
 here {
  (here ('name') is ('value'))
    means
  (here {
    ('name') is ('value')
  });
  (here ('abstract') means ('expression'))
    means
  (here {
    ('abstract') means ('expression')
  });
  (here ('abstract') means ('expression') using ('scope'))
    means
  (here {
    ('abstract') means ('expression')
  } using ('scope'))
 }
 ]])
 return ns
--- a/archive/note0.txt
+++ b/archive/note0.txt
@@ -1,13 +0,0 @@
 I am thinking for the syntax in nel.
 How can we have multiple arguments for something?
 It feels rather stupid allowing this really.
 It's not very clear, a list is a list in any case.
 So maybe we really should just have another
 substatement, and forget about powering up
 the abstracts, for now? ...?
 Well then... in that case.
 We only need to make sure scoping works.
 Which means, scopes inherit from eachother,
 and applying congruent bindings causes an error.
 I think.
--- a/archive/note1.txt
+++ b/archive/note1.txt
@@ -1,159 +0,0 @@
 taking expressions and parsing them later down?
 that seems slightly stupid.
 really, an expression is sort of a tree that
 hasn't been dealt with yet.
 is it really wise to keep passing them down as
 just that expression?
 otherwise it would have to be evaluated in the later
 scope.
 it makes more sense to sort of evaluate things
 as we go along.
 at the very least, every expression will always end
 up being 'something'.
 it just means that we need to execute different
 expressions in different contexts
 i guess.
 so 'meaning' becomes slightly more interesting here.
 i guess this would be where the macros fit.
 we could use a macro, which literally replaces
 a particular expression with another one, somehow, or
 maybe pass in some other sort of context to evaluate
 these things under. but that would evaluate everything
 that way.
 it would be nice if we could somehow refer to an
 expression as what it is expressed as, but also
 what it will be.
 i mean: let (render (elements)) mean (... do stuff ...)
 is great and all because i can now do:
 render (
  box()
 )
 but then how about
 let (view) mean (box())
 and then render(view)
 that clearly does not work, but absolutely should be
 valid nel code.
 with equal pertinence, on the other hand we have:
 let (sum) mean (math (5 + 2))
 where math ()...
 hold on. i think i know why this is actually confusing
 me. it also connects quite well with how source code
 works.
 'mean' means 'copy the expression in place'
 somehow preserving the scope.
 but
 'be' means 'the literal value we want'
 which is, definitely rather odd. very odd.
 how is each one useful in their own right?
 i think, my issue is that im really struggling
 to see the direct separation between what we have
 defined in nel and what the compiled bits should be!
 code {
  (number) means (int)
  let (x) is a (number)
  let (y) is a (number)
  let (sum) is a (number), is (x + y)
 }
 i mean its weird. very weird.
 since the 'let' bits should really be interpreted by
 the 'code' expression to represent some local variables
 in source code!
 but then the 'means' bit quite literally breaks that idea
 in two because that isn't source code at all it's just
 doing its own thing really.
 we ideally want 'means' to be available everywhere?
 are there any situations where it is bad?
 and again, what about macros?
 so maybe back to html as a weird example
 ui {
  box()
 }
 i think i get it now.
 when you use 'means' you are creating a new binding in
 the scope that forces NEL to create a 'value' which
 is more a wrapper (or even a trap!) that calls that
 particular expression again in the parent scope.
 this IS that macro, and i think it is quite deadly.
 which makes me wonder, is this a good idea to have
 around? well, i'm not sure!
 in a lot of cases, this is actually very nice, because
 we can literally just functionally expand our ENTIRE
 program out as we please without any function overhead.
 note that this is bad for maintainability and code bloat.
 we also still have the power of a general routine, so this
 isn't all doom and gloom really.
 how weird.
 i think i am sort of ok knowing this now, even though
 i am now very much more confused than even before.
 however, this turns out to be very nice.
 so:
 (doeth (code)) means (do (code))
 right, crap. effectively here that entire idea doesn't
 really hold water simply because i need the candid 
 expression to be able to execute the nellie effectively.
 that's not entirely great is it now.
 'means' and 'do' operations themselves work over abstract
 nel anyways. this sum foolery indeed.
 so effectively, abstract nel doesnt like abstract nel,
 yes yes yes that makes complete sense actually.
 because with doubly abstract nel we cannot just say
 (action) means (print (text (fart)))
 and then literally
 do {
  action;
  action;
  action;
 }
 or even worse have some sort of multiplicative expression.
 it's just not feasible you see!
 however, i now think i have a sort of idea.
 you see, with bindings, we can have values
 i have been thinking for a while and i am not sure if
 i can easily find some sort of solution to all of this.
 it's quite concerning really.
 do {}
 represents a list of expressions, how can we define this,
 just in pure NEL, to execute each statement.
 because, and i need to keep saying it, NEL should compile
 NEL, no?
 if EVERYTHING is written in NEL, then i surely should be
 allowed to write nel that can interpret expressions this
 way. it just feels incredibly stupid to not be able to.
 like what?
 all while being simple to understand. completely insane.
 COMPLETELY, insane.
 unless... just about unless.
 all expressions were functions.
 that promised to give back an expression.
 i realise now that my mind is very very weak.
 there is something missing from it. it's not about all the
 puzzles. it seems definition is trivial to everything.
 but this algorithm seems to me like a knot.
 its not a knot, i know there is a very clean solution,
 i just cant see it right now.
 i need to actually break things down into what i want first
 so i can see things as clearly as i possibly can
--- a/archive/note2.txt
+++ b/archive/note2.txt
@@ -1,19 +0,0 @@
 // My name is 'pal'
 /* Some sorcery for a query? */
 // There is an object which is me
 // There is an object 'pal' (how pronounce?)
 // I guess a 'written as' branch
 /* Notes:
 Queries can create queries (are they called 'queries'?)
 They specify a general scenario.
 Can they have constants? Are those constants branches?
 */
 // wtf ^
 /* From DMLR
 there was self referencing logic.
 quantifiers over general objects
 */
--- a/interpret.lua
+++ b/interpret.lua
@@ -1,196 +0,0 @@
 require("parse")
 -- TODO: This should really be a separate API and module
 -- please break it out
 -- Interpret some text
 function interpret(content,uri,chain)
  -- LOCALS
  -- The pattern for words inbetween expressions
  local expressionWordPattern = "(.*)"
  -- The patterns to open and close expressions,
  -- the words scattered inbetween them will be matches 
  local expressionOpenPattern = "%("
  local expressionClosePattern = "%)"
  local subExpressionOpenPattern = "%:"
  local subExpressionClosePattern = "%,"
  local blockOpenPattern = "%{"
  local blockClosePattern = "%}"
  local blockDelimiterPattern = "[;]+"
  -- So that all functions have access to eachother
  local consume,
        consumeExpression,
        processWords,
        processClosure,
        processOpening,
        consumeBlock,
        consumeText,
        consumeNumber
  local consumer = Consumer(content)
  local function expression(...)
    return Expression(...):locate(
      string.format(
        "%i:%i",
        consumer.row,
        consumer.col
      ),uri)
  end
  local baseExpression = expression()
  -- FUNCTIONS
  -- Consume an expression, with its sub expressions
  -- given that an opening has just been consumed
  local singleLineStringPattern = "\""
  local function singleLineStringMeal(current,match)
    return function(words,_)
      current:insert(words,consumer:consume({
        [match] = function(words,_)
          return expression({"text",Expression({words})})
        end
      }))
    end
  end
  local multiLineStringOpenPattern = "%[%["
  local multiLineStringClosePattern = "%]%]"
  local function multiLineStringMeal(current,match)
    return function(words,_)
      current:insert(words,consumer:consume({
        ["[\n\r]"] = function()
          error("Incomplete string literal")
        end,
        [match] = function(words,_)
          return expression({"text",Expression({words})})
        end
      }))
    end
  end
  local uriOpenPattern = "<"
  local uriClosePattern = ">"
  local function URIMeal(current,match)
    return function(words,_)
      current:insert(words,consumer:consume({
        ["[\n\r]"] = function()
          current:error("Incomplete URI literal")
        end,
        [match] = function(path)
          return read(path)
        end
      }))
    end
  end
  local function expressionMeal(current)
    return function(words,_) 
      current:insert(words,consumeExpression())
    end
  end
  local singleLineCommentPattern = "//"
  local function singleLineCommentMeal(current)
    return function(words,_)
      current:insert(words) -- Consume what was left
      consumer:consume({
        ["[\n\r]"] = function() end
      })
    end
  end
  local multiLineCommentPattern = "/%*"
  local function multiLineCommentMeal(current)
    return function(words,_) -- consume what was left
      current:insert(words)
      consumer:consume({
        ["%*/"] = function() end
      })
    end
  end
  local colonSyntaxPattern = ":"
  local function colonSyntaxMeal(current)
    return function(words,_)
      current:insert(words,consumeColonExpression())
    end
  end
  function consumeBlock()
    local expressions = {}
    local current = expression()
    local loop = true
    while loop do
      local expr = consumer:consume({
        [multiLineCommentPattern] = multiLineCommentMeal(current),
        [singleLineCommentPattern] = singleLineCommentMeal(current),
        [uriOpenPattern] = URIMeal(current,uriClosePattern),
        [expressionOpenPattern] = expressionMeal(current),
        [multiLineStringOpenPattern] = 
          multiLineStringMeal(
            current,multiLineStringClosePattern),
        [singleLineStringPattern] = 
          singleLineStringMeal(
            current,singleLineStringPattern),
        [blockDelimiterPattern] = function(words,_)
          current:insert(words)
          if current:empty() then
            --error("Extravenous semicolon.")
          else
            table.insert(expressions,current)
          end
          current = expression()
        end,
        [blockClosePattern] = function(words,_)
          current:insert(words)
          loop = false
        end,
        [blockOpenPattern] = function(words,_)
          current:insert(
            words,
            consumeBlock()
          )
        end,
      })
    end
    if #current.items ~= 0 then
      table.insert(expressions,current)
    end
    return expression(expressions)
  end
  function consumeExpression()
    local current = expression()
    -- Loop, adding new expressions and words,
    -- until closing that is
    local loop = true
    while loop do
      local remaining = consumer:remaining()
      local expr = consumer:consume({
        [multiLineCommentPattern] = multiLineCommentMeal(current),
        [singleLineCommentPattern] = singleLineCommentMeal(current),
        [uriOpenPattern] = URIMeal(current,uriClosePattern),
        [expressionOpenPattern] = expressionMeal(current),
        [multiLineStringOpenPattern] = 
          multiLineStringMeal(
            current,multiLineStringClosePattern),
        [singleLineStringPattern] = 
          singleLineStringMeal(
            current,singleLineStringPattern),
        [expressionOpenPattern] = expressionMeal(current),
        [expressionClosePattern] = function(words,_)
          current:insert(words)
          loop = false
        end,
        [blockOpenPattern] = function(words,_)
          current:insert(
            words,
            consumeBlock()
          )
        end,
        ["$"] = function(words,last)
          current:insert(remaining)
          loop = false
        end
      })
      -- This single line below made me procrastinate life for a total of 4 hours on instagram reels; lock in.
      -- if not expr then print("brk") break end -- Since now closing
    end
    return current
  end
  return consumeExpression()
  -- TODO: check for later expressions please?
 end
 return _G
--- a/nel/helper.nel
+++ b/nel/helper.nel
@@ -1,23 +0,0 @@
 do {
  let {
    ( here (abstract) expands to (expression) )
      expands to
    ( let { (abstract) expands to (expression) } in (this scope) );
    (here (abstract) evaluates to (expression))
      expands to
    (let {(abstract) evaluates to (expression)} in (this scope));
    ( here (abstract) is equal to (expression) )
      expands to
    ( let {(abstract) is equal to (expression)} in (this scope) );
    (module (the path))
      expands to
    (do {
      here (the scope) is (a new scope);
      evaluate (read file (the path)) in (the scope);
      return (the scope);
    });
  };
 }
--- a/nel/lc.nel
+++ b/nel/lc.nel
@@ -1,14 +0,0 @@
 do {
  // Scope for the language that we will write in NEL
  here (I scope) is (new scope); // I -> NEL Intermediate Code
  // Compile (...) should return the compiled text
  here (compile ('code')) 
    expands to 
  (do {'code'} in (I scope));
  // Definitions for things in the I scope
  let {
  } in (I scope)
 }
--- a/nel/translator/cxx.nel
+++ b/nel/translator/cxx.nel
@@ -1,3 +0,0 @@
 do {
 } in ((module ("nel/translator/main.nel"))
--- a/nel/translator/main.nel
+++ b/nel/translator/main.nel
@@ -1,14 +0,0 @@
 do {
  here (lang scope) is (new scope);
  let {
    here ( call (identifier) (values) ) evaluates to ( 
      here (source) is 
    )
    here ( text (literal) ) evaluates to ( text (literal) )
    here ( print (values) ) expands to ( call (print) (values) )
  } in (lang scope)
  here (compile (code))
    expands to
  (do (code) in (lang scope));
 }
--- a/nel/ui.nel
+++ b/nel/ui.nel
@@ -1,6 +0,0 @@
 do {
  here ((fart) means (print "fart"));
  fart;
  fart;
  fart;
 }
--- a/nellie/helper.lua
+++ b/nellie/helper.lua
@@ -27,8 +27,15 @@ end
 id = function(...) return ... end
 function union(t0,t1)
-  for index,item in pairs(t0) do
+  for index,item in pairs(t1) do
-    t0[index] = t1
+    t0[index] = t1[index]
  end
  return t0
 end
 function union_all(t0,...)
  for _,t1 in pairs({...}) do
    union(t0,t1)
  end
  return t0
 end
@@ -59,6 +66,12 @@ function indices(t)
  return indices
 end
 function map(t,func)
  for index,item in pairs(t) do
    t[index] = func(index,item)
  end
 end
 -- Ensures a table has a metatable
 function ensure_metatable(t)
  local meta = getmetatable(t)
@@ -193,7 +206,7 @@ function read(path)
  local file = io.open(path)
  if not file then
    error(
-      string.match("Could not open file '%s'.",path),3
+      string.format("Could not open file '%s'.",path),3
    )
  end
  local content = file:read("a")
--- a/nellie/helper.nel
+++ b/nellie/helper.nel
@@ -0,0 +1,8 @@
 // single line comment
 log "a";
 /* 
 multi 
 line 
 comment
 */
 log "b";
--- a/nellie/init.lua
+++ b/nellie/init.lua
@@ -1,27 +1,27 @@
-require("nelli")
+local path = ...
 require("nellie.proto")
-local function main(args)
+function Run(...)
  -- Take arguments as neli files to read and interpret
  local root = Chain(
    string.format(
      "in cmd 'nelli {%s}'",
-      table.concat(args,";")
+      table.concat({...},";")
    )
  )
-  for _,parameter in pairs(args) do
+  for _,parameter in pairs({...}) do
    local chain = Chain(
      string.format("in 'call: root' @'%s'",parameter)
    ):from(root)
    root:call(function()
-      local root = interpret(
+      local root = Parse(
        read(parameter),
        parameter,
        chain
      )
-      NelliScope:run(root,chain)
+      for _,expression in pairs(root.items) do
        NelliScope:run(expression,Chain(expression:link("root: do")):from(chain))
      end
    end)
  end
 end
 -- A list of arguments passed into this
 main({...})
--- a/nellie/interpreter.lua
+++ b/nellie/interpreter.lua
@@ -1,59 +1,6 @@
-require("helper")
+require("nellie.helper")
 -- CLASS DEFINITIONS
 -- A stream of text (kind of)
 -- with some helping methods
 Reader = class("Reader")
 -- Construct a reader from
 function Reader:new(text)
  assert_type("string")(text,"Arg 'text' #1: %s")
  self.text = text
 end
 -- Get the substring of the readers text in a bounds
 function Reader:get(first,final)
  assert_type("number")(first,"Arg 'first' #1: %s")
  assert_type("number","nil")(final,"Arg 'final' #2: %s")
  return self.text:sub(first,final)
 end
 -- Match on the reader's text from an index
 function Reader:find(pattern,init)
  assert_type("string")(pattern,"Arg 'pattern' #1: %s")
  assert_type("number","nil")(init,"Arg 'init' #2: %s")
  return self.text:find(pattern,init)
 end
 function Reader:match(pattern,init)
  assert_type("string")(pattern,"Arg 'pattern' #1: %s")
  assert_type("number")(init,"Arg 'init' #2: %s")
  return self.text:match(pattern,init)
 end
 -- A range of text being considered
 -- like a cursor
 Range = class("Range")
 -- Construct a range of text from a reader and bounds
 function Range:new(reader,first,final)
  assert_meta(Reader)(reader)
  assert_type("number","nil")(first,"Arg 'first' #1: %s")
  assert_type("number","nil")(final,"Arg 'final' #2: %s")
  self.reader = reader
  self.first = first
  self.final = final
 end
 function Range:text()
  return self.reader:get(self.first or 1,self.final)
 end
 function Range:find(pattern)
  return self.reader:find(pattern,self.first)
 end
 function Range:move(first,final)
  assert_type("number","nil")(first,"Arg 'first' #1: %s")
  assert_type("number","nil")(final,"Arg 'final' #2: %s")
  self.first = first
  self.final = final
  -- note that this function returns itself
  return self
 end
 Expression = class("Expression")
 -- Construct an expression from items (or not)
 function Expression:new(items)
@@ -191,76 +138,6 @@ function Expression:link(msg)
  )
 end
 --[[
 A class which parses text using the 'consumer-meal'
 model.
 ]]
 Consumer = class("Consumer")
 function Consumer:new(content)
  self.range = Range(Reader(content))
  self.col = 1
  self.row = 1
 end
 function Consumer:remaining()
  return self.range:text()
 end
 function Consumer:mark()
 end
 -- From a table of actions of patterns,
 -- consume the earliest pattern (index)
 -- and call the value
 function Consumer:consume(t)
  -- t: {string = function...}
  assert_type("table")(t,"Arg 't' #1: %s")
  if not next(t) then 
    error("The match table cannot be empty!",2)
  end
  for index,func in pairs(t) do
    assert_type("string")(index,"Bad 't' index: %s")
    assert_type("function")(func,"Bad 't' item: %s")
  end
  local origin = self.range.first or 1
  -- Get the next earliest match
  local findex,ffinal,fpattern,ffunc,fexcess
  for pattern,new_func in pairs(t) do
    local new_index,new_final = self.range:find(pattern)
    if new_index and 
      ((not findex) or (findex > new_index))
    then
      if not new_index then return end
      findex = new_index
      ffinal = new_final
      fpattern = pattern
      ffunc = new_func
      fexcess = self.range.reader:get(
        self.range.first or 1,
        new_final - 1
      )
    end
  end
  -- Pass into the func
  if not ffunc then 
    return nil
  end
  assert(findex) assert(ffinal)
  self.range:move(ffinal+1) -- Move range to after the match
  local fmatch = self.range.reader:match(fpattern,findex)
  -- Pass back consumed result to
  local sum = self.range.reader:get(origin+1,self.range.first)
    :gsub("\r\n","\n")
    :gsub("\r","\n")
  for char in sum:gmatch(".") do
    if char == "\n" then 
      self.row = self.row + 1
      self.col = 1
    else
      self.col = self.col + 1
    end
  end
  return ffunc(fexcess,fmatch)
 end
 Binding = class("Binding")
 -- Construct from a neli string to infer a binding
 -- note that you must wrap this definition in "(<def>)"!
@@ -362,6 +239,7 @@ function Chain:pcall(func)
  local success,result = xpcall(func,function(msg)
    -- If this is a 'nel:' error, strip the line responsible
    -- Otherwise just return the whole traceback since something went really bad
    if not msg then msg = "no message provided" end
    local match = msg:match("nel:%s(.*)")
    if match then
      return match
@@ -376,7 +254,7 @@ function Chain:pcall(func)
      table.concat(self:flatten(),"\n\t")
    ))
  end
-  return successs,result
+  return success,result
 end
 function Chain:call(func)
  local success,result = self:pcall(func)
@@ -400,7 +278,13 @@ function Scope:insert(binding)
  assert_meta(Binding)(binding,"Arg 'binding' #1: %s")
  for competitor in iterate(self.bindings) do
    if competitor:check(binding.template) then
-      error(string.format("nel: Conflicting sibling bindings in scope for '%s'.",binding.template))
+      error(
        string.format(
          "nel: Conflicting sibling binding in scope for '%s': '%s'.",
          binding.template,
          competitor.template
        )
      )
    end
  end
  table.insert(self.bindings,binding)
@@ -455,9 +339,7 @@ function Scope:run(expression,chain,original)
      )
    ,2)
  else
-    for index,item in pairs(binds) do
+    if not binding then error("No binding") end -- todo: improve error
      print("index:",index,"item:",item)
    end
    return binding:call(
      original,
      bind,
@@ -465,4 +347,3 @@ function Scope:run(expression,chain,original)
    )
  end  
 end
 return _G
--- a/nellie/parser.lua
+++ b/nellie/parser.lua
@@ -0,0 +1,336 @@
 require("nellie.interpreter")
 -- A stream of text (kind of)
 -- with some helping methods
 Reader = class("Reader")
 -- Construct a reader from
 function Reader:new(text)
  assert_type("string")(text,"Arg 'text' #1: %s")
  self.text = text
 end
 -- Get the substring of the readers text in a bounds
 function Reader:get(first,final)
  assert_type("number")(first,"Arg 'first' #1: %s")
  assert_type("number","nil")(final,"Arg 'final' #2: %s")
  return self.text:sub(first,final)
 end
 -- Match on the reader's text from an index
 function Reader:find(pattern,init)
  assert_type("string")(pattern,"Arg 'pattern' #1: %s")
  assert_type("number","nil")(init,"Arg 'init' #2: %s")
  return self.text:find(pattern,init)
 end
 function Reader:match(pattern,init)
  assert_type("string")(pattern,"Arg 'pattern' #1: %s")
  assert_type("number")(init,"Arg 'init' #2: %s")
  return self.text:match(pattern,init)
 end
 -- A range of text being considered
 -- like a cursor
 Range = class("Range")
 -- Construct a range of text from a reader and bounds
 function Range:new(reader,first,final)
  assert_meta(Reader)(reader)
  assert_type("number","nil")(first,"Arg 'first' #1: %s")
  assert_type("number","nil")(final,"Arg 'final' #2: %s")
  self.reader = reader
  self.first = first
  self.final = final
 end
 function Range:text()
  return self.reader:get(self.first or 1,self.final)
 end
 function Range:find(pattern)
  return self.reader:find(pattern,self.first)
 end
 function Range:move(first,final)
  assert_type("number","nil")(first,"Arg 'first' #1: %s")
  assert_type("number","nil")(final,"Arg 'final' #2: %s")
  self.first = first
  self.final = final
  -- note that this function returns itself
  return self
 end
 --[[
 A class which parses text using the 'consumer-meal'
 model.
 ]]
 Consumer = class("Consumer")
 function Consumer:new(content)
  self.range = Range(Reader(content))
  self.col = 1
  self.row = 1
 end
 function Consumer:remaining()
  return self.range:text()
 end
 function Consumer:mark()
 end
 -- From a table of actions of patterns,
 -- consume the earliest pattern (index)
 -- and call the value
 local NONE = {}
 function Consumer:consumePatterns(patterns,state)
  -- t: {string = function...}
  assert_type("table")(patterns,"Arg 't' #1: %s")
  if not next(patterns) then 
    error("The match table cannot be empty!",2)
  end
  for index,func in pairs(patterns) do
    assert_type("string")(index,"Bad 't' index: %s")
    assert_type("function")(func,"Bad 't' item: %s")
  end
  local origin = self.range.first or 1
  -- Get the next earliest match
  local callback = nil
  local earliest = {}
  --local findex,ffinal,fpattern,ffunc,fexcess -- TODO: make this not be a bunch of locals. New class?
  for pattern,new_func in pairs(patterns) do
    local new_index,new_final = self.range:find(pattern)
    if new_index and 
      ((not earliest.index) or (earliest.index > new_index))
    then
      if not new_index then return end -- (later:) what why?
      earliest.index = new_index
      earliest.final = new_final
      earliest.pattern = pattern
      callback = new_func
      earliest.excess = self.range.reader:get(
        self.range.first or 1,
        earliest.index - 1
      )
    end
  end
  -- Pass into the func
  if not callback then
    if patterns[NONE] then
      return patterns[NONE]()
    end
    return nil
  end
  assert(earliest.index) assert(earliest.final)
  self.range:move(earliest.final+1) -- Move range to after the match
  local fmatch = self.range.reader:match(earliest.pattern,earliest.final)
  -- This seems to be broken:
  local sum = self.range.reader:get(origin+1,self.range.first)
    :gsub("\r\n","\n")
    :gsub("\r","\n")
  for char in sum:gmatch(".") do
    if char == "\n" then 
      self.row = self.row + 1
      self.col = 1
    else
      self.col = self.col + 1
    end
  end
  return callback(earliest,state)
 end
 -- Interpret some text
 function Parse(content,uri,chain)
  -- LOCALS
  -- So that all functions have access to eachother
  local consume,
        consumeExpression,
        consumeBlock
  local consumer = Consumer(content)
  local function expression(...)
    return Expression(...):locate(
      string.format(
        "%i:%i",
        consumer.row,
        consumer.col
      ),uri)
  end
  local baseExpression = expression()
  local patterns = {}
  patterns.contentClose = "$"
  -- The pattern for words inbetween expressions
  patterns.expressionWord = "(.*)"
  -- The patterns to open and close expressions,
  -- the words scattered inbetween them will be matches 
  patterns.expressionOpen = "%("
  patterns.expressionClose = "%)"
  patterns.subExpressionOpen = "%:"
  patterns.subExpressionClose = "%,"
  patterns.blockOpen = "%{"
  patterns.blockClose = "%}"
  patterns.blockDelimiter = "[;]+"
  patterns.newLine = "[\n\r]+"
  patterns.singleLineString = "\""
  patterns.named = "'"
  patterns.multiLineStringOpen = "%[%["
  patterns.multiLineStringClose = "%]%]"
  patterns.uriOpen = "<"
  patterns.uriClose = ">"
  patterns.singleLineComment = "//"
  patterns.multiLineCommentOpen = "/%*"
  patterns.multiLineCommentClose = "%*/"
  patterns.colonSyntax = ":"
  -- Give me: {patterns that take (match,state)}, the state, and a handler for comments
  -- I will give you a function that will return the result of consumePatterns(patterns)
  -- With escapes handled.
  local function makeConsumerEscaping(patterns,state,handler)
    return function()
      handler = handler or function() end
      local escaped = true
      local function escape() escaped = true end
      while escaped do
        escaped = false
        consumer:consumePatterns(union({
          [patterns.singleLineComment] = function(...)
            handler(...)
            consumer:consumePatterns({
              [patterns.newLine] = escape
            })
          end,
          [patterns.multiLineCommentOpen] = function(...)
            handler(...)
            consumer:consumePatterns({
              [NONE] = error,
              [patterns.multiLineCommentClose] = escape
            })
          end,
        },patterns),state)
      end
    end
  end
  -- Give me {patterns that take (match,current)} and current (expression) 
  local function makeConsumerAppending(patterns,state)
    local appendingPatterns = map(patterns,function(func)
      return function(match,current) 
        current:insert(match.excess,func(match,current))
      end
    end)
    makeConsumerEscaping(appendingPatterns,function(match,current) 
      current:insert(match.excess) 
    end)
  end
  local function makeConsumerExpressive()
    local function consumeSingleLineString()
      return
    end
    local function consumeNamed()
    end
    local function consumeMultiLineString()
    end
    local function consumeURI()
    end
    return makeConsumerAppending({
      [patterns.singleLineString] = function(match,current)
        return consumer:consumePatterns({
          ["[\n\r]"] = function()
            error("Incomplete string literal")
          end,
          [patterns.singleLineString] = function(words,_)
            return expression({"text",Expression({words})})
          end
        })
      end,
      [patterns.named] = function(words,_,current)
        current:insert(words,consumePatternsEscaping({
          [patterns.named] = function(words,_)
            return expression({"the",Expression({words})})
          end
        }))
      end,
      [patterns.multiLineStringOpen] = function(match,current)
        return consumer:consumePatterns({
          [patterns.multiLineStringClose] = function(words,_)
            return expression({"text",Expression({words})})
          end
        })
      end,
      [patterns.multiLineStringOpen] = function(words,_,current)
        current:insert(words,consumePatternsEscaping({
          [patterns.multiLineStringClose] = function(words,_)
            return expression({"text",Expression({words})})
          end
        }))
      end,
      [patterns.uriOpen] = function(words,_,current)
        current:insert()
        current:insert(words,consumePatternsEscaping({
          ["[\n\r]"] = function()
            current:error("Incomplete URI literal")
          end,
          [patterns.uriClose] = function(path)
            return read(path)
          end
        }))
      end,
      [patterns.expressionOpen] = function(match,current)
        return consumeExpression()
      end,
      [patterns.colonSyntax] = function(match,current)
        return consumeExpression()
      end,
      [patterns.blockOpen] = function(match,current)
        return consumeBlock()
      end,
    })
  end
  local function consumePatternsExpressive(patterns,current)
    return consumePatternsEscaping
  end
  -- Consume a {} block of code
  function consumeBlock(closing_pattern)
    closing_pattern = closing_pattern or patterns.blockClose
    local expressions = {}
    local current = expression()
    local loop = true
    while loop do
      local remaining = consumer:remaining()
      local expr = consumePatternsEscaping(union(expressionMeals,{
        [patterns.blockDelimiter] = function(words,_)
          current:insert(words)
          if current:empty() then
            --error("Extravenous semicolon.")
          else
            table.insert(expressions,current)
          end
          current = expression()
        end,
        [closing_pattern] = function(words,_)
          current:insert(words)
          loop = false
        end,
      }),current)
    end
    if #current.items ~= 0 then
      table.insert(expressions,current)
    end
    return expression(expressions)
  end
  function consumeExpression()
    local current = expression()
    -- Loop, adding new expressions and words,
    -- until closing that is
    local loop = true
    while loop do
      local remaining = consumer:remaining()
      local expr = consumePatternsEscaping(union(expressionMeals,{
        [patterns.expressionClose] = function(words,_,_current)
          current:insert(words)
          loop = false
        end
      }),current)
      -- This single line below made me procrastinate life for a total of 4 hours on instagram reels; lock in.
      -- if not expr then print("brk") break end -- Since now closing
    end
    return current
  end
  return consumeBlock(patterns.contentClose)
  -- TODO: check for later expressions please?
 end
--- a/nellie/proto.lua
+++ b/nellie/proto.lua
@@ -1,14 +1,16 @@
-require("interpret")
+-- Prototype for nel
 require("nellie.parser")
-function B(scope,abstract,callback)
+function Bind(scope,abstract,callback)
-  scope:insert(
+  for _,expression in pairs(Parse(abstract).items) do
-    Binding(
+    assert_meta(Expression)(expression)
-      interpret(abstract),
+    scope:insert(Binding(
      expression,
      callback
-    )
+    ))
-  )
+  end
 end
-function R(scope,expression,chain,name)
+function Run(scope,expression,chain,name)
  name = name or "?"
  assert_meta(Chain)(chain,"Arg 'chain' #3: %s")
  assert_meta(Scope)(scope,"Arg 'scope' #1: %s")
@@ -16,9 +18,17 @@ function R(scope,expression,chain,name)
  local chain = Chain(expression:link(name)):from(chain)
  return scope:run(expression,chain)
 end
 function Do(scope,expression,chain,name)
  local latest
  for index,item in pairs(expression.items) do
    latest = Run(scope,item,chain,"do: "..tostring(index))
  end
  return latest
 end
 NelliScope = Scope()
 local ns = NelliScope
 --[[
 -- Replace all :text() occurrences with ones in 'exp_map'
 local function substitute(target,exp_map)
  local text = target:text()
@@ -64,7 +74,7 @@ local function Bexpands(s,e,c)
        --[[error(string.format(
          "nel: Abstract parameter \"%s\" not in 'quotes'.",
          text
-        ))]]
+        ))]]--[[
      else
        table.insert(bound,text)
      end
@@ -76,10 +86,10 @@ local function Bexpands(s,e,c)
      map[binding] = _e[binding]
    end
    local expanded = substitute(e.expression,map)
-    return R(_s,expanded,_c,"means: "..tostring(expanded))
+    return Run(_s,expanded,_c,"means: "..tostring(expanded))
  end)
-end
+end]]
-B(ns,"(abstract) means (expression)",Bexpands)
+--[[Bind(ns,"(abstract) means (expression)",Bexpands)
 local function Bevaluate(s,e,c)
  return Binding(e.abstract,function(_s,_e,_c)
    local scope = Scope()
@@ -87,18 +97,18 @@ local function Bevaluate(s,e,c)
    for name,expression in pairs(_e.items) do
      scope:insert(Binding(
        Expression({name}),
-        R(_s,_e,_c,string.format("expands: %s:",name))
+        Run(_s,_e,_c,string.format("expands: %s:",name))
      ))
    end
-    return R(scope,e,c,"evaluate: result")
+    return Run(scope,e,c,"evaluate: result")
  end)
 end
-B(ns,"(abstract) becomes (expression)",Bevaluates)
+Bind(ns,"(abstract) becomes (expression)",Bevaluates)
-B(ns,"(identifier) is (expression)",function(s,e,c)
+Bind(ns,"(identifier) is (expression)",function(s,e,c)
  if not e.identifier:text(s,e,c) then 
    error("nel: text-only expression expected.")
  end
-  return Binding(e.identifier,R())
+  return Binding(e.identifier,Run())
 end)
 local function doAll(s,e,c)
  local res
@@ -111,7 +121,7 @@ local function doAll(s,e,c)
        )
      )
    end
-    res = R(s,item,c,"do: line")
+    res = Run(s,item,c,"do: line")
  end
  return res
 end
@@ -120,16 +130,16 @@ end
 local function Bdo(s,e,c)
  local scope
  if e.scope then
-    scope = R(s,e.scope,c,"do: scope")
+    scope = Run(s,e.scope,c,"do: scope")
  else
    scope = Scope()
    scope.parent = s
  end
  return doAll(s,e.expression,c)
 end
-B(ns,"do (expression) in (scope)",Bdo)
+Bind(ns,"do (expression) in (scope)",Bdo)
-B(ns,"do (expression)",Bdo)
+Bind(ns,"do (expression)",Bdo)
-B(ns,"(abstract) broken into (expressions) as do (results)",function(s,e,c)
+Bind(ns,"(abstract) broken into (expressions) as do (results)",function(s,e,c)
  return Binding(e.abstract,function(_s,_e,_c)
    local params = List()
    for index,item in pairs(_e) do
@@ -157,10 +167,10 @@ local _list = {}
 local function List()
  return setmetatable(_list,{})
 end
-B(ns,"a new list",function(s,e,c)
+Bind(ns,"a new list",function(s,e,c)
  return List()
 end)
-B(ns,"for each (item) in (list) do (expressions)",function(s,e,c)
+Bind(ns,"for each (item) in (list) do (expressions)",function(s,e,c)
  local item = e.item:text()
  if not property then 
    error(
@@ -170,7 +180,7 @@ B(ns,"for each (item) in (list) do (expressions)",function(s,e,c)
      )
    ) 
  end
-  local list = R(s,e.list,c,"for each: list")
+  local list = Run(s,e.list,c,"for each: list")
  assert_meta(List)(list,"for each: list: %s")
  for index,item in ipairs(list) do
    local scope = Scope()
@@ -179,40 +189,40 @@ B(ns,"for each (item) in (list) do (expressions)",function(s,e,c)
    doAll(s,e.expressions,c)
  end
 end)
-B(ns,"add (item) to (list)",function(s,e,c)
+Bind(ns,"add (item) to (list)",function(s,e,c)
-  local item = R(s,e.list,c,"")
+  local item = Run(s,e.list,c,"")
-  local list = R(s,e.list,c,"add: list")
+  local list = Run(s,e.list,c,"add: list")
  assert_meta(List)(list,"add: list: %s")
  table.insert(list,item)
 end)
 -- I even quite dislike these, they are prone to gumming things up
 local _table = {}
-B(ns,"a new table",function(s,e,c) return {} end)
+Bind(ns,"a new table",function(s,e,c) return {} end)
-B(ns,"set (index) of (table) to (value)",function(s,e,c)
+Bind(ns,"set (index) of (table) to (value)",function(s,e,c)
  local index = e.index:text()
  if not index then 
-    index = R(s,e.index,c,"set: index")
+    index = Run(s,e.index,c,"set: index")
  end
-  local tab = R(s,e.table,c,"set: table")
+  local tab = Run(s,e.table,c,"set: table")
-  local val = R(s,e.value,c,"set: value")
+  local val = Run(s,e.value,c,"set: value")
  tab[index] = val
 end)
-B(ns,"get (index) of (table)",function(s,e,c)
+Bind(ns,"get (index) of (table)",function(s,e,c)
  local index = e.index:text()
  if not index then
-    index = R(s,e.index,c,"get: index")
+    index = Run(s,e.index,c,"get: index")
  end
-  local tab = R(s,e.table,c,"get: table")
+  local tab = Run(s,e.table,c,"get: table")
  return tab[index]
 end)
 local _object = {}
 local function Object()
  return setmetatable(_object,{})
 end
-B(ns,"a new object",function(s,e,c)
+Bind(ns,"a new object",function(s,e,c)
  return Object()
 end)
-B(ns,"(property) of (object) is (value)",function(s,e,c)
+Bind(ns,"(property) of (object) is (value)",function(s,e,c)
  local property = e.property:text()
  if not property then 
    error(
@@ -222,12 +232,12 @@ B(ns,"(property) of (object) is (value)",function(s,e,c)
      )
    ) 
  end
-  local object = R(s,e.object,c,"property is: object")
+  local object = Run(s,e.object,c,"property is: object")
  assert_meta(Object)(object,"nel: property is: object: %s")
-  local value = R(s,e.value,c,"property is: value")
+  local value = Run(s,e.value,c,"property is: value")
  object[property] = value
 end)
-B(ns,"(property) of (object)",function(s,e,c)
+Bind(ns,"(property) of (object)",function(s,e,c)
  local property = e.property:text()
  if not property then 
    error(
@@ -237,58 +247,77 @@ B(ns,"(property) of (object)",function(s,e,c)
      )
    ) 
  end
-  local object = R(s,e.object,c,"property is: object")
+  local object = Run(s,e.object,c,"property is: object")
  assert_meta(Object)(object,"nel: property is: object: %s")
  return object[property]
 end)
-B(ns,"error (text)",function(s,e,c)
+Bind(ns,"error (text)",function(s,e,c)
-  error("nel: "..R(s,e.text,c,"error: message"))
+  error("nel: "..Run(s,e.text,c,"error: message"))
 end)
-B(ns,"this scope",function(s,e,c)
+Bind(ns,"this scope",function(s,e,c)
  return s
 end)
-B(ns,"a new scope",function(s,e,c)
+Bind(ns,"a new scope",function(s,e,c)
  return Scope()
 end)
 -- Read a file in the current directly, more for compiling
-B(ns,"read file (path)",function(s,e,c)
+Bind(ns,"read file (path)",function(s,e,c)
-  return read(R(s,e.path,c,"read: path"))
+  return read(Run(s,e.path,c,"read: path"))
 end)
 -- Take some text and interpret it into an expression
-B(ns,"evaluate (text) in (scope)",function(s,e,c)
+Bind(ns,"evaluate (text) in (scope)",function(s,e,c)
-  local scope = R(s,e.scope,c,"evaluate: scope")
+  local scope = Run(s,e.scope,c,"evaluate: scope")
-  return R(s,interpret(R(scope,e.text,c,"include: source")),c,"include: result")
+  return Run(s,interpret(Run(scope,e.text,c,"include: source")),c,"include: result")
 end)
-B(ns,"print (text)",function(s,e,c)
+Bind(ns,"text (literal)",function(s,e,c)
  log(R(s,e.text,c,"print: text"))
 end)
 B(ns,"text (literal)",function(s,e,c)
  return e.literal:text()
 end)
-B(ns,"return (expression)",function(s,e,c)
+Bind(ns,"return (expression)",function(s,e,c)
-  return R(s,e.expression,c,"return: result")
+  return Run(s,e.expression,c,"return: result")
 end)
-B(ns,"(macro) means (expansion)",function(s,e,c)
+Bind(ns,"let (binding) in (scope)",function(s,e,c)
 end)
-B(ns,"(identifier) is (value)",function(s,e,c)
+Bind(ns,"text (literal)",function(s,e,c) return e.literal:text() end)
 Bind(ns,"let ((named (name)) be (value))",function(s,e,c) end)
 Bind(ns,"new table",function(s,e,c) return {} end)
 ]]
 Bind(ns,"text (text)",function(s,e,c) return e.text:text() end)
 Bind(ns,"(closed)",function(s,e,c) print(e.closed) return Run(s,e.closed,c,"(...)") end)
 Bind(ns,"log (text)",function(s,e,c) log(Run(s,e.text,c,"print: text")) end)
 Bind(ns,"this scope",function(s,e,c) return s end)
 Bind(ns,"new scope",function(s,e,c) return Scope() end) -- TODO: chains?!!?
 Bind(ns,"index (table) with (key)",function(s,e,c) return Run(s,e,c,"") end)
 Bind(ns,[[
 (input) means (output);
 (input) in (input_scope) means (output);
 (input) means do (output) in (output_scope);
 (input) in (input_scope) means (output) in (output_scope)
 ]],function(s1,e1,c1) -- A substitution
  local input_scope = s1
  if e1.input_scope then input_scope = Run(s1,e1.input_scope,c1,"means: input scope") end
  local output_scope = s1
  if e1.output_scope then output_scope = Run(s1,e1.output_scope,c1,"means: output scope") end
  Bind(input_scope,e1.input,function(s2,e2,c2)
    return Do(output_scope,e1.output,c2) -- TODO: chains?!
  end)
 end)
-B(ns,"(expression) becomes (result)",function(s,e,c)
+Bind(ns,"do (stuff) in (scope); do (stuff)",function(s,e,c)
-
+  s = s or Scope()
  return Do(s,e.stuff,c)
 end)
-B(ns,"let (binding) in (scope)",function(s,e,c)
+Bind(ns,"new table",function(s,e,c) return {} end)
-end)
+local Hpath = "nellie/helper.nel"
 local Hpath = "nel/helper.nel"
 local Hchain = Chain("in internal: "..Hpath)
 local success,result = Hchain:call(function(chain)
-  R(NelliScope,interpret(read(Hpath),Hpath,chain),chain)
+  print(Parse(read(Hpath),Hpath,chain))
  Do(NelliScope,Parse(read(Hpath),Hpath,chain),chain)
 end)
 --[[ Documentation:
-
+(log (text)) -> Log text to the output stream (print?)
 (a new scope) -> Becomes a created new scope
 (this scope) -> Becomes the current scope
 (macro) expands to (expansion) -> Becomes a binding which makes
--- a/nex.nel
+++ b/nex.nel
@@ -1,28 +0,0 @@
 // NEX 4
 here 'nex language' is [do {
  here 'language' is [create new language]
  return 'language'
 }]
 here (nex (expressions)) means [
  do (expressions) in 'nex language'
 ]
 (interpret 'input') means {
  here: 'previous character' is [nothing]
  iterate over [pattern match all "." in 'input' as {'this character'}] {
    if ['previous character' is something] {
    }
    now: 'previous character' is 'this character';
  }
 }
 loop (until 'termination') {
  choose from [read console] as 'input' {
    ('input' matches "end") does { now: termination };
    everything else does { interpret 'input' };
  }
 }
--- a/run.sh
+++ b/run.sh
@@ -4,6 +4,5 @@ then
  echo "lua could not be found"
  exit 1
 else
-  lua main.lua "$@"
+  lua -l nellie -e "Run'$@'"
 fi
--- a/session.vim
+++ b/session.vim
@@ -1,205 +0,0 @@
 let SessionLoad = 1
 let s:so_save = &g:so | let s:siso_save = &g:siso | setg so=0 siso=0 | setl so=-1 siso=-1
 let v:this_session=expand("<sfile>:p")
 silent only
 silent tabonly
 cd ~/Programming/nel/1
 if expand('%') == '' && !&modified && line('$') <= 1 && getline(1) == ''
  let s:wipebuf = bufnr('%')
 endif
 let s:shortmess_save = &shortmess
 if &shortmess =~ 'A'
  set shortmess=aoOA
 else
  set shortmess=aoO
 endif
 badd +167 main.lua
 badd +27 parse.lua
 badd +0 term://~/Programming/nel/1//1946:/usr/bin/zsh
 badd +0 interpret.lua
 badd +0 test.nel
 badd +191 helper.lua
 argglobal
 %argdel
 $argadd ~/Programming/nel/1
 edit parse.lua
 let s:save_splitbelow = &splitbelow
 let s:save_splitright = &splitright
 set splitbelow splitright
 wincmd _ | wincmd |
 vsplit
 1wincmd h
 wincmd _ | wincmd |
 split
 1wincmd k
 wincmd _ | wincmd |
 vsplit
 1wincmd h
 wincmd w
 wincmd w
 wincmd w
 wincmd _ | wincmd |
 split
 1wincmd k
 wincmd w
 let &splitbelow = s:save_splitbelow
 let &splitright = s:save_splitright
 wincmd t
 let s:save_winminheight = &winminheight
 let s:save_winminwidth = &winminwidth
 set winminheight=0
 set winheight=1
 set winminwidth=0
 set winwidth=1
 exe '1resize ' . ((&lines * 24 + 19) / 39)
 exe 'vert 1resize ' . ((&columns * 60 + 90) / 181)
 exe '2resize ' . ((&lines * 24 + 19) / 39)
 exe 'vert 2resize ' . ((&columns * 60 + 90) / 181)
 exe '3resize ' . ((&lines * 12 + 19) / 39)
 exe 'vert 3resize ' . ((&columns * 121 + 90) / 181)
 exe '4resize ' . ((&lines * 24 + 19) / 39)
 exe 'vert 4resize ' . ((&columns * 59 + 90) / 181)
 exe '5resize ' . ((&lines * 12 + 19) / 39)
 exe 'vert 5resize ' . ((&columns * 59 + 90) / 181)
 argglobal
 setlocal foldmethod=manual
 setlocal foldexpr=v:lua.vim.treesitter.foldexpr()
 setlocal foldmarker={{{,}}}
 setlocal foldignore=#
 setlocal foldlevel=0
 setlocal foldminlines=1
 setlocal foldnestmax=20
 setlocal foldenable
 silent! normal! zE
 let &fdl = &fdl
 let s:l = 267 - ((8 * winheight(0) + 12) / 24)
 if s:l < 1 | let s:l = 1 | endif
 keepjumps exe s:l
 normal! zt
 keepjumps 267
 normal! 019|
 lcd ~/Programming/nel/1
 wincmd w
 argglobal
 if bufexists(fnamemodify("~/Programming/nel/1/interpret.lua", ":p")) | buffer ~/Programming/nel/1/interpret.lua | else | edit ~/Programming/nel/1/interpret.lua | endif
 if &buftype ==# 'terminal'
  silent file ~/Programming/nel/1/interpret.lua
 endif
 balt ~/Programming/nel/1/parse.lua
 setlocal foldmethod=manual
 setlocal foldexpr=v:lua.vim.treesitter.foldexpr()
 setlocal foldmarker={{{,}}}
 setlocal foldignore=#
 setlocal foldlevel=0
 setlocal foldminlines=1
 setlocal foldnestmax=20
 setlocal foldenable
 silent! normal! zE
 let &fdl = &fdl
 let s:l = 58 - ((15 * winheight(0) + 12) / 24)
 if s:l < 1 | let s:l = 1 | endif
 keepjumps exe s:l
 normal! zt
 keepjumps 58
 normal! 034|
 lcd ~/Programming/nel/1
 wincmd w
 argglobal
 if bufexists(fnamemodify("term://~/Programming/nel/1//1946:/usr/bin/zsh", ":p")) | buffer term://~/Programming/nel/1//1946:/usr/bin/zsh | else | edit term://~/Programming/nel/1//1946:/usr/bin/zsh | endif
 if &buftype ==# 'terminal'
  silent file term://~/Programming/nel/1//1946:/usr/bin/zsh
 endif
 balt ~/Programming/nel/1/parse.lua
 setlocal foldmethod=manual
 setlocal foldexpr=0
 setlocal foldmarker={{{,}}}
 setlocal foldignore=#
 setlocal foldlevel=0
 setlocal foldminlines=1
 setlocal foldnestmax=20
 setlocal foldenable
 let s:l = 947 - ((11 * winheight(0) + 6) / 12)
 if s:l < 1 | let s:l = 1 | endif
 keepjumps exe s:l
 normal! zt
 keepjumps 947
 normal! 040|
 lcd ~/Programming/nel/1
 wincmd w
 argglobal
 if bufexists(fnamemodify("~/Programming/nel/1/main.lua", ":p")) | buffer ~/Programming/nel/1/main.lua | else | edit ~/Programming/nel/1/main.lua | endif
 if &buftype ==# 'terminal'
  silent file ~/Programming/nel/1/main.lua
 endif
 balt ~/Programming/nel/1/helper.lua
 setlocal foldmethod=manual
 setlocal foldexpr=v:lua.vim.treesitter.foldexpr()
 setlocal foldmarker={{{,}}}
 setlocal foldignore=#
 setlocal foldlevel=0
 setlocal foldminlines=1
 setlocal foldnestmax=20
 setlocal foldenable
 silent! normal! zE
 let &fdl = &fdl
 let s:l = 178 - ((21 * winheight(0) + 12) / 24)
 if s:l < 1 | let s:l = 1 | endif
 keepjumps exe s:l
 normal! zt
 keepjumps 178
 normal! 012|
 lcd ~/Programming/nel/1
 wincmd w
 argglobal
 if bufexists(fnamemodify("~/Programming/nel/1/test.nel", ":p")) | buffer ~/Programming/nel/1/test.nel | else | edit ~/Programming/nel/1/test.nel | endif
 if &buftype ==# 'terminal'
  silent file ~/Programming/nel/1/test.nel
 endif
 balt ~/Programming/nel/1/main.lua
 setlocal foldmethod=manual
 setlocal foldexpr=0
 setlocal foldmarker={{{,}}}
 setlocal foldignore=#
 setlocal foldlevel=0
 setlocal foldminlines=1
 setlocal foldnestmax=20
 setlocal foldenable
 silent! normal! zE
 let &fdl = &fdl
 let s:l = 5 - ((4 * winheight(0) + 6) / 12)
 if s:l < 1 | let s:l = 1 | endif
 keepjumps exe s:l
 normal! zt
 keepjumps 5
 normal! 0
 lcd ~/Programming/nel/1
 wincmd w
 3wincmd w
 exe '1resize ' . ((&lines * 24 + 19) / 39)
 exe 'vert 1resize ' . ((&columns * 60 + 90) / 181)
 exe '2resize ' . ((&lines * 24 + 19) / 39)
 exe 'vert 2resize ' . ((&columns * 60 + 90) / 181)
 exe '3resize ' . ((&lines * 12 + 19) / 39)
 exe 'vert 3resize ' . ((&columns * 121 + 90) / 181)
 exe '4resize ' . ((&lines * 24 + 19) / 39)
 exe 'vert 4resize ' . ((&columns * 59 + 90) / 181)
 exe '5resize ' . ((&lines * 12 + 19) / 39)
 exe 'vert 5resize ' . ((&columns * 59 + 90) / 181)
 tabnext 1
 if exists('s:wipebuf') && len(win_findbuf(s:wipebuf)) == 0 && getbufvar(s:wipebuf, '&buftype') isnot# 'terminal'
  silent exe 'bwipe ' . s:wipebuf
 endif
 unlet! s:wipebuf
 set winheight=1 winwidth=20
 let &shortmess = s:shortmess_save
 let &winminheight = s:save_winminheight
 let &winminwidth = s:save_winminwidth
 let s:sx = expand("<sfile>:p:r")."x.vim"
 if filereadable(s:sx)
  exe "source " . fnameescape(s:sx)
 endif
 let &g:so = s:so_save | let &g:siso = s:siso_save
 set hlsearch
 doautoall SessionLoadPost
 unlet SessionLoad
 " vim: set ft=vim :
--- a/test.nel
+++ b/test.nel
@@ -1,3 +0,0 @@
 do {
  print "wsg";
 }
--- a/test.sh
+++ b/test.sh
@@ -0,0 +1,8 @@
 #/bin/sh
 if ! command -v lua &> /dev/null
 then
  echo "lua could not be found"
  exit 1
 else
  lua -i -v -W -l nellie tests/test.lua
 fi
--- a/tests/print.nel
+++ b/tests/print.nel
--- a/tests/test.lua
+++ b/tests/test.lua
@@ -0,0 +1,9 @@
 print("doing some tests")
 local function test(file,result)
 end
 test("print.nel",[[hello world!]])
 do
 end
Author	SHA1	Message	Date
Christian Lincoln	7aa282b405	Sync	2026-03-29 11:46:50 +01:00
Christian Lincoln	e6f3b5c77f	Proto: meaning etc.	2026-03-08 18:59:45 +00:00
Christian Lincoln	d7ca3739aa	Renaming.	2026-03-03 14:22:18 +00:00
Christian Lincoln	b89e015170	Organisation.	2026-02-27 19:05:01 +00:00
Christian Lincoln	7edad0c5bb	Removing archive.	2026-02-27 16:46:43 +00:00
Christian Lincoln	d600fc7232	Moving nex out.	2026-02-22 17:51:11 +00:00
		`@@ -1,3 +0,0 @@`
			`do {`

			`} in ((module ("nel/translator/main.nel"))`