diff --git a/Caddyfile b/Caddyfile
index 80eaf39..970f98b 100644
--- a/Caddyfile
+++ b/Caddyfile
@@ -1,3 +1,9 @@
aidan-network.duckdns.org {
+ root ./old/
+ file_server
+}
+
+localhost:8443 {
+ root ./new/
file_server
}
\ No newline at end of file
diff --git a/new/builtin.mjs b/new/builtin.mjs
new file mode 100644
index 0000000..7b65afd
--- /dev/null
+++ b/new/builtin.mjs
@@ -0,0 +1,107 @@
+import {addDefn, addRPNASTDefn, makeFn, cloneElem} from './shiny.mjs';
+import {parseExprs} from './parse.mjs';
+import {tokenize} from './token.mjs';
+
+const addRPNDefn = (name, def) => {
+ let toks = tokenize(def);
+ if (!toks) {
+ throw 'could not load builtin'
+ }
+ let ast = parseExprs(toks);
+ if (!ast.parsed) {
+ throw 'could not load builtin'
+ }
+ addRPNASTDefn(name, ast.parsed[0]);
+}
+
+const add = (_, args) => {
+ return [{type:"int", val:args[0] + args[1]}];
+}
+
+const sub = (_, args) => {
+ return [{type:"int", val:args[1] - args[0]}];
+}
+
+const div = (_, args) => {
+ return [{type:"int", val:args[1] / args[0]}];
+}
+
+const mult = (_, args) => {
+ return [{type:"int", val:args[0] * args[1]}];
+}
+
+const pow = (_, args) => {
+ return [{type:"int", val:Math.pow(args[1], args[0])}];
+}
+
+const root = (_, args) => {
+ return [{type:"int", val:Math.sqrt(args[0])}];
+}
+
+const type = (_, args) => {
+ return [{type:"type", val:args[0].type}];
+}
+
+const pair = (_, args) => {
+ return [{type:"pair", val:{fst:args[1], snd:args[0]}}];
+}
+
+const fst = (_, args) => [args[0].fst];
+
+const snd = (_, args) => [args[0].snd];
+
+const eq = (_, args) => {
+ if (args[0].type === args[1].type && args[0].val === args[1].val) {
+ console.log(args[0], args[1])
+ return [{type:"ident", val:"true"}];
+ } else {
+ return [{type:"ident", val:"false"}];
+ }
+}
+
+const tuple = (_, args) => {
+ return [makeFn(args[0], (_, args) => {return [{type:"tuple", val:args}]})];
+}
+
+const index = (_, args) => {
+ return [args[1][args[0]]];
+}
+
+const len = (_, args) => {
+ return [{type:"int", val:args[0].length}];
+}
+
+const coerce = (_, args) => {
+ if (args[0].type === "type") {
+ let o = cloneElem(args[1]);
+ o.type = args[0].val;
+ return o;
+ } else {
+ throw 'typeerror'
+ }
+}
+
+addDefn("+", ["int", "int"], add);
+addDefn("-", ["int", "int"], sub);
+addDefn("/", ["int", "int"], div);
+addDefn("*", ["int", "int"], mult);
+addDefn("^", ["int", "int"], pow);
+addDefn("sqrt", ["int"], root);
+addDefn("==", 2, eq);
+addDefn("typeof", 1, type);
+addDefn("pair", 2, pair);
+addDefn("fst", ["pair"], fst);
+addDefn("snd", ["pair"], snd);
+addDefn("tuple", ["int"], tuple);
+addDefn("!!", ["int", "tuple"], index);
+addDefn("len", ["tuple"], len);
+addDefn("unsafeCoerce", 2, coerce);
+//addRPNDefn("unit", "(-> 0 arr)");
+//addRPNDefn("mono", "(-> 1 arr)");
+//addRPNDefn("unwrap", "(-> 0 !!)");
+addRPNDefn("true", "(a b -> a)");
+addRPNDefn("false", "(a b -> b)");
+addRPNDefn("stop", "\"stop");
+//addRPNDefn("id", "(a -> a)");
+addRPNDefn("inv", "(x -> 1 x /)");
+addRPNDefn("fold", "(x acc fn -> acc '(-> x acc fn 'fn fold) 'x \"stop ==)");
\ No newline at end of file
diff --git a/new/index.html b/new/index.html
new file mode 100644
index 0000000..25cf256
--- /dev/null
+++ b/new/index.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/new/main.js b/new/main.js
new file mode 100644
index 0000000..9ba0fd3
--- /dev/null
+++ b/new/main.js
@@ -0,0 +1,58 @@
+import {execRPN} from './shiny.mjs';
+import {parseExprs} from './parse.mjs';
+import {tokenize} from './token.mjs';
+//import './builtin.mjs';
+
+const inbox = document.getElementById("inbox")
+const outbox = document.getElementById("outbox")
+const submit = document.getElementById("submit")
+
+const show = (elem) => {
+ if (elem.type === "int") {
+ return elem.val
+ } else if (elem.type === "pair") {
+ return "{" + show(elem.val.fst) + ", " + show(elem.val.snd) + "}"
+ } else if (elem.type === "closure") {
+ return "(needs: " + elem.val.args.join(", ") + ")"
+ } else if (elem.type === "type") {
+ return elem.val
+ } else if (elem.type === "array") {
+ return "[" + prettyprint(elem.val) + "]"
+ } else if (elem.val) {
+ return "(" + elem.type + ": " + elem.val + ")"
+ } else {
+ return elem.type
+ }
+}
+
+const prettyprint = (out) => {
+ let str = "";
+ for (let i = 0; i < out.length; i++) {
+ str += show(out[i]);
+ if (i < out.length - 1) {
+ str += " ";
+ }
+ }
+ return str;
+}
+
+submit.onclick = (event) => {
+ const input = inbox.value;
+ let toks = tokenize(input);
+ if (!toks) {
+ outbox.innerHTML = "could not parse input: " + input;
+ return;
+ }
+ let ast = parseExprs(toks);
+ if (!ast.parsed) {
+ outbox.innerHTML = "incorrect syntax somewhere";
+ return;
+ }
+ let out = execRPN({}, ast.parsed);
+ if (!out) {
+ outbox.innerHTML = "failed to execute";
+ return;
+ }
+ //console.log(out.stacks);
+ outbox.innerHTML = prettyprint(out.stacks[0]);
+}
\ No newline at end of file
diff --git a/parse.mjs b/new/parse.mjs
similarity index 100%
rename from parse.mjs
rename to new/parse.mjs
diff --git a/new/shiny.mjs b/new/shiny.mjs
new file mode 100644
index 0000000..89ec0ef
--- /dev/null
+++ b/new/shiny.mjs
@@ -0,0 +1,145 @@
+/*
+EVAL.js
+-------
+
+reads exprs from AST and executes them
+
+types of elem:
+all have type
+all have val
+
+TYPE VAL
+"closure" {scope:{}, args:['x', 'y'], defn:}
+
+:
+{type:"ins", ins:[]}
+{type:"builtin", fn:(scope) => {stack}}
+
+exported functionality:
+defnOp(name, function) - define a built-in operator
+evalRPN(scope, ast)
+*/
+
+let builtins = {};
+
+export const defnOp = (name, data) => {
+ builtins[name] = data;
+}
+
+const lookup = (name, scope) => {
+ let n = scope[name];
+ if (n) {
+ return n;
+ }
+ n = builtins[n];
+ if (n) {
+ return n;
+ }
+ console.log(scope);
+ throw '"' + name + '" not in scope'
+}
+
+const extend = (scope, name, elems) => {
+ let o = Object.create(scope);
+ o[name] = elems;
+ return o;
+}
+
+const runFn = (defn, state) => {
+ if (defn.type === "ins") {
+ state.calls.push(defn.ins);
+ state.stacks.push([]);
+ } else if (defn.type === "builtin") {
+ let scope = state.scopes.pop();
+ let out = defn.fn(scope);
+ state.calls.push([]);
+ state.stacks.push(out);
+ }
+}
+
+const giveArg = (arg, elem) => {
+ let argN = elem.val.args[elem.val.args.length-1];
+ let newscope = extend(elem.val.scope, argN, [arg]);
+ return {type:elem.type, val:{scope:newscope, args:elem.val.args.slice(0,-1), defn:elem.val.defn}};
+}
+
+const apply = (elem, state) => {
+ if (elem.type === "closure") {
+ if (elem.val.args.length === 0) {
+ state.scopes.push(elem.val.scope);
+ runFn(elem.val.defn, state);
+ } else if (state.stacks[state.stacks.length-1].length > 0) {
+ apply(giveArg(state.stacks[state.stacks.length-1].pop(), elem), state);
+ } else {
+ state.stacks[state.stacks.length-1].push(elem);
+ }
+ } else {
+ state.stacks[state.stacks.length-1].push(elem);
+ }
+}
+
+const applyMany = (elems, state) => {
+ for (let i = 0; i < elems.length; i++) {
+ apply(elems[i], state);
+ }
+}
+
+const makeStackElems = (ins, state) => {
+ if (ins.type === "push") {
+ throw 'nested push error'
+ } else if (ins.type === "ident") {
+ return lookup(ins.val, state.scopes[state.scopes.length-1]);
+ } else if (ins.type === "func") {
+ return [{type:"closure", val:{scope:state.scopes[state.scopes.length-1], args:ins.args, defn:{type:"ins", ins:ins.body}}}];
+ } else {
+ return [ins];
+ }
+}
+
+const doIns = (ins, state) => {
+ if (ins.type === "push") {
+ state.stacks[state.stacks.length-1] = state.stacks[state.stacks.length-1].concat(makeStackElems(ins.elem, state));
+ } else if (ins.type === "defn") {
+ // initialize definition scope
+ let defscope = Object.create(state.scopes[state.scopes.length-1]);
+ // parse into closure for definition's scope (to allow for recursion)
+ let fnForm = {type:"closure", val:{scope:defscope, args:[], defn:{type:"ins", ins:ins.defn}}};
+ // add fnForm to definition scope
+ defscope[ins.ident] = [fnForm];
+ // evaluate fnForm
+ let out = execRPN(defscope, ins.defn);
+ defscope[ins.ident] = out.stacks[0];
+ state.scopes[state.scopes.length-1] = defscope;
+ } else {
+ applyMany(makeStackElems(ins, state), state);
+ }
+}
+
+const step = (state) => {
+ if (state.calls[state.calls.length-1].length === 0) {
+ if (state.calls.length === 1) {
+ throw 'finished execution'
+ }
+ if (state.stacks.length < 2) {
+ throw 'nothing to return'
+ }
+ state.calls.pop();
+ let out = state.stacks.pop();
+ applyMany(out, state);
+ } else {
+ let ins = state.calls[state.calls.length-1][0];
+ state.calls[state.calls.length-1] = state.calls[state.calls.length-1].slice(1);
+ doIns(ins, state);
+ }
+}
+
+export const execRPN = (scope, ins) => {
+ let state = {scopes:[scope], stacks:[[]], calls:[ins]};
+ while (state.calls[0].length > 0 || state.calls.length > 1) {
+ step(state);
+ if (state.stacks.length > 4096) {
+ throw 'max recursion depth exceeded'
+ }
+ }
+ return state;
+}
\ No newline at end of file
diff --git a/token.mjs b/new/token.mjs
similarity index 100%
rename from token.mjs
rename to new/token.mjs
diff --git a/builtin.mjs b/old/builtin.mjs
similarity index 85%
rename from builtin.mjs
rename to old/builtin.mjs
index 7802400..f878105 100644
--- a/builtin.mjs
+++ b/old/builtin.mjs
@@ -1,4 +1,4 @@
-import {addDefn, addRPNASTDefn, makeFn} from './eval.mjs';
+import {addDefn, addRPNASTDefn, makeFn, cloneElem} from './eval.mjs';
import {parseExprs} from './parse.mjs';
import {tokenize} from './token.mjs';
@@ -60,7 +60,7 @@ const eq = (_, args) => {
}
const tuple = (_, args) => {
- return [makeFn(args[0], (_, args) => {return [{type:"array", val:args}]})];
+ return [makeFn(args[0], (_, args) => {return [{type:"tuple", val:args}]})];
}
const index = (_, args) => {
@@ -73,7 +73,9 @@ const len = (_, args) => {
const coerce = (_, args) => {
if (args[0].type === "type") {
- return [{type:args[0].val, val:args[1].val}];
+ let o = cloneElem(args[1]);
+ o.type = args[0].val;
+ return o;
} else {
throw 'typeerror'
}
@@ -91,15 +93,15 @@ addDefn("pair", 2, pair);
addDefn("fst", ["pair"], fst);
addDefn("snd", ["pair"], snd);
addDefn("tuple", ["int"], tuple);
-addDefn("!!", ["int", "array"], index);
-addDefn("len", ["array"], len);
+addDefn("!!", ["int", "tuple"], index);
+addDefn("len", ["tuple"], len);
addDefn("unsafeCoerce", 2, coerce);
//addRPNDefn("unit", "(-> 0 arr)");
//addRPNDefn("mono", "(-> 1 arr)");
//addRPNDefn("unwrap", "(-> 0 !!)");
addRPNDefn("true", "(a b -> a)");
addRPNDefn("false", "(a b -> b)");
-addRPNDefn("stop", "(-> \"stop)");
+addRPNDefn("stop", "\"stop");
//addRPNDefn("id", "(a -> a)");
addRPNDefn("inv", "(x -> 1 x /)");
-addRPNDefn("fold", "(x acc fn -> 'acc '(-> x acc fn 'fn fold) 'x \"stop ==)");
\ No newline at end of file
+addRPNDefn("fold", "(x acc fn -> acc '(-> x acc fn 'fn fold) 'x \"stop ==)");
\ No newline at end of file
diff --git a/eval.mjs b/old/eval.mjs
similarity index 95%
rename from eval.mjs
rename to old/eval.mjs
index 7a7182a..043641c 100644
--- a/eval.mjs
+++ b/old/eval.mjs
@@ -72,7 +72,7 @@ const makeObj = (elem) => {
}
}
-const cloneElem = (elem) => {
+export const cloneElem = (elem) => {
if (Array.isArray(elem)) {
return elem.map(cloneElem);
} if (elem.type === "closure") {
@@ -81,6 +81,8 @@ const cloneElem = (elem) => {
argsClone.push(cloneElem(elem.args[i]));
}
return {type:"closure", args:argsClone, func:elem.func};
+ } else if (elem.val) {
+ return {type:elem.type, val:elem.val};
} else {
return elem;
}
@@ -148,7 +150,6 @@ const pushS = (elem, stack) => {
} else {
if (elem.type === "ident") {
let id = lookupScope(elem.val, stack.scope);
- console.log(id);
pushS(id, stack);
} else {
stack.stack.push(elem);
@@ -176,10 +177,15 @@ const showIns = (curr) => {
return curr.val;
} else if (curr.type === "push") {
return "'" + showIns(curr.elem)
+ } else if (curr.type === "func") {
+ return "anon"
+ } else if (curr.type === "defn") {
+ return curr.ident;
}
}
export const execRPN = (scope, i) => {
+ console.log(scope);
let ins = JSON.parse(JSON.stringify(i));
let stack = {scope:scope, stack:[]};
while (ins.length > 0) {
diff --git a/index.html b/old/index.html
similarity index 100%
rename from index.html
rename to old/index.html
diff --git a/main.js b/old/main.js
similarity index 93%
rename from main.js
rename to old/main.js
index e2724ae..b7bffd9 100644
--- a/main.js
+++ b/old/main.js
@@ -18,6 +18,10 @@ const show = (elem) => {
return elem.val
} else if (elem.type === "array") {
return "[" + prettyprint(elem.val) + "]"
+ } else if (elem.val) {
+ return "(" + elem.type + ": " + elem.val + ")"
+ } else {
+ return elem.type
}
}
diff --git a/old/parse.mjs b/old/parse.mjs
new file mode 100644
index 0000000..7e2474a
--- /dev/null
+++ b/old/parse.mjs
@@ -0,0 +1,212 @@
+/*
+parse.js
+--------
+
+Parse tokenstream into AST
+
+convert:
+[
+{type:"int",val:1},
+{type:"int",val:2},
+{type:"ident",name:"+"},
+{type:"syntax",val:"'"},
+{type:"syntax",val:"("},
+{type:"ident",name:"name"},
+{type:"syntax",val:";"},
+{type:"ident",name:"args"},
+{type:"syntax",val:"->"},
+{type:"int",val:2},
+{type:"ident",name:"args"},
+{type:"ident",name:"+"},
+{type:"syntax",val:")"}
+]
+
+(for c+p)
+[{type:"int",val:1},{type:"int",val:2},{type:"ident",name:"+"},{type:"syntax",val:"'"},{type:"syntax",val:"("},{type:"ident",name:"name"},{type:"ident",name:"args"},{type:"syntax",val:"->"},{type:"int",val:2},{type:"ident",name:"args"},{type:"ident",name:"+"},{type:"syntax",val:")"}]
+
+to:
+[
+ {type:"int", val:1},
+ {type:"int", val:2},
+ {type:"builtin", op:"+"},
+ {type:"push", elem:
+ {type:"func", args:["args"], body:[
+ {type:"int", val:1},
+ {type:"ident", val:"args"},
+ {type:"builtin", op:"+"},
+ }}]}}
+]
+
+EXPORTED FUNCTIONS:
+parseExprs - takes in tokenstream, outputs AST
+*/
+
+/* make parser safe */
+const attempt = (parser) => (stream) => {
+ let streamclone = [...stream];
+ try {
+ let out = parser(stream);
+ return out;
+ } catch(err) {
+ return {parsed:null,stream:streamclone};
+ }
+}
+
+/* chain */
+const or = (a, b) => (stream) => {
+ let aout = a(stream);
+ if (aout.parsed === null) {
+ return b(aout.stream);
+ } else {
+ return aout;
+ }
+}
+
+/* (parser) */
+const parens = (parser) => (stream) => {
+ let a = parseSyntax("(")(stream);
+ if (a.parsed === null) {
+ return {parsed:null, stream:a.stream};
+ }
+ let dat = parser(a.stream);
+ a = parseSyntax(")")(dat.stream);
+ if (a.parsed === null) {
+ throw 'mismatched parens!';
+ }
+ return {parsed:dat.parsed, stream:a.stream};
+}
+
+/* [parser] */
+const many = (parser) => (stream) => {
+ let parsed = [];
+ for (let i = parser(stream); i.parsed !== null; i = parser(stream)) {
+ parsed.push(i.parsed);
+ stream = i.stream;
+ }
+ return {parsed:parsed, stream:stream};
+}
+
+/* takes in stream, outputs parsed item or null */
+const parseIdent = (stream) => {
+ let e = stream[0];
+ if (e === undefined) {
+ return {parsed:null, stream:stream};
+ }
+ if (e.type !== "ident") {
+ return {parsed:null, stream:stream};
+ } else {
+ stream.shift();
+ return {parsed:{type:e.type, val:e.name}, stream:stream};
+ }
+}
+
+/* takes in stream, outputs parsed item or null */
+const parseInteger = (stream) => {
+ let e = stream[0];
+ if (e === undefined) {
+ return {parsed:null, stream:stream};
+ }
+ if (e.type !== "int") {
+ return {parsed:null, stream:stream};
+ } else {
+ stream.shift();
+ return {parsed:{type:e.type, val:e.val}, stream:stream};
+ }
+}
+
+/* takes in stream, outputs parsed item or null */
+const parseSyntax = (syntax) => (stream) => {
+ let e = stream[0];
+ if (e === undefined) {
+ return {parsed:null, stream:stream};
+ }
+ if (e.type !== "syntax") {
+ return {parsed:null, stream:stream};
+ }
+ if (e.val !== syntax) {
+ return {parsed:null, stream:stream};
+ } else {
+ stream.shift();
+ return {parsed:{type:"syntax", val:syntax}, stream:stream};
+ }
+}
+
+/* takes in stream, outputs string or null - FAILABLE */
+const parseName = (stream) => {
+ let id = parseIdent(stream);
+ if (id.parsed === null) {
+ return {parsed:null, stream:id.stream};
+ }
+ let syn = parseSyntax(";")(id.stream);
+ if (syn.parsed === null) {
+ throw 'could not parse name!'
+ }
+ return {parsed:id.parsed.val, stream:syn.stream};
+}
+
+const parseType = (stream) => {
+ let syn = attempt(parseSyntax("\""))(stream);
+ if (syn.parsed === null) {
+ return {parsed:null, stream:syn.stream};
+ }
+ let id = or(parseIdent, parseInteger)(syn.stream);
+ if (id.parsed === null) {
+ return {parsed:null, stream:id.stream};
+ }
+ return {parsed:{type:"type", val:id.parsed.val}, stream:id.stream};
+
+ //return {parsed:null, stream:stream};
+}
+
+/* takes in stream, outputs parsed item or null - FAILABLE */
+const parsePush = (stream) => {
+ let syn = attempt(parseSyntax("'"))(stream);
+ if (syn.parsed === null) {
+ return {parsed:null, stream:syn.stream};
+ }
+ let id = parseExpr(syn.stream);
+ if (id.parsed === null) {
+ return {parsed:null, stream:id.stream};
+ }
+ return {parsed:{type:"push", elem:id.parsed}, stream:id.stream};
+}
+
+const parseDefn = (stream) => {
+ let name = parseName(stream);
+ if (name.parsed === null) {
+ throw 'no name found!'
+ }
+ let expr = parseExprs(stream);
+ if (expr.parsed === null) {
+ throw 'no body found!'
+ }
+ return {parsed:{type:"defn", ident:name.parsed, defn:expr.parsed}, stream:expr.stream}
+}
+
+/* takes in stream, outputs parsed item or null - FAILABLE */
+const parseLambda = (stream) => {
+ let args = many(parseIdent)(stream);
+ let syn = parseSyntax("->")(args.stream);
+ if (syn.parsed === null) {
+ throw 'no lambda body found!';
+ }
+ let body = parseExprs(syn.stream); // .parsed should never be null, but anyway...
+ if (body.parsed === null) {
+ throw 'no lambda body found!';
+ }
+ return {parsed:{type:"func", args:args.parsed.map(x => x.val), body:body.parsed}, stream:body.stream};
+}
+
+/* takes in stream, outputs parsed item or null */
+const parseExpr = or(
+ attempt(parens(parseDefn)), or(
+ attempt(parens(parseLambda)), or(
+ attempt(parseLambda), or(
+ parseType, or(
+ parseIdent, or(
+ parseInteger,
+ parsePush
+ ))))));
+
+/* takes in stream, outputs parsed items */
+export const parseExprs = many(parseExpr);
\ No newline at end of file
diff --git a/old/token.mjs b/old/token.mjs
new file mode 100644
index 0000000..3e0a341
--- /dev/null
+++ b/old/token.mjs
@@ -0,0 +1,51 @@
+export function tokenize(input) {
+ let i;
+ let inputWithAddedSpaces = "";
+ const syntax = /['";()]/; // -> is a special syntax (because it uses 2 characters) so is coded separately
+ for(i = 0; i"){
+ if(input.charAt(i-1) != " "){
+ inputWithAddedSpaces += " "; // adds a space
+ }
+ if(input.charAt(i+2) != " "){
+ inputWithAddedSpaces += "->" + " "; // adds a space after the two characters
+ } else {
+ inputWithAddedSpaces += "->"; // adds the two characters
+ }
+ } else if(input.charAt(i) != ">") { // if it is syntax, it was already detected at "-"
+ inputWithAddedSpaces += input.charAt(i);
+ }
+ } // i feel like this for loop is inefficient and could just add spaces around syntax all the time, so the following code has more writes to memory but may be more efficient. replace lines 5-27 with 29-37 by commenting out lines 5-27 and removing the /* and */ around lines 29-37. Note: i have not tested the code but it probably works.
+ /*
+ for(i = 0; i"){
+ inputWithAddedSpaces += " -> ";
+ } else {
+ inputWithAddedSpaces += input.charAt(i);
+ }
+ }
+ */
+ let splitInput = inputWithAddedSpaces.split(" ").filter((s) => s !== "");
+ let output = [];
+ for(i = 0; i
+ } else if(syntax.test(splitInput[i]) || splitInput[i] === "->"){// needs a || as -> wasn't included in the syntax regexp. it wasn't in because -> uses two characters so i wanted to have separate code for it. (also because regexps are confusing)
+ output.push({type: "syntax", val:splitInput[i]});
+ } else if(splitInput[i] != '') { // if syntax is next to the end of the string or other bits of syntax the two spaces are in inputWithAddedSpaces so .split returns '' as one element. this makes sure that it is not read as an identifier
+ output.push({type: "ident", name:splitInput[i]});
+ }
+ }
+ return(output)
+}
\ No newline at end of file