Removing archive.
This commit is contained in:
@@ -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
|
|
||||||
@@ -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.
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
*/
|
|
||||||
@@ -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);
|
|
||||||
});
|
|
||||||
};
|
|
||||||
}
|
|
||||||
14
nel/lc.nel
14
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)
|
|
||||||
}
|
|
||||||
@@ -1,3 +0,0 @@
|
|||||||
do {
|
|
||||||
|
|
||||||
} in ((module ("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));
|
|
||||||
}
|
|
||||||
@@ -1,6 +0,0 @@
|
|||||||
do {
|
|
||||||
here ((fart) means (print "fart"));
|
|
||||||
fart;
|
|
||||||
fart;
|
|
||||||
fart;
|
|
||||||
}
|
|
||||||
205
session.vim
205
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 :
|
|
||||||
Reference in New Issue
Block a user