├── LICENSE.txt
├── README.md
├── base.js
├── ck
├── ck.js
├── ckeval.js
└── editor.html
├── editor.css
├── editor.html
├── editor.js
├── eval.js
├── examples
├── editor.css
├── editor.html
├── editor.js
├── quines.html
├── quines.js
├── veneer.css
└── veneer.js
├── immutable.min.js
├── mk.js
├── mk_test.js
├── reader.js
├── resources
├── closebrackets.js
├── codemirror.css
├── codemirror.js
├── matchbrackets.js
└── scheme.js
├── veneer.css
└── veneer.js
/LICENSE.txt:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2015 tca
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # veneer
2 |
3 | [Browser based miniKanren editor and REPL](http://tca.github.io/veneer/examples/editor.html)
4 |
--------------------------------------------------------------------------------
/base.js:
--------------------------------------------------------------------------------
1 | function Pair(car, cdr) {
2 | this.car = car;
3 | this.cdr = cdr;
4 | }
5 | function car(x) { return x.car; }
6 | function cdr(x) { return x.cdr; }
7 | function pairp(x) { return x instanceof Pair; }
8 | function cons(car, cdr) { return new Pair(car, cdr); }
9 |
10 |
11 | var gensym_counter = 0;
12 | var symbol_table = new Object(null);
13 |
14 | function Symbol(str) { this.string = str; }
15 |
16 | function gensym(str) { return new Symbol([str, "@@", gensym_counter++].join("")); }
17 |
18 | function intern(string) {
19 | if (symbol_table.hasOwnProperty(string)) {
20 | return symbol_table[string];
21 | } else {
22 | var sym = new Symbol(string);
23 | symbol_table[string] = sym;
24 | return sym;
25 | }
26 | }
27 |
28 | function nullp(x) { return x === null; }
29 | function procedurep(x) { return x instanceof Function; }
30 | function symbolp(x) { return x instanceof Symbol; }
31 | function numberp(t) { return typeof t === "number"; }
32 | function booleanp(t) { return typeof t === "boolean"; }
33 | function stringp(t) { return typeof t === "string"; }
34 | function constantp(t) { return numberp(t) || booleanp(t) || stringp(t); }
35 |
36 | function not(x) { return x === false; }
37 |
38 | function quotient(a, b) { return Math.trunc(a/b); }
39 | function oddp(n) { return (n % 2) == 1; }
40 | function evenp(n) { return (n % 2) == 0; }
41 | function zerop(n) { return n === 0; }
42 |
43 | function Ref(v) {
44 | this.val = v;
45 | }
46 | Ref.prototype.get = function() { return this.val; };
47 | Ref.prototype.set = function(v1) { this.val = v1; };
48 |
49 | function ref(v) { return new Ref(v); }
50 |
51 | function anyp(pred, xs) {
52 | while(xs !== null) {
53 | if (pred(xs.car)) { return xs.car; }
54 | else { xs = xs.cdr; }
55 | } return false;
56 | }
57 |
58 | function memq(x, xs) {
59 | return anyp(function(y) { return x === y; }, xs);
60 | }
61 |
62 | function assp(pred, xs) {
63 | while(xs !== null) {
64 | if (pred(xs.car.car)) { return xs.car; }
65 | else { xs = xs.cdr; }
66 | } return false;
67 | }
68 |
69 | function length(lst) {
70 | var memo = 0;
71 | while(lst !== null) { memo++; lst = lst.cdr; }
72 | return memo;
73 | }
74 |
75 | function nth(xs, n) {
76 | while(--n > 0) { xs = xs.cdr; }
77 | return xs.car;
78 | }
79 |
80 | function reverse_aux(lst, memo) {
81 | while(lst !== null) {
82 | memo = cons(lst.car, memo);
83 | lst = lst.cdr;
84 | } return memo;
85 | }
86 |
87 | function reverse(lst) {
88 | return reverse_aux(lst, null);
89 | }
90 |
91 | function append(as, bs) {
92 | if(as === null) {
93 | return bs;
94 | } else {
95 | return cons(as.car, append(as.cdr, bs));
96 | }
97 | }
98 |
99 | function make_list(len, elem) {
100 | var accum = null;
101 | while (len-- > 0) {
102 | accum = cons(elem, accum);
103 | } return accum;
104 | }
105 |
106 | function array_slice_list(arr, from) {
107 | var i = arr.length;
108 | var memo = null;
109 | while(i > from) { memo = cons(arr[--i], memo); }
110 | return memo;
111 | }
112 |
113 | function array_to_list(arr) {
114 | var i = arr.length;
115 | var memo = null;
116 | while(i > 0) { memo = cons(arr[--i], memo); }
117 | return memo;
118 | }
119 |
120 | function map(fn, lst) {
121 | var memo = [];
122 | while(lst !== null) {
123 | memo.push(fn(lst.car));
124 | lst = lst.cdr;
125 | } return array_to_list(memo);
126 | }
127 |
128 | function list() {
129 | return array_to_list(arguments);
130 | }
131 |
132 | function foldl(xs, m, fn) {
133 | while(xs !== null) {
134 | m = fn(m, xs.car);
135 | xs = xs.cdr;
136 | } return m;
137 | }
138 |
139 | function foldr(xs, m, fn) {
140 | return (xs === null) ? m : fn(xs.car, foldr(xs.cdr, m, fn));
141 | }
142 |
143 | function assq(x, xs) {
144 | while(xs !== null) {
145 | if (x === xs.car.car) { return xs.car; }
146 | else { xs = xs.cdr; }
147 | } return false;
148 | }
149 |
150 | function pretty_print(x) {
151 | if (numberp(x)) {
152 | return x.toString();
153 | } else if (booleanp(x)) {
154 | return x ? "#t" : "#f";
155 | } else if (x === null) {
156 | return "()";
157 | } else if (typeof x === "string") {
158 | return ["\"", x, "\""].join("");
159 | } else if (symbolp(x)) {
160 | return x.string;
161 | } else if (pairp(x)) {
162 | var cur = x;
163 | var memo = [];
164 | while(true) {
165 | if(pairp(cur.cdr)) {
166 | memo.push(pretty_print(cur.car));
167 | cur = cur.cdr;
168 | } else if (cur.cdr === null) {
169 | memo.push(pretty_print(cur.car));
170 | break;
171 | } else {
172 | memo.push(pretty_print(cur.car));
173 | memo.push(".");
174 | memo.push(pretty_print(cur.cdr));
175 | break;
176 | }
177 | } return ["(", memo.join(" "), ")"].join("");
178 | } else if (x && x.toString && typeof x.toString === "function") {
179 | return x.toString();
180 | } else {
181 | return JSON.stringify(x);
182 | }
183 | }
184 |
--------------------------------------------------------------------------------
/ck/ck.js:
--------------------------------------------------------------------------------
1 | function Var(c) { this.c = c; }
2 | function mkvar(c) { return new Var(c); }
3 | function varp(x) { return (x instanceof Var); }
4 | function vareq(x1, x2) { return x1.c === x2.c; }
5 |
6 | function MiniKanrenState(s, c, p, cs) {
7 | this.substitution = s;
8 | this.counter = c;
9 | this.prefix = p;
10 | this.constraint_store = cs;
11 | }
12 | function Mks(s, c, p, cs) { return new MiniKanrenState(s, c, p, cs); }
13 |
14 | var not_found = [];
15 | function walk(u, s) {
16 | var pr;
17 | while(varp(u)) {
18 | pr = s.get(u.c, not_found);
19 | if (pr === not_found) {
20 | return u;
21 | } else {
22 | u = pr;
23 | }
24 | } return u;
25 | }
26 |
27 | function occurs_check(x, v, s) {
28 | var v1 = walk(v, s);
29 | if(varp(v1)) {
30 | return vareq(v1, x);
31 | } else if (pairp(v1)) {
32 | return occurs_check(x, v1.car, s) || occurs_check(x, v1.cdr, s);
33 | } else {
34 | return false;
35 | }
36 | }
37 |
38 | function unify(u, v, mks) {
39 | var s = mks.substitution;
40 | var p = mks.prefix;
41 | var u1 = walk(u, s);
42 | var v1 = walk(v, s);
43 | if (varp(u1) && varp(v1) && vareq(u1, v1)) { return mks; }
44 | else if (varp(u1)) { return ext_s_check_prefix(u1, v1, mks); }
45 | else if (varp(v1)) { return ext_s_check_prefix(v1, u1, mks); }
46 | else if (pairp(u1) && pairp(v1)) {
47 | var mks1 = unify(u1.car, v1.car, mks);
48 | return (mks1 !== false) && unify(u1.cdr, v1.cdr, mks1);
49 | } else {
50 | return (u1 === v1) && mks;
51 | }
52 | }
53 |
54 | function eqeq(u, v) {
55 | return function(mks) {
56 | var mks1 = unify(u, v, mks);
57 | return mks1 === false ? mzero : run_constraints(mks1);
58 | };
59 | }
60 |
61 | var empty_set = Immutable.Set();
62 | function ext_disequality(u, v, mks) {
63 | var cs = mks.constraint_store;
64 | return Mks(mks.substitution, mks.counter, mks.prefix,
65 | cs.updateIn([u.c, 1], empty_set, function(ds) { return ds.add(v); }));
66 | }
67 | function rem_disequality(u, v, mks) {
68 | var ds1 = mks.constraint_store.getIn([u.c, 1], false);
69 | if (ds1) {
70 | return Mks(mks.substitution, mks.counter, mks.prefix, mks.constraint_store.setIn([u.c, 1], ds1.delete(v)));
71 | } else {
72 | return mks;
73 | }
74 | }
75 |
76 | // need to do more for =/= between vars?
77 | function disunify(u, v, mks) {
78 | var s = mks.substitution;
79 | var p = mks.prefix;
80 | var u1 = walk(u, s);
81 | var v1 = walk(v, s);
82 | if (varp(u1) && varp(v1) && vareq(u1, v1)) { return false; }
83 | else if (varp(u1)) { return ext_disequality(u1, v1, mks); }
84 | else if (varp(v1)) { return ext_disequality(v1, u1, mks); }
85 | else if (pairp(u1) && pairp(v1)) {
86 | var mks1 = disunify(u1.car, v1.car, mks);
87 | return (mks1 !== false) && disunify(u1.cdr, v1.cdr, mks1);
88 | } else {
89 | if (u1 !== v1) {
90 | if (varp(u)) {
91 | return rem_disequality(u, v1, mks);
92 | } else { return mks; }
93 | } else {
94 | return false;
95 | }
96 | }
97 | }
98 |
99 | function disequality(u, vs, mks) {
100 | var mks1 = mks;
101 | vs.forEach(function(v) {
102 | mks1 = disunify(u, v, mks);
103 | return mks1;
104 | });
105 | return mks1;
106 | }
107 |
108 | function noteqeq(u, v) {
109 | return function(mks) {
110 | var mks1 = disunify(u, v, mks);
111 | return mks1 !== false ? unit(mks1) : mzero;
112 | };
113 | }
114 |
115 | var empty_map = Immutable.Map();
116 | function type_check(v, p, mks) {
117 | var s = mks.substitution;
118 | var cs = mks.constraint_store;
119 | var v1 = walk(v, s);
120 | if (varp(v1)) {
121 | var cs_entry = cs.get(v1.c, false);
122 | var existing_type = cs_entry !== false && cs_entry.get(0, false);
123 | if (existing_type && existing_type !== p) {
124 | if(existing_type === p) {
125 | // types match, dont add extra constraint
126 | return mks;
127 | } else {
128 | // type mismatch; fail
129 | return false;
130 | }
131 | } else {
132 | // add constraint
133 | cs_entry = cs_entry || empty_map;
134 | var cs1 = cs.set(v1.c, cs_entry.set(0, p));
135 | return Mks(s, mks.counter, mks.prefix, cs1);
136 | }
137 | } else {
138 | // ground; run test
139 | if (p(v1)) {
140 | var cs1 = cs;
141 | if (varp(v)) {
142 | // remove constraint from store; it cannot be violated
143 | var cs_entry = cs.get(v.c, false);
144 | cs1 = cs_entry ? cs.set(v.c, cs_entry.delete(0)) : cs;
145 | }
146 | return Mks(s, mks.counter, mks.prefix, cs1);
147 | } else {
148 | return false;
149 | }
150 | }
151 | }
152 |
153 | function typeo(v, p) {
154 | return function(mks) {
155 | var mks1 = type_check(v, p, mks);
156 | return mks1 === false ? mzero : unit(mks1);
157 | };
158 | }
159 |
160 | function symbolo(s) { return typeo(s, symbolp); }
161 | function numbero(n) { return typeo(n, numberp); }
162 |
163 | function absent_check(u, v, mks) {
164 | var s = mks.substitution;
165 |
166 | var abs_f = walk(u, s);
167 | var abs_s = walk(v, s);
168 |
169 | // defer until both terms are ground
170 | if (varp(abs_f) || varp(abs_s)) {
171 | var cs2 = mks.constraint_store.updateIn([abs_f.c, 2], function(_) { return abs_s; });
172 | return vareq(abs_s, abs_f) ? false : Mks(s, mks.counter, mks.prefix, cs2);
173 | }
174 | // split and requeue
175 | else if (pairp(abs_f)) {
176 | var mks1 = Mks(s, mks.counter, mks.prefix, mks.constraint_store.deleteIn([abs_f.c, 2]));
177 | var mks2 = absent_check(abs_f.car, abs_s, mks1);
178 | return mks2 !== false && absent_check(abs_f.car, abs_s, mks2);
179 | }
180 | // both are ground and atomic; check for eqv?
181 | else if (abs_s === abs_f) {
182 | return false;
183 | } else {
184 | // forget constraint, it can never fail
185 | return Mks(s, mks.counter, mks.prefix, mks.constraint_store.deleteIn([abs_f, 2]));
186 | }
187 | }
188 |
189 | function absento(s, f) {
190 | return function(mks) {
191 | var mks1 = absent_check(f, s, mks);
192 | return mks1 !== false ? unit(mks1) : mzero;
193 | };
194 | }
195 |
196 | function unit(mks) { return cons(mks, mzero); }
197 | var mzero = null;
198 |
199 | function ext_s_check_prefix(x, v, mks) {
200 | var s = mks.substitution;
201 | var p = mks.prefix;
202 | if (occurs_check(x, v, s)) {
203 | return false;
204 | } else {
205 | return Mks(s.set(x.c, v), mks.counter, cons(cons(x, v), p), mks.constraint_store);
206 | }
207 | }
208 |
209 | var ctable = [type_check, disequality, absent_check];
210 |
211 | function run_constraints(mks) {
212 | var cs = mks.constraint_store;
213 | if (cs.isEmpty()) { return unit(mks); }
214 |
215 | var s = mks.substitution;
216 | var c = mks.counter;
217 | var p = mks.prefix;
218 | var mks1 = Mks(s, c, null, cs);
219 |
220 | // TODO: add loop to run changes added by constraints ?
221 | var relevant_cs;
222 | while(p !== null) {
223 | relevant_cs = cs.get(p.car.car.c, false);
224 | if (relevant_cs) {
225 | relevant_cs.forEach(function(ct, cv) {
226 | mks1 = ctable[cv](p.car.car, ct, mks1);
227 | return mks1;
228 | });
229 | if(!mks1) { return mzero; }
230 | }
231 | p = p.cdr;
232 | }
233 | return unit(mks1);
234 | }
235 |
236 | function call_fresh(f) {
237 | return function(mks) {
238 | var c = mks.counter;
239 | return f(mkvar(c))(Mks(mks.substitution, (c + 1), mks.prefix, mks.constraint_store));
240 | };
241 | }
242 |
243 | function disj(g1, g2) {
244 | return function(mks) { return mplus(g1(mks), g2(mks)); };
245 | }
246 | function conj(g1, g2) {
247 | return function(mks) { return bind(g1(mks), g2); };
248 | }
249 |
250 | function mplus($1, $2) {
251 | if ($1 === null) {
252 | return $2;
253 | } else if (procedurep($1)) {
254 | return function() { return mplus($2, $1()); };
255 | } else {
256 | return cons($1.car, mplus($1.cdr, $2));
257 | }
258 | }
259 |
260 | function bind($, g) {
261 | if ($ === null) {
262 | return mzero;
263 | } else if (procedurep($)) {
264 | return function() { return bind($(), g); };
265 | } else {
266 | return mplus(g($.car), bind($.cdr, g));
267 | }
268 | }
269 |
270 | function pull($) {
271 | while(procedurep($)) {
272 | $ = $();
273 | } return $;
274 | }
275 |
276 | function reify(v, s) {
277 | var v1 = walk_star(v, s);
278 | return walk_star(v1, reify_s(v1, Immutable.Map()));
279 | }
280 |
281 | function walk_star(v, s) {
282 | var v1 = walk(v, s);
283 | if (varp(v1)) {
284 | return v1;
285 | } else if (pairp(v1)) {
286 | return cons(walk_star(v1.car, s),
287 | walk_star(v1.cdr, s));
288 | } else {
289 | return v1;
290 | }
291 | }
292 |
293 | function reify_s(v, s) {
294 | var v1 = walk(v, s);
295 | if (varp(v1)) {
296 | return s.set(v1.c, reify_name(s.size));
297 | } else if (pairp(v1)) {
298 | return reify_s(v1.cdr, reify_s(v1.car, s));
299 | } else {
300 | return s;
301 | }
302 | }
303 |
304 | function reify_name(n) {
305 | return { toString: function() { return ["_", n].join("."); } };
306 | }
307 |
308 | function pred_to_tag(p) {
309 | return assq(p, list(cons(symbolp, intern("sym")),
310 | cons(numberp, intern("num")))).cdr;
311 | }
312 |
313 | function query_map(qm, mks) {
314 | var s = mks.substitution;
315 |
316 | var q = reify(qm, s);
317 |
318 | var m = print_constraints(q, s);
319 |
320 | return m;
321 | }
322 |
323 | function print_constraints(sq, s) {
324 | var subs = foldl(sq, [], function(m, a_v) {
325 | return m.concat([a_v.car, ": ", pretty_print(a_v.cdr), "\n"]);
326 | });
327 |
328 | return subs.join("");
329 | }
330 |
331 | function build_num(n) {
332 | if((n % 2) === 1) {
333 | return cons(1, build_num(Math.floor((n - 1) / 2)));
334 | } else if (n !== 0 && (n % 2) === 0) {
335 | return cons(0, build_num(Math.floor(n / 2)));
336 | } else {
337 | return null;
338 | }
339 | }
340 |
--------------------------------------------------------------------------------
/ck/ckeval.js:
--------------------------------------------------------------------------------
1 | function VeneerVM() {
2 | var toplevel = new Object(null);
3 |
4 | function register_define(exp) {
5 | if (pairp(exp) && exp.car === intern("define")) {
6 | var a = pairp(exp.cdr.car) ? exp.cdr.car.car : exp.cdr.car;
7 | toplevel[a.string] = ref(null);
8 | }
9 | }
10 |
11 | function quote_desugar(exp) {
12 | if (pairp(exp)) {
13 | return meta(list(meta(intern("cons"), {tag:"var"}), quote_desugar(exp.car), quote_desugar(exp.cdr)), {tag:"app-builtin"});
14 | } else if (exp == null) {
15 | return meta(list(intern("quote"), null), { tag: "quoted" });
16 | }else if(constantp(exp)) {
17 | return meta(exp, {tag:"const"});
18 | } else {
19 | return meta(list(intern("quote"), exp), { tag: "quoted" });
20 | }
21 | }
22 |
23 | function quasiquote_desugar(exp, n, env) {
24 | if (pairp(exp)) {
25 | if (exp.car === intern("unquote")) {
26 | if (n === 1) {
27 | return desugar(exp.cdr.car, env);
28 | } else {
29 | return list(intern("list"), list(intern("quote"), intern("unquote")),
30 | quasiquote_desugar(exp.cdr.car, n - 1, env));
31 | }
32 | } else if (exp.car === intern("quasiquote")) {
33 | return list(intern("list"), list(intern("quote"), intern("quasiquote")),
34 | quasiquote_desugar(exp.cdr.car, n + 1, env));
35 | } else {
36 | return list(intern("cons"), quasiquote_desugar(exp.car, n, env),
37 | quasiquote_desugar(exp.cdr, n, env));
38 | }
39 | } else {
40 | return quote_desugar(exp);
41 | }
42 | }
43 |
44 | function Meta(val, meta) {
45 | this.val = val;
46 | this.meta = meta || {};
47 | }
48 | function meta(v, meta) { return new Meta(v, meta); }
49 |
50 | function normalize_params(params) {
51 | var ps = null;
52 | var rest = null;
53 | var whole = null;
54 | while(params !== null) {
55 | if(symbolp(params)) {
56 | rest = cons(params, rest);
57 | whole = cons(params, ps);
58 | break;
59 | } else {
60 | ps = cons(params.car, ps);
61 | whole = ps;
62 | params = params.cdr;
63 | }
64 | } return { normal: reverse(ps), rest: rest, whole: reverse(whole) };
65 | }
66 |
67 | function desugar(exp, env) {
68 | if(exp instanceof Meta) { return exp; }
69 | if(pairp(exp)) {
70 | // application
71 | var app = false;
72 | if(symbolp(exp.car) && (lookup(exp.car, env) || toplevel.hasOwnProperty(exp.car.string))
73 | || pairp(exp.car)) {
74 | return meta(map(function(e) { return desugar(e, env); }, exp),
75 | { tag: "app" });
76 | }
77 | // special forms & builtins
78 | switch(exp.car) {
79 | case intern("define"):
80 | var name;
81 | var body;
82 | if(pairp(exp.cdr.car)) {
83 | // (define (x y z) f) => (define x (lambda (y z) f))
84 | name = exp.cdr.car.car;
85 | body = cons(intern("lambda"), cons(exp.cdr.car.cdr, exp.cdr.cdr));
86 | } else {
87 | name = exp.cdr.car;
88 | body = exp.cdr.cdr.car;
89 | }
90 | return meta(list(exp.car, name, desugar(body, env)), { tag: "define" });
91 | case intern("quote"):
92 | var val = quote_desugar(exp.cdr.car);
93 | val.meta.constp = true;
94 | return val;
95 | case intern("quasiquote"):
96 | return desugar(quasiquote_desugar(exp.cdr.car, 1, env), env);
97 | case intern("zzz"):
98 | return meta(list(exp.car, desugar(exp.cdr.car, env)),
99 | { tag: "zzz" });
100 | case intern("conde"):
101 | var clauses = map(function(row) { return cons(intern("conj"), row); }, exp.cdr);
102 | return desugar(cons(intern("disj"), clauses), env);
103 | case intern("conj"):
104 | if (exp.cdr == null) { throw "error: empty conj"; }
105 | else if (exp.cdr.cdr == null) {
106 | var e1 = desugar(list(intern("zzz"), exp.cdr.car), env);
107 | return e1;
108 | } else {
109 | var e1 = list(intern("zzz"), exp.cdr.car);
110 | var e2 = cons(intern("conj"), exp.cdr.cdr);
111 | return desugar(list(intern("conj/2"), e1, e2), env);
112 | }
113 | case intern("disj"):
114 | if (exp.cdr == null) { throw "error: empty disj"; }
115 | else if (exp.cdr.cdr == null) {
116 | var e1 = desugar(list(intern("zzz"), exp.cdr.car), env);
117 | return e1;
118 | } else {
119 | var e1 = list(intern("zzz"), exp.cdr.car);
120 | var e2 = cons(intern("disj"), exp.cdr.cdr);
121 | return desugar(list(intern("disj/2"), e1, e2), env);
122 | }
123 | case intern("begin"):
124 | return meta(cons(exp.car, map(function(f) { return desugar(f, env); }, exp.cdr)),
125 | { tag: "begin" });
126 | case intern("fresh"):
127 | var bindings = exp.cdr.car;
128 | var body = exp.cdr.cdr;
129 | if (bindings === null) {
130 | return desugar(cons(intern("conj"), body), env);
131 | } else {
132 | var fn = list(intern("lambda"), bindings, cons(intern("conj"), body));
133 | var body1 = desugar(fn, env);
134 | var len = desugar(length(bindings), env);
135 | return meta(list(intern("apply/fresh-n"), len, body1),
136 | { tag: "fresh" });
137 | }
138 | case intern("lambda"):
139 | var bindings = exp.cdr.car;
140 | var body = exp.cdr.cdr;
141 | var norm = normalize_params(bindings);
142 | var env1 = foldl(norm.whole, env, function(e, b) { return cons(cons(b, b), e); });
143 | var body1 = desugar(cons(intern("begin"), body), env1);
144 | return meta(list(exp.car, norm.whole, body1),
145 | { tag: "lambda", params: norm });
146 | default:
147 | if(builtins.hasOwnProperty(exp.car.string)) {
148 | return meta(cons(meta(exp.car, { tag: "var" }), map(function(f) { return desugar(f, env); }, exp.cdr)),
149 | { tag: "app-builtin" });
150 | } else if (exp.car === intern("list")) {
151 | return meta(cons(meta(exp.car, { tag: "var" }), map(function(f) { return desugar(f, env); }, exp.cdr)),
152 | { tag: "app-builtin" });
153 | } else {
154 | throw new Error("unkown exp: " + pretty_print(exp));
155 | }
156 | }
157 | } else if(constantp(exp)) {
158 | return meta(exp, { tag: "const" });
159 | } else if(symbolp(exp)) {
160 | return meta(exp, { tag: "var" });
161 | } else {
162 | throw new Error("unkown exp: " + pretty_print(exp));
163 | }
164 | }
165 |
166 | function lookup(x, xs) {
167 | while(xs !== null) {
168 | if (x === xs.car.car) { return xs.car.cdr; }
169 | else { xs = xs.cdr; }
170 | } return false;
171 | }
172 |
173 | function extend_boxed(env, a, v) {
174 | var envu = env.get();
175 | var existing = lookup(a, envu);
176 | if (existing) {
177 | return existing;
178 | } else {
179 | env.set(cons(cons(a, v), envu));
180 | return v;
181 | }
182 | }
183 |
184 | function frees(exp, env, lenv, fenv) {
185 | switch(exp.meta.tag) {
186 | case "const": case "quoted":
187 | return exp;
188 | case "define":
189 | var name = exp.val.cdr.car;
190 | var dfenv = ref(null);
191 | // add self to env once mutable vars works, unless toplevel
192 | var ret = list(exp.val.car, name, frees(exp.val.cdr.cdr.car, env, lenv, dfenv));
193 | if(dfenv.get() === null) {
194 | return meta(ret, exp.meta);
195 | } else {
196 | throw ("free variables in define: " + name.string + pretty_print(map(car, dfenv.get())));
197 | }
198 | case "lambda":
199 | var bindings = exp.val.cdr.car;
200 | var body = exp.val.cdr.cdr;
201 | var e1 = foldl(bindings, env, function(e, a) { return cons(cons(a, a), e); });
202 | var inner_frees = ref(null);
203 | var proper_frees = null;
204 |
205 | var re = cons(exp.val.car, cons(bindings, map(function(x) {
206 | return frees(x, e1, bindings, inner_frees);
207 | }, body)));
208 |
209 | map(function(v) {
210 | if (!memq(v.car, bindings)) {
211 | extend_boxed(fenv, v.car, v.cdr);
212 | proper_frees = cons(v.cdr, proper_frees);
213 | }
214 | }, inner_frees.get());
215 |
216 | exp.meta.frees = proper_frees;
217 | return meta(re, exp.meta);
218 | case "begin": case "zzz": case "fresh":
219 | return meta(cons(exp.val.car, map(function(x) { return frees(x, env, lenv, fenv); }, exp.val.cdr)),
220 | exp.meta);
221 | case "app": case "app-builtin":
222 | return meta(map(function(x) { return frees(x, env, lenv, fenv); }, exp.val), exp.meta);
223 | case "var":
224 | if (memq(exp.val, lenv)) { return exp; }
225 | if (lookup(exp.val, env)) { return meta(extend_boxed(fenv, exp.val, exp.val), exp.meta); }
226 | if (toplevel.hasOwnProperty(exp.val.string)) { return exp; }
227 | if (exp.val === intern("list")) { return exp; } // TODO: remove once varargs added
228 | if (builtins.hasOwnProperty(exp.val.string)) { return exp; }
229 | return meta(extend_boxed(fenv, exp.val, exp.val), exp.meta);
230 | default:
231 | throw new Error("unkown exp: " + pretty_print(exp.val));
232 | }
233 | }
234 |
235 | // instead of returning a value, it returns a function that fetches a value
236 | // based on the offset of how far it takes to reach the variable
237 | // values in the env are expected to be :: offset -> cenv -> value
238 | function lookup_calc(x, xs) {
239 | var n = 0;
240 | while(xs !== null) {
241 | if (x === xs.car.car) { return xs.car.cdr(n); }
242 | else { n++; xs = xs.cdr; }
243 | } return false;
244 | }
245 |
246 | function augment_cenv(env, name) {
247 | var binding = cons(name, function (offset) { return function(aenv, cenv) { return cenv[offset]; }; });
248 | return cons(env.car, cons(binding, env.cdr));
249 | }
250 |
251 | function augment_aenv(env, name) {
252 | var binding = cons(name, function (offset) { return function(aenv, cenv) { return aenv[offset]; }; });
253 | return cons(cons(binding, env.car), env.cdr);
254 | }
255 |
256 | function augment_aenv_rest(env, name) {
257 | var binding = cons(name, function (offset) { return function(aenv, cenv) { return array_slice_list(aenv, offset); }; });
258 | return cons(cons(binding, env.car), env.cdr);
259 | }
260 |
261 | function lift_frees(exp) {
262 | var free_env = ref(null);
263 | var exp1 = frees(exp, null, null, free_env);
264 | var e1_c1 = foldl(free_env.get(), cons(null, 0),
265 | function(e_c, a) {
266 | var var1 = mkvar(e_c.cdr);
267 | var retrieve = function(_) { return function(_) { return var1; }; };
268 | return cons(cons(cons(a.cdr, retrieve), e_c.car), e_c.cdr + 1); });
269 | return list(exp1, e1_c1.car, Mks(Immutable.Map(), e1_c1.cdr, null, Immutable.Map()));
270 | }
271 |
272 | function eval0(exp, env) {
273 | if(exp.meta.constp) {
274 | exp.meta.constp = false;
275 | var val = eval0(exp, env)();
276 | return function(cenv) { return val; };
277 | }
278 | switch(exp.meta.tag) {
279 | case "app":
280 | var clos = eval0(exp.val.car, env);
281 | var args = foldl(reverse(exp.val.cdr), null, function(m, e) {
282 | return cons(eval0(e, env), m);
283 | });
284 | var len = length(args);
285 | return function(aenv, cenv) {
286 | var clos1 = clos(aenv, cenv);
287 | return clos1.car(build_env(len, args, aenv, cenv), clos1.cdr);
288 | };
289 | case "define":
290 | var result = eval0(exp.val.cdr.cdr.car, env);
291 | toplevel[exp.val.cdr.car.string].set(result());
292 | return function(aenv, cenv) { return true; };
293 | case "quoted":
294 | var val = exp.val.cdr.car;
295 | return function(aenv, cenv) { return val };
296 | case "begin":
297 | if (exp.val.cdr == null) { throw new Error("empty begin"); }
298 | else if (exp.val.cdr.cdr == null) {
299 | var e1 = eval0(exp.val.cdr.car, env);
300 | return e1;
301 | } else {
302 | return generate_begin_code(length(exp.val.cdr))(exp.val.cdr, env, eval0);
303 | }
304 | case "lambda":
305 | var bindings = exp.val.cdr.car;
306 | var body = exp.val.cdr.cdr.car;
307 | var free_env = foldl(reverse(exp.meta.frees), cons(null, null), augment_cenv);
308 | var env1_rest = foldl(exp.meta.params.rest, free_env, augment_aenv_rest);
309 | var env1 = foldl(reverse(exp.meta.params.normal), env1_rest, augment_aenv);
310 | var len = length(exp.meta.frees);
311 | var free_env1 = map(function(v) { return eval0(meta(v, { tag: "var" }), env); }, exp.meta.frees);
312 | var closure_body = eval0(body, env1);
313 | var closure_env_build = function(aenv, cenv) { return build_env(len, free_env1, aenv, cenv); };
314 | var closure = function(aenv, cenv) { return cons(closure_body, closure_env_build(aenv, cenv)); };
315 | return closure;
316 | case "zzz":
317 | var e1 = eval0(exp.val.cdr.car, env);
318 | return function(aenv, cenv) { return function(mks) { return function() { return e1(aenv, cenv)(mks); }; }; };
319 | case "fresh":
320 | var len = exp.val.cdr.car.val;
321 | var fn = exp.val.cdr.cdr.car;
322 | var closure = eval0(fn, env);
323 | return function(aenv, cenv) { return apply_fresh(len, closure, aenv, cenv); };
324 | case "app-builtin":
325 | if (exp.val.car.val === intern("list")) {
326 | var args = map(function(e) { return eval0(e, env); }, exp.val.cdr);
327 | return function(aenv, cenv) {
328 | return map(function(a) { return a(aenv, cenv); }, args);
329 | };
330 | }
331 | return builtins[exp.val.car.val.string](exp.val.cdr, env, eval0);
332 | case "const":
333 | var val = exp.val
334 | return function(aenv, cenv) { return val; };
335 | case "var":
336 | var v;
337 | v = lookup_calc(exp.val, env.car) || lookup_calc(exp.val, env.cdr);
338 | if (v) {
339 | return v;
340 | } else if(toplevel.hasOwnProperty(exp.val.string)) {
341 | var box = toplevel[exp.val.string];
342 | return function(aenv, cenv) { return box.get(); };
343 | } else {
344 | throw new Error("unbound variable: " + pretty_print(exp.val));
345 | }
346 | default:
347 | throw new Error("unkown exp: " + pretty_print(exp.val));
348 | }
349 | }
350 |
351 | var builtins = new Object(null);
352 | builtins["cons"] = generate_fn_code("cons", 2);
353 | builtins["conj/2"] = generate_fn_code("conj", 2);
354 | builtins["disj/2"] = generate_fn_code("disj", 2);
355 | builtins["=="] = generate_fn_code("eqeq", 2);
356 | builtins["=/="] = generate_fn_code("noteqeq", 2);
357 | builtins["symbolo"] = generate_fn_code("symbolo", 1);
358 | builtins["numbero"] = generate_fn_code("numbero", 1);
359 | builtins["absento"] = generate_fn_code("absento", 2);
360 | builtins["build-num"] = generate_fn_code("build_num", 1);
361 |
362 | function generate_fn_code(name, arity) {
363 | var c = 0;
364 | var evalers = [];
365 | var callers = [];
366 |
367 | for(c = 0; c < arity; c++) {
368 | evalers = evalers.concat(["var e", c, " = eval0(nth(args, ", c+1, "), env);\n"]);
369 | callers = callers.concat([["e", c, "(aenv, cenv)"].join("")]);
370 | }
371 |
372 | var args_evald = evalers.join("");
373 | var return_val = ["return function(aenv, cenv) { return ", name, "(", callers.join(", "), "); };"].join("");
374 | return new Function(["args, env, eval0"], [args_evald, return_val].join("\n"));
375 | }
376 |
377 | function generate_begin_code(arity) {
378 | var c = 0;
379 | var evalers = [];
380 | var callers = [];
381 |
382 | for(c = 0; c < arity; c++) {
383 | evalers = evalers.concat(["var e", c, " = eval0(nth(args, ", c+1, "), env);\n"]);
384 | var prefix = c < arity ? "" : "return ";
385 | callers = callers.concat([[prefix, "e", c, "(aenv, cenv)"].join("")]);
386 | }
387 |
388 | var args_evald = evalers.join("");
389 | var return_val = ["return function(aenv, cenv) { ", callers.join("; "), " };"].join("");
390 | return new Function(["args, env, eval0"], [args_evald, return_val].join("\n"));
391 | }
392 |
393 | function veval(exp, env) {
394 | return eval0(exp, env)([], []);
395 | }
396 |
397 | function build_env(len, e, aenv, cenv) {
398 | var new_env = new Array(len);
399 | var i = 0;
400 | while(e !== null) {
401 | new_env[i++] = e.car(aenv, cenv);
402 | e = e.cdr;
403 | } return new_env;
404 | }
405 |
406 | function fresh_n(n, c) {
407 | var m = new Array(n);
408 | while(n-- > 0) {
409 | m[n] = mkvar(c++);
410 | } return [m, c];
411 | }
412 |
413 | function apply_fresh(len, closure, aenv, cenv) {
414 | var closure1 = closure(aenv, cenv);
415 | var closure_env = closure1.cdr;
416 | var closure_fn = closure1.car;
417 | return function(mks) {
418 | var c = mks.counter;
419 | var e1_c1 = fresh_n(len, c);
420 | var mks1 = Mks(mks.substitution, e1_c1[1], mks.prefix, mks.constraint_store);
421 | return closure_fn(e1_c1[0], closure_env)(mks1);
422 | };
423 | }
424 |
425 | function map_stream(fn, stream) {
426 | return function() {
427 | var $ = pull(stream);
428 | return ($ == null) ? null : cons(fn($.car), map_stream(fn, $.cdr));
429 | };
430 | }
431 |
432 | function query_stream(q, qenv, mks) {
433 | var $ = q(mks);
434 | var run_queries = function(mks) {
435 | var qm = map(function(p) { return cons(p.car.string, p.cdr()()); }, qenv);
436 | return query_map(qm, mks);
437 | };
438 | return map_stream(run_queries, $);
439 | }
440 |
441 | function stream_generator($) {
442 | var next = $;
443 | return function() {
444 | var cur = next();
445 | if(cur == null) { return null; }
446 | else { next = cur.cdr;
447 | return cur.car; }
448 | };
449 | }
450 |
451 | function run_expression(p) {
452 | var desugared = desugar(p, null);
453 | var lifted = lift_frees(desugared);
454 |
455 | var exp = lifted.car;
456 | var env = cons(null, lifted.cdr.car);
457 | var mks = lifted.cdr.cdr.car;
458 | var evald = veval(exp, env);
459 |
460 | if(procedurep(evald)) {
461 | var q$ = query_stream(evald, env.cdr, mks);
462 | return stream_generator(q$);
463 | } else if (env.cdr === null) {
464 | return evald;
465 | } else {
466 | throw "unbound variables: " + pretty_print(map(car, env.cdr));
467 | }
468 | }
469 |
470 | function run_program(p) {
471 | var stream;
472 | if(p == null) { throw "no program" }
473 | map(register_define, p);
474 | while(p != null) {
475 | stream = run_expression(p.car);
476 | p = p.cdr;
477 | } return stream;
478 | }
479 |
480 | this.reset = function() { toplevel = new Object(null); };
481 | this.eval = function(ast) { return run_program(ast); };
482 | this.read_eval = function(text) { return run_program(read_program(text)); };
483 | }
484 |
--------------------------------------------------------------------------------
/ck/editor.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | editor
23 |
24 |
25 |
26 | demos:create file
29 | save file
30 |
31 |
32 | relational interpreter
33 |
136 |
137 |
138 | type inference
139 |
197 |
198 |
199 | numbers
200 |
496 |
497 |
498 | lists
499 |
521 |
522 |
523 | grammar
524 |
570 |
571 |
573 |
574 |
575 |
576 |
--------------------------------------------------------------------------------
/editor.css:
--------------------------------------------------------------------------------
1 | body {
2 | padding:0;
3 | margin: 0;
4 | font-family:courier, monospace;
5 | height:100vh;
6 | background-color:#ccc
7 | }
8 |
9 | #container { height:90%; }
10 | #demos { display:none; }
11 |
--------------------------------------------------------------------------------
/editor.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | editor
23 |
24 |
25 |
26 | demos:create file
29 | save file
30 | create link
31 |
32 |
33 |
34 | relational interpreter
35 |
138 |
139 |
140 | type inference
141 |
199 |
200 |
201 | numbers
202 |
498 |
499 |
500 | reasoned schemer prelude
501 |
582 |
583 |
584 | grammar
585 |
631 |
632 |
634 |
635 |
636 |
637 |
--------------------------------------------------------------------------------
/editor.js:
--------------------------------------------------------------------------------
1 | function load_editor() {
2 | var veneer = new Veneer_v1();
3 |
4 | var vm = veneer.new_vm();
5 |
6 | var ed = veneer.new_editor(document.getElementById("container"), vm);
7 | var editor = ed.editor;
8 | var repl = ed.repl;
9 | var errors = ed.errors;
10 | var dump_button = ed.dump_button;
11 |
12 | var demo = false;
13 | var loaded_file = false;
14 | function setEditorValue(val) {
15 | demo = false;
16 | loaded_file = false;
17 | editor.setValue(val);
18 | }
19 |
20 | var demos = document.getElementsByClassName("demo");
21 | var demo_picker = document.getElementById("demo_picker");
22 | var file_values = new Array(demos.length);
23 | for(var i=0; i < demos.length; i++ ) {
24 | var selection = document.createElement("option");
25 | var name = demos[i].getElementsByClassName("title")[0].textContent;
26 | file_values[i] = demos[i].getElementsByClassName("content")[0].value;
27 | selection.value = i;
28 | selection.appendChild(document.createTextNode(name));
29 | demo_picker.appendChild(selection);
30 | }
31 | demo_picker.onchange = function() {
32 | load_demo(demo_picker.selectedIndex);
33 | };
34 | demo_picker.value = "0";
35 | setEditorValue(file_values[0]);
36 | demo = 0;
37 |
38 | var ls_picker = document.getElementById("localstorage_picker");
39 | var files = JSON.parse(localStorage.getItem('__index__') || "[]");
40 | for(var i=0; i < files.length; i++ ) {
41 | var selection = document.createElement("option");
42 | var name = files[i];
43 | selection.value = name;
44 | selection.appendChild(document.createTextNode(name));
45 | ls_picker.appendChild(selection);
46 | }
47 | ls_picker.onchange = function() {
48 | load_file(ls_picker[ls_picker.selectedIndex].value);
49 | };
50 | document.getElementById("save_file").onclick = save_current;
51 | document.getElementById("new_file").onclick = add_file;
52 |
53 | document.getElementById("create_link").onclick = function() {
54 | var req = new XMLHttpRequest();
55 | var method = "POST";
56 | var url = "https://api.github.com/gists";
57 |
58 | var options = {
59 | "description": "veneer save",
60 | "public": true,
61 | "files": {
62 | "file": {
63 | "content": editor.getValue()
64 | }
65 | }
66 | };
67 |
68 | req.open(method, url, true);
69 | req.onreadystatechange = function () {
70 | if (req.readyState !== XMLHttpRequest.DONE) {
71 | return;
72 | }
73 | if (req.status === 201) {
74 | var response = JSON.parse(req.responseText);
75 | window.location.hash = response.id;
76 | }
77 | };
78 | req.send(JSON.stringify(options));
79 | };
80 |
81 |
82 | function confirm_overwrite(name) {
83 | return window.confirm("File exists: Are you sure you want to over-write \"" + name + "\"");
84 | }
85 | function pick_filename() {
86 | return window.prompt("save file as:","default");
87 | }
88 | function confirm_save_progress() {
89 | return window.confirm("Save progress before switching?");
90 | }
91 |
92 | function load_demo(id) {
93 | var save_status = true;
94 | if (demo !== id) { save_status = save_current(true); }
95 | if(save_status) {
96 | var demo_val = file_values[id];
97 | setEditorValue(demo_val);
98 | demo = id;
99 | }
100 | }
101 |
102 | function load_file(name) {
103 | var save_status = true;
104 | if (loaded_file !== name) { save_status = save_current(true); }
105 | if(save_status) {
106 | var new_val = localStorage.getItem(name);
107 | setEditorValue(new_val);
108 | loaded_file = name;
109 | }
110 | }
111 |
112 | function save_current(for_change) {
113 | if (loaded_file !== false) {
114 | if(editor.getValue() !== localStorage.getItem(loaded_file)) {
115 |
116 | if(for_change === true && !confirm_save_progress()) {
117 | return true;
118 | }
119 |
120 | loaded_file = confirm_overwrite(loaded_file) ? loaded_file : false;
121 | }
122 | } else if (demo !== false) {
123 | if (editor.getValue() !== file_values[demo]) {
124 |
125 | if(for_change === true && !confirm_save_progress()) {
126 | return true;
127 | }
128 |
129 | loaded_file = window.prompt("save progress as: ", "default") || false;
130 | } else if (for_change === true) {
131 | return true;
132 | }
133 | }
134 |
135 | if(!loaded_file) { return false; }
136 | demo = false;
137 |
138 | if(files.indexOf(loaded_file) < 0) {
139 | files.push(loaded_file);
140 |
141 | var selection = document.createElement("option");
142 | selection.appendChild(document.createTextNode(loaded_file));
143 | ls_picker.appendChild(selection);
144 | ls_picker.value = loaded_file;
145 | localStorage.setItem('__index__', JSON.stringify(files));
146 | };
147 | localStorage.setItem(loaded_file, editor.getValue());
148 | return true;
149 | }
150 |
151 | function add_file() {
152 | if(save_current(true)) { setEditorValue(''); }
153 | }
154 |
155 | if(window.location.hash) {
156 | var req = new XMLHttpRequest();
157 | var method = "GET";
158 | var url = "https://api.github.com/gists/" + window.location.hash.substring(1);
159 |
160 | req.open(method, url, true);
161 | req.onreadystatechange = function () {
162 | if (req.readyState !== XMLHttpRequest.DONE) {
163 | return;
164 | }
165 | if (req.status === 200) {
166 | var response = JSON.parse(req.responseText);
167 | setEditorValue(response.files.file.content);
168 | }
169 | };
170 | req.send();
171 | }
172 | }
173 |
--------------------------------------------------------------------------------
/eval.js:
--------------------------------------------------------------------------------
1 | function VeneerVM() {
2 | var toplevel = new Object(null);
3 |
4 | function register_define(exp) {
5 | if (pairp(exp) && exp.car === intern("define")) {
6 | var a = pairp(exp.cdr.car) ? exp.cdr.car.car : exp.cdr.car;
7 | toplevel[a.string] = ref(null);
8 | }
9 | }
10 |
11 | function quote_desugar(exp) {
12 | if (pairp(exp)) {
13 | return meta(list(meta(intern("cons"), {tag:"var"}), quote_desugar(exp.car), quote_desugar(exp.cdr)), {tag:"app-builtin"});
14 | } else if (exp === null) {
15 | return meta(list(intern("quote"), null), { tag: "quoted" });
16 | } else if(constantp(exp)) {
17 | return meta(exp, {tag:"const"});
18 | } else {
19 | return meta(list(intern("quote"), exp), { tag: "quoted" });
20 | }
21 | }
22 |
23 | function quasiquote_desugar(exp, n, env) {
24 | if (pairp(exp)) {
25 | if (exp.car === intern("unquote")) {
26 | if (n === 1) {
27 | return exp.cdr.car;
28 | } else {
29 | return list(intern("list"), list(intern("quote"), intern("unquote")),
30 | quasiquote_desugar(exp.cdr.car, n - 1, env));
31 | }
32 | } else if (exp.car === intern("quasiquote")) {
33 | return list(intern("list"), list(intern("quote"), intern("quasiquote")),
34 | quasiquote_desugar(exp.cdr.car, n + 1, env));
35 | } else {
36 | return list(intern("cons"), quasiquote_desugar(exp.car, n, env),
37 | quasiquote_desugar(exp.cdr, n, env));
38 | }
39 | } else {
40 | return list(intern("quote"), exp);
41 | }
42 | }
43 |
44 | function Meta(val, meta) {
45 | this.val = val;
46 | this.meta = meta || {};
47 | }
48 | Meta.prototype.toString = function() {
49 | return pretty_print(this.val);
50 | }
51 | function meta(v, meta) { return new Meta(v, meta); }
52 |
53 | function normalize_params(params) {
54 | var ps = null;
55 | var rest = null;
56 | var whole = null;
57 | while(params !== null) {
58 | if(symbolp(params)) {
59 | rest = cons(params, rest);
60 | whole = cons(params, ps);
61 | break;
62 | } else {
63 | ps = cons(params.car, ps);
64 | whole = ps;
65 | params = params.cdr;
66 | }
67 | }
68 | var normal = reverse(ps);
69 | var whole = reverse(whole);
70 | var min_args = length(normal);
71 | return { normal: normal, rest: rest, whole: whole, min_args: min_args };
72 | }
73 |
74 | function desugar(exp, env) {
75 | if(pairp(exp)) {
76 | // application
77 | var app = false;
78 | if(symbolp(exp.car) && (lookup(exp.car, env) || toplevel.hasOwnProperty(exp.car.string))
79 | || pairp(exp.car)) {
80 | return meta(map(function(e) { return desugar(e, env); }, exp),
81 | { tag: "app" });
82 | }
83 | // special forms & builtins
84 | switch(exp.car) {
85 | case intern("define"):
86 | var name;
87 | var body;
88 | if(pairp(exp.cdr.car)) {
89 | // (define (x y z) f) => (define x (lambda (y z) f))
90 | name = exp.cdr.car.car;
91 | body = cons(intern("lambda"), cons(exp.cdr.car.cdr, exp.cdr.cdr));
92 | } else {
93 | name = exp.cdr.car;
94 | body = exp.cdr.cdr.car;
95 | }
96 | return meta(list(exp.car, name, desugar(body, env)), { tag: "define" });
97 | case intern("quote"):
98 | var val = quote_desugar(exp.cdr.car);
99 | val.meta.constp = true;
100 | return val;
101 | case intern("quasiquote"):
102 | return desugar(quasiquote_desugar(exp.cdr.car, 1, env), env);
103 | case intern("zzz"):
104 | return meta(list(exp.car, desugar(exp.cdr.car, env)),
105 | { tag: "zzz" });
106 | case intern("conde"):
107 | var clauses = map(function(row) { return cons(intern("conj"), row); }, exp.cdr);
108 | return desugar(cons(intern("disj"), clauses), env);
109 | case intern("conj"):
110 | if (exp.cdr === null) { throw "error: empty conj"; }
111 | else if (exp.cdr.cdr === null) {
112 | var e1 = desugar(list(intern("zzz"), exp.cdr.car), env);
113 | return e1;
114 | } else {
115 | var e1 = list(intern("zzz"), exp.cdr.car);
116 | var e2 = cons(intern("conj"), exp.cdr.cdr);
117 | return desugar(list(intern("conj/2"), e1, e2), env);
118 | }
119 | case intern("disj"):
120 | if (exp.cdr === null) { throw "error: empty disj"; }
121 | else if (exp.cdr.cdr === null) {
122 | var e1 = desugar(list(intern("zzz"), exp.cdr.car), env);
123 | return e1;
124 | } else {
125 | var e1 = list(intern("zzz"), exp.cdr.car);
126 | var e2 = cons(intern("disj"), exp.cdr.cdr);
127 | return desugar(list(intern("disj/2"), e1, e2), env);
128 | }
129 | case intern("conde/dfs"):
130 | var clauses = map(function(row) { return cons(intern("conj/dfs"), row); }, exp.cdr);
131 | return desugar(cons(intern("disj/dfs"), clauses), env);
132 | case intern("conj/dfs"):
133 | if (exp.cdr === null) { throw "error: empty conj"; }
134 | else if (exp.cdr.cdr === null) {
135 | var e1 = desugar(list(intern("zzz"), exp.cdr.car), env);
136 | return e1;
137 | } else {
138 | var e1 = list(intern("zzz"), exp.cdr.car);
139 | var e2 = cons(intern("conj/dfs"), exp.cdr.cdr);
140 | return desugar(list(intern("conj/dfs/2"), e1, e2), env);
141 | }
142 | case intern("disj/dfs"):
143 | if (exp.cdr === null) { throw "error: empty disj"; }
144 | else if (exp.cdr.cdr === null) {
145 | var e1 = desugar(list(intern("zzz"), exp.cdr.car), env);
146 | return e1;
147 | } else {
148 | var e1 = list(intern("zzz"), exp.cdr.car);
149 | var e2 = cons(intern("disj/dfs"), exp.cdr.cdr);
150 | return desugar(list(intern("disj/dfs/2"), e1, e2), env);
151 | }
152 | case intern("begin"):
153 | return meta(cons(exp.car, map(function(f) { return desugar(f, env); }, exp.cdr)),
154 | { tag: "begin" });
155 | case intern("if"):
156 | return meta(cons(exp.car, map(function(f) { return desugar(f, env); }, exp.cdr)),
157 | { tag: "if" });
158 |
159 | case intern("and"):
160 | if (exp.cdr === null) {
161 | // (and) => true
162 | return desugar(true, env);
163 | } else if (exp.cdr.cdr === null) {
164 | // (and a) => a
165 | return desugar(exp.cdr.car, env);
166 | } else {
167 | // (and a . r) => (if a (and . r) #f)
168 | return desugar(list(intern("if"), exp.cdr.car,
169 | cons(intern("and"), exp.cdr.cdr),
170 | false),
171 | env);
172 | }
173 | case intern("or"):
174 | if (exp.cdr === null) {
175 | // (or) => false
176 | return desugar(false, env);
177 | } else if (exp.cdr.cdr === null) {
178 | // (or a) => a
179 | return desugar(exp.cdr.car, env);
180 | } else {
181 | // (or a . r) => (let ((tmp a)) (if tmp tmp (or . r)))
182 | var tmp = gensym("tmp");
183 | return desugar(list(intern("let"), list(list(tmp, exp.cdr.car)),
184 | list(intern("if"), tmp, tmp, cons(intern("or"), exp.cdr.cdr))),
185 | env);
186 | }
187 | case intern("cond"):
188 | if (exp.cdr === null) {
189 | throw "error: empty cond";
190 | } else if(exp.cdr.cdr === null) {
191 | if(exp.cdr.car.car === intern("else")) {
192 | // (cond (else . x)) => (begin . x)
193 | return desugar(cons(intern("begin"), exp.cdr.car.cdr), env);
194 | } else {
195 | // (cond (a . b)) => (if a (begin . b) #f)
196 | return desugar(list(intern("if"), exp.cdr.car.car,
197 | cons(intern("begin"), exp.cdr.car.cdr),
198 | false),
199 | env);
200 | }
201 | } else {
202 | // (cond (a . b) . r) => (if a (begin . b) (cond . r))
203 | return desugar(list(intern("if"), exp.cdr.car.car,
204 | cons(intern("begin"), exp.cdr.car.cdr),
205 | cons(intern("cond"), exp.cdr.cdr)),
206 | env);
207 | }
208 | case intern("let"):
209 | // (let ((a b) ...) . body) => ((lambda (a ...) . body) b ...)
210 | return desugar(cons(cons(intern("lambda"), cons(map(car, exp.cdr.car), exp.cdr.cdr)),
211 | map(function(e) { return e.cdr.car; }, exp.cdr.car)),
212 | env);
213 | case intern("fresh"):
214 | var bindings = exp.cdr.car;
215 | var body = exp.cdr.cdr;
216 | if (bindings === null) {
217 | return desugar(cons(intern("conj"), body), env);
218 | } else {
219 | var fn = list(intern("lambda"), bindings, cons(intern("conj"), body));
220 | var body1 = desugar(fn, env);
221 | var len = desugar(length(bindings), env);
222 | return meta(list(intern("apply/fresh-n"), len, body1),
223 | { tag: "fresh" });
224 | }
225 | case intern("fresh/dfs"):
226 | var bindings = exp.cdr.car;
227 | var body = exp.cdr.cdr;
228 | if (bindings === null) {
229 | return desugar(cons(intern("conj/dfs"), body), env);
230 | } else {
231 | var fn = list(intern("lambda"), bindings, cons(intern("conj/dfs"), body));
232 | var body1 = desugar(fn, env);
233 | var len = desugar(length(bindings), env);
234 | return meta(list(intern("apply/fresh-n"), len, body1),
235 | { tag: "fresh" });
236 | }
237 | case intern("lambda"):
238 | var bindings = exp.cdr.car;
239 | var body = exp.cdr.cdr;
240 | var norm = normalize_params(bindings);
241 | var env1 = foldl(norm.whole, env, function(e, b) { return cons(cons(b, b), e); });
242 | var body1 = desugar(cons(intern("begin"), body), env1);
243 | return meta(list(exp.car, norm.whole, body1),
244 | { tag: "lambda", params: norm });
245 | default:
246 | if(builtins.hasOwnProperty(exp.car.string)) {
247 | return meta(cons(meta(exp.car, { tag: "var" }), map(function(f) { return desugar(f, env); }, exp.cdr)),
248 | { tag: "app-builtin" });
249 | } else if (exp.car === intern("list")) {
250 | return meta(cons(meta(exp.car, { tag: "var" }), map(function(f) { return desugar(f, env); }, exp.cdr)),
251 | { tag: "app-builtin" });
252 | } else {
253 | throw new Error("unkown exp: " + pretty_print(exp));
254 | }
255 | }
256 | } else if(constantp(exp)) {
257 | return meta(exp, { tag: "const" });
258 | } else if(symbolp(exp)) {
259 | return meta(exp, { tag: "var" });
260 | } else {
261 | throw new Error("unkown exp: " + pretty_print(exp));
262 | }
263 | }
264 |
265 | function lookup(x, xs) {
266 | while(xs !== null) {
267 | if (x === xs.car.car) { return xs.car.cdr; }
268 | else { xs = xs.cdr; }
269 | } return false;
270 | }
271 |
272 | function extend_boxed(env, a, v) {
273 | var envu = env.get();
274 | var existing = lookup(a, envu);
275 | if (existing) {
276 | return existing;
277 | } else {
278 | env.set(cons(cons(a, v), envu));
279 | return v;
280 | }
281 | }
282 |
283 | function frees(exp, env, lenv, fenv) {
284 | switch(exp.meta.tag) {
285 | case "const": case "quoted":
286 | return exp;
287 | case "define":
288 | var name = exp.val.cdr.car;
289 | var dfenv = ref(null);
290 | // add self to env once mutable vars works, unless toplevel
291 | var ret = list(exp.val.car, name, frees(exp.val.cdr.cdr.car, env, lenv, dfenv));
292 | if(dfenv.get() === null) {
293 | return meta(ret, exp.meta);
294 | } else {
295 | throw ("free variables in define: " + name.string + pretty_print(map(car, dfenv.get())));
296 | }
297 | case "begin": case "zzz": case "fresh":
298 | return meta(cons(exp.val.car, map(function(x) { return frees(x, env, lenv, fenv); }, exp.val.cdr)),
299 | exp.meta);
300 | case "if":
301 | return meta(cons(exp.val.car, map(function(x) { return frees(x, env, lenv, fenv); }, exp.val.cdr)),
302 | exp.meta);
303 | case "lambda":
304 | var bindings = exp.val.cdr.car;
305 | var body = exp.val.cdr.cdr;
306 | var e1 = foldl(bindings, env, function(e, a) { return cons(cons(a, a), e); });
307 | var inner_frees = ref(null);
308 | var proper_frees = null;
309 |
310 | var re = cons(exp.val.car, cons(bindings, map(function(x) {
311 | return frees(x, e1, bindings, inner_frees);
312 | }, body)));
313 |
314 | map(function(v) {
315 | if (!memq(v.car, bindings)) {
316 | extend_boxed(fenv, v.car, v.cdr);
317 | proper_frees = cons(v.cdr, proper_frees);
318 | }
319 | }, inner_frees.get());
320 |
321 | exp.meta.frees = proper_frees;
322 | return meta(re, exp.meta);
323 | case "app": case "app-builtin":
324 | return meta(map(function(x) { return frees(x, env, lenv, fenv); }, exp.val), exp.meta);
325 | case "var":
326 | if (memq(exp.val, lenv)) { return exp; }
327 | if (lookup(exp.val, env)) { return meta(extend_boxed(fenv, exp.val, exp.val), exp.meta); }
328 | if (toplevel.hasOwnProperty(exp.val.string)) { return exp; }
329 | if (exp.val === intern("list")) { return exp; } // TODO: remove once varargs added
330 | if (builtins.hasOwnProperty(exp.val.string)) { return exp; }
331 | return meta(extend_boxed(fenv, exp.val, exp.val), exp.meta);
332 | default:
333 | throw new Error("unkown exp: " + pretty_print(exp.val));
334 | }
335 | }
336 |
337 | function lookup_calc(x, xs) {
338 | var n = 0;
339 | while(xs !== null) {
340 | if (x === xs.car.car) { return xs.car.cdr(n); }
341 | else { n++; xs = xs.cdr; }
342 | } return false;
343 | }
344 |
345 | function augment_cenv(env, name) {
346 | var binding = cons(name, function (offset) { return function(aenv, cenv) { return cenv[offset]; }; });
347 | return cons(env.car, cons(binding, env.cdr));
348 | }
349 |
350 | function augment_aenv(env, name) {
351 | var binding = cons(name, function (offset) { return function(aenv, cenv) { return aenv[offset]; }; });
352 | return cons(cons(binding, env.car), env.cdr);
353 | }
354 |
355 | function augment_aenv_rest(env, name) {
356 | var binding = cons(name, function (offset) { return function(aenv, cenv) { return array_slice_list(aenv, offset); }; });
357 | return cons(cons(binding, env.car), env.cdr);
358 | }
359 |
360 | function lift_frees(exp) {
361 | var free_env = ref(null);
362 | var exp1 = frees(exp, null, null, free_env);
363 | var e1_c1 = foldl(free_env.get(), cons(null, 0),
364 | function(e_c, a) {
365 | var var1 = mkvar(e_c.cdr);
366 | var retrieve = function(_) { return function(_) { return var1; }; };
367 | return cons(cons(cons(a.cdr, retrieve), e_c.car), e_c.cdr + 1); });
368 | return list(exp1, e1_c1.car, Mks(Immutable.Map(), e1_c1.cdr, null, Immutable.Map(), null, Immutable.Map()));
369 | }
370 |
371 | function eval0(exp, env) {
372 | if(exp.meta.constp) {
373 | exp.meta.constp = false;
374 | var val = eval0(exp, env)();
375 | return function(cenv) { return val; };
376 | }
377 | switch(exp.meta.tag) {
378 | case "app":
379 | var clos = eval0(exp.val.car, env);
380 | var args = foldl(reverse(exp.val.cdr), null, function(m, e) {
381 | return cons(eval0(e, env), m);
382 | });
383 | var len = length(args);
384 | return function(aenv, cenv) {
385 | var clos1 = clos(aenv, cenv);
386 | var args1 = build_env(len, args, aenv, cenv);
387 | if (len < clos1[2]) {
388 | arity_error(clos1[2], len, exp, args1);
389 | } else if (!clos1[3] && len > clos1[2]) {
390 | arity_error(clos1[2], len, exp, args1);
391 | } else {
392 | return clos1[0](args1, clos1[1]);
393 | }
394 | };
395 | case "define":
396 | var result = eval0(exp.val.cdr.cdr.car, env);
397 | toplevel[exp.val.cdr.car.string].set(result());
398 | return function(aenv, cenv) { return true; };
399 | case "quoted":
400 | var val = exp.val.cdr.car;
401 | return function(aenv, cenv) { return val };
402 | case "begin":
403 | if (exp.val.cdr == null) { throw new Error("empty begin"); }
404 | else if (exp.val.cdr.cdr == null) {
405 | var e1 = eval0(exp.val.cdr.car, env);
406 | return e1;
407 | } else {
408 | return generate_begin_code(length(exp.val.cdr))(exp.val.cdr, env, eval0);
409 | }
410 | case "if":
411 | var t = eval0(exp.val.cdr.car, env);
412 | var c = eval0(exp.val.cdr.cdr.car, env);
413 | var a = eval0(exp.val.cdr.cdr.cdr.car, env);
414 | return function(aenv, cenv) { return t(aenv, cenv) ? c(aenv, cenv) : a(aenv, cenv); };
415 | case "lambda":
416 | var bindings = exp.val.cdr.car;
417 | var min_args = exp.meta.params.min_args;
418 | var restp = !(exp.meta.params.rest === null);
419 | var body = exp.val.cdr.cdr.car;
420 | var free_env = foldl(reverse(exp.meta.frees), cons(null, null), augment_cenv);
421 | var env1_rest = foldl(exp.meta.params.rest, free_env, augment_aenv_rest);
422 | var env1 = foldl(reverse(exp.meta.params.normal), env1_rest, augment_aenv);
423 | var len = length(exp.meta.frees);
424 | var free_env1 = map(function(v) { return eval0(meta(v, { tag: "var" }), env); }, exp.meta.frees);
425 | var closure_body = eval0(body, env1);
426 | var closure = function(aenv, cenv) {
427 | return [closure_body, build_env(len, free_env1, aenv, cenv), min_args, restp];
428 | };
429 | return closure;
430 | case "zzz":
431 | var e1 = eval0(exp.val.cdr.car, env);
432 | return function(aenv, cenv) { return function(mks) { return function() { return e1(aenv, cenv)(mks); }; }; };
433 | case "fresh":
434 | var len = exp.val.cdr.car.val;
435 | var fn = exp.val.cdr.cdr.car;
436 | var closure = eval0(fn, env);
437 | return function(aenv, cenv) { return apply_fresh(len, closure, aenv, cenv); };
438 | case "app-builtin":
439 | if (exp.val.car.val === intern("list")) {
440 | var args = map(function(e) { return eval0(e, env); }, exp.val.cdr);
441 | return function(aenv, cenv) {
442 | return map(function(a) { return a(aenv, cenv); }, args);
443 | };
444 | }
445 | return builtins[exp.val.car.val.string](exp.val.cdr, env, eval0);
446 | case "const":
447 | var val = exp.val
448 | return function(aenv, cenv) { return val; };
449 | case "var":
450 | var v;
451 | v = lookup_calc(exp.val, env.car) || lookup_calc(exp.val, env.cdr);
452 | if (v) {
453 | return v;
454 | } else if(toplevel.hasOwnProperty(exp.val.string)) {
455 | var box = toplevel[exp.val.string];
456 | return function(aenv, cenv) { return box.get(); };
457 | } else {
458 | throw new Error("unbound variable: " + pretty_print(exp.val));
459 | }
460 | default:
461 | throw new Error("unkown exp: " + pretty_print(exp.val));
462 | }
463 | }
464 |
465 | var builtins = new Object(null);
466 | builtins["cons"] = generate_fn_code("cons", 2);
467 | builtins["car"] = generate_fn_code("car", 1);
468 | builtins["cdr"] = generate_fn_code("cdr", 1);
469 | builtins["null?"] = generate_fn_code("nullp", 1);
470 | builtins["number?"] = generate_fn_code("numberp", 1);
471 | builtins["+"] = generate_fn_code("+", 2, true);
472 | builtins["-"] = generate_fn_code("-", 2, true);
473 | builtins["*"] = generate_fn_code("*", 2, true);
474 | builtins["/"] = generate_fn_code("/", 2, true);
475 | builtins["quotient"] = generate_fn_code("quotient", 2);
476 | builtins["="] = generate_fn_code("===", 2, true);
477 | builtins[">"] = generate_fn_code(">", 2, true);
478 | builtins["<"] = generate_fn_code("<", 2, true);
479 | builtins[">="] = generate_fn_code(">=", 2, true);
480 | builtins["<="] = generate_fn_code("<=", 2, true);
481 | builtins["odd?"] = generate_fn_code("oddp", 1);
482 | builtins["even?"] = generate_fn_code("evenp", 1);
483 | builtins["zero?"] = generate_fn_code("zerop", 1);
484 | builtins["eq?"] = generate_fn_code("===", 2, true);
485 | builtins["not"] = generate_fn_code("not", 1);
486 | builtins["log"] = generate_fn_code("console.log", 1);
487 | builtins["gensym"] = generate_fn_code("gensym", 1);
488 | builtins["reverse"] = generate_fn_code("reverse", 1);
489 | builtins["append"] = generate_fn_code("append", 2);
490 | builtins["make-list"] = generate_fn_code("make_list", 2);
491 |
492 | builtins["conj/2"] = generate_fn_code("conj", 2);
493 | builtins["disj/2"] = generate_fn_code("disj", 2);
494 | builtins["conj/dfs/2"] = generate_fn_code("conj_dfs", 2);
495 | builtins["disj/dfs/2"] = generate_fn_code("disj_dfs", 2);
496 | builtins["=="] = generate_fn_code("eqeq", 2);
497 | builtins["=/="] = generate_fn_code("noteqeq", 2);
498 | builtins["symbolo"] = generate_fn_code("symbolo", 1);
499 | builtins["numbero"] = generate_fn_code("numbero", 1);
500 | builtins["absento"] = generate_fn_code("absento", 2);
501 | builtins["build-num"] = generate_fn_code("build_num", 1);
502 | builtins["watch"] = generate_fn_code("watch", 2);
503 |
504 | function generate_fn_code(name, arity, infixp) {
505 | var c = 0;
506 | var evalers = [];
507 | var callers = [];
508 |
509 | for(c = 0; c < arity; c++) {
510 | evalers = evalers.concat(["var e", c, " = eval0(args.car, env);\n"]);
511 | evalers = evalers.concat(["args = args.cdr;\n"]);
512 | callers = callers.concat([["e", c, "(aenv, cenv)"].join("")]);
513 | }
514 | var args_evald = evalers.join("");
515 |
516 | var return_val;
517 | if (infixp === true) {
518 | return_val = ["return function(aenv, cenv) { return ", callers[0], " ", name, " ", callers[1], "; };"].join("");
519 | } else {
520 | return_val = ["return function(aenv, cenv) { return ", name, "(", callers.join(", "), "); };"].join("");
521 | }
522 | return new Function(["args, env, eval0"], [args_evald, return_val].join("\n"));
523 | }
524 |
525 | function generate_begin_code(arity) {
526 | var c = 0;
527 | var evalers = [];
528 | var callers = [];
529 |
530 | for(c = 0; c < arity; c++) {
531 | evalers = evalers.concat(["var e", c, " = eval0(nth(args, ", c+1, "), env);\n"]);
532 | var prefix = c < arity ? "" : "return ";
533 | callers = callers.concat([[prefix, "e", c, "(aenv, cenv)"].join("")]);
534 | }
535 |
536 | var args_evald = evalers.join("");
537 | var return_val = ["return function(aenv, cenv) { ", callers.join("; "), " };"].join("");
538 | return new Function(["args, env, eval0"], [args_evald, return_val].join("\n"));
539 | }
540 |
541 | function veval(exp, env) {
542 | return eval0(exp, env)([], []);
543 | }
544 |
545 | function build_env(len, e, aenv, cenv) {
546 | var new_env = new Array(len);
547 | var i = 0;
548 | while(e !== null) {
549 | new_env[i++] = e.car(aenv, cenv);
550 | e = e.cdr;
551 | } return new_env;
552 | }
553 |
554 | function fresh_n(n, c) {
555 | var m = new Array(n);
556 | while(n-- > 0) {
557 | m[n] = mkvar(c++);
558 | } return [m, c];
559 | }
560 |
561 | function apply_fresh(len, closure, aenv, cenv) {
562 | var closure1 = closure(aenv, cenv);
563 | var closure_env = closure1[1];
564 | var closure_fn = closure1[0];
565 | return function(mks) {
566 | var c = mks.counter;
567 | var e1_c1 = fresh_n(len, c);
568 | var mks1 = Mks(mks.substitution, e1_c1[1], mks.diseq, mks.types, mks.absentee, mks.watch);
569 | return closure_fn(e1_c1[0], closure_env)(mks1);
570 | };
571 | }
572 |
573 | function arity_error(expected, recieved, exp, values) {
574 | throw ["Error: Invalid argument count in application",
575 | "\nExpected: ", expected,
576 | "\nRecieved: ", recieved,
577 | "\nExpression: ", pretty_print(exp),
578 | "\nValues:", JSON.stringify(values)].join("");
579 | }
580 |
581 | function map_stream(fn, stream) {
582 | return function() {
583 | var $ = pull(stream);
584 | return ($ == null) ? null : cons(fn($.car), map_stream(fn, $.cdr));
585 | };
586 | }
587 |
588 | function query_stream(q, qenv, mks) {
589 | var $ = q(mks);
590 | var run_queries = function(mks) {
591 | var qm = map(function(p) { return cons(p.car.string, p.cdr()()); }, qenv);
592 | return query_map(qm, mks);
593 | };
594 | return map_stream(run_queries, $);
595 | }
596 |
597 | function stream_generator($) {
598 | var next = $;
599 | return function() {
600 | var cur = next();
601 | if(cur == null) { return null; }
602 | else { next = cur.cdr;
603 | return cur.car; }
604 | };
605 | }
606 |
607 | function run_expression(p) {
608 | var desugared = desugar(p, null);
609 | var lifted = lift_frees(desugared);
610 |
611 | var exp = lifted.car;
612 | var env = cons(null, lifted.cdr.car);
613 | var mks = lifted.cdr.cdr.car;
614 | var evald = veval(exp, env);
615 |
616 | if(procedurep(evald)) {
617 | var q$ = query_stream(evald, env.cdr, mks);
618 | return stream_generator(q$);
619 | } else if (env.cdr === null) {
620 | return evald;
621 | } else {
622 | throw "unbound variables: " + pretty_print(map(car, env.cdr));
623 | }
624 | }
625 |
626 | function run_program(p) {
627 | var stream;
628 | if(p == null) { throw "no program" }
629 | map(register_define, p);
630 | while(p != null) {
631 | stream = run_expression(p.car);
632 | p = p.cdr;
633 | } return stream;
634 | }
635 |
636 | this.reset = function() { toplevel = new Object(null); };
637 | this.eval = function(ast) { return run_program(ast); };
638 | this.read_eval = function(text) { return run_program(read_program(text)); };
639 | }
640 |
--------------------------------------------------------------------------------
/examples/editor.css:
--------------------------------------------------------------------------------
1 | html { height:100%; }
2 | body {
3 | padding:0;
4 | margin: 0;
5 | font-family:courier, monospace;
6 | height:100%;
7 | background-color:#eee;
8 | }
9 |
10 | #container {
11 | position:absolute;
12 | top:0; bottom:0;
13 | height:100%; width:100%;
14 | }
15 | #head { position:absolute; top:0; width:100%; background-color:#ccc;}
16 | #demos { display:none; }
17 |
--------------------------------------------------------------------------------
/examples/editor.js:
--------------------------------------------------------------------------------
1 | function load_editor() {
2 | var veneer = new Veneer_v1();
3 |
4 | var vm = veneer.new_vm();
5 |
6 | var ed = veneer.new_editor(document.getElementById("container"), vm);
7 | var editor = ed.editor;
8 | var editor_elt = ed.editor_elt;
9 | var repl = ed.repl;
10 | var errors = ed.errors;
11 | var dump_button = ed.dump_button;
12 |
13 |
14 | var font_size = 10;
15 | var font_plus = document.getElementById("font_plus");
16 | var font_minus = document.getElementById("font_minus");
17 | font_plus.onclick = function() {
18 | font_size = font_size + 1;
19 | editor_elt.style.fontSize = "" + font_size + "pt";
20 | repl.style.fontSize = "" + font_size + "pt";
21 | editor.refresh()
22 | };
23 | font_minus.onclick = function() {
24 | font_size = font_size - 1;
25 | repl.style.fontSize = "" + font_size + "pt";
26 | editor_elt.style.fontSize = "" + font_size + "pt";
27 | editor.refresh();
28 | };
29 |
30 | var slider = document.getElementById("slider");
31 | slider.onchange = function() {
32 | font_size = (parseInt(slider.value) + 16) * 0.5;
33 | editor_elt.style.fontSize = "" + font_size + "pt";
34 | repl.style.fontSize = "" + font_size + "pt";
35 | editor.refresh();
36 | };
37 |
38 | var demo = false;
39 | function setEditorValue(val) {
40 | demo = false;
41 | editor.setValue(val);
42 | }
43 |
44 | var demos = document.getElementsByClassName("demo");
45 | var demo_picker = document.getElementById("demo_picker");
46 | var file_values = new Array(demos.length);
47 | for(var i=0; i < demos.length; i++ ) {
48 | var selection = document.createElement("option");
49 | var name = demos[i].getElementsByClassName("title")[0].textContent;
50 | file_values[i] = demos[i].getElementsByClassName("content")[0].value;
51 | selection.value = i;
52 | selection.appendChild(document.createTextNode(name));
53 | demo_picker.appendChild(selection);
54 | }
55 | demo_picker.onchange = function() {
56 | load_demo(demo_picker.selectedIndex);
57 | };
58 | demo_picker.value = "0";
59 | setEditorValue(file_values[0]);
60 | demo = 0;
61 |
62 | document.getElementById("create_link").onclick = function() {
63 | var req = new XMLHttpRequest();
64 | var method = "POST";
65 | var url = "https://api.github.com/gists";
66 |
67 | var options = {
68 | "description": "veneer save",
69 | "public": true,
70 | "files": {
71 | "file": {
72 | "content": editor.getValue()
73 | }
74 | }
75 | };
76 |
77 | req.open(method, url, true);
78 | req.onreadystatechange = function () {
79 | if (req.readyState !== XMLHttpRequest.DONE) {
80 | return;
81 | }
82 | if (req.status === 201) {
83 | var response = JSON.parse(req.responseText);
84 | window.location.hash = response.id;
85 | }
86 | };
87 | req.send(JSON.stringify(options));
88 | };
89 |
90 | function load_demo(id) {
91 | var save_status = true;
92 | if(save_status) {
93 | var demo_val = file_values[id];
94 | setEditorValue(demo_val);
95 | demo = id;
96 | }
97 | }
98 |
99 | if(window.location.hash) {
100 | var req = new XMLHttpRequest();
101 | var method = "GET";
102 | var url = "https://api.github.com/gists/" + window.location.hash.substring(1);
103 |
104 | req.open(method, url, true);
105 | req.onreadystatechange = function () {
106 | if (req.readyState !== XMLHttpRequest.DONE) {
107 | return;
108 | }
109 | if (req.status === 200) {
110 | var response = JSON.parse(req.responseText);
111 | setEditorValue(response.files.file.content);
112 | }
113 | };
114 | req.send();
115 | }
116 | }
117 |
--------------------------------------------------------------------------------
/examples/quines.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | relational interpreter
31 |
32 |
33 | relational interpreter fun
34 |
35 | With a relational interpreter you can run normal scheme functions "backwards" by grounding the output and leaving the inputs fresh. The interpreter will then produce the inputs for the given output.
36 |
37 |
38 |
56 |
57 |
58 | By setting a programs input to also be it's output, you create a program which returns itself, known as a quine.
59 |
60 |
61 |
65 |
66 |
67 | We can also create twines, which are two programs that produce the other. We make each program the output of each other and make sure they are different with a disequality constraint (otherwise we would just get two quines).
68 |
69 |
70 |
77 |
78 | Now go make some more!
79 |
80 |
82 |
83 |
84 |
85 |
86 |
174 |
175 |
176 |
--------------------------------------------------------------------------------
/examples/quines.js:
--------------------------------------------------------------------------------
1 | function load_page() {
2 | var rel_interp = document.getElementById("rel_interp").value;
3 | var veneer = new Veneer_v1();
4 |
5 | var vm1 = veneer.new_vm();
6 | var vm2 = veneer.new_vm();
7 | var vm3 = veneer.new_vm();
8 | var editor1 = veneer.new_editor(document.getElementById("ed1"), vm1, rel_interp);
9 | var editor2 = veneer.new_editor(document.getElementById("ed2"), vm2, rel_interp);
10 | var editor3 = veneer.new_editor(document.getElementById("ed3"), vm3, rel_interp);
11 |
12 | editor1.editor.setValue(document.getElementById("code1").value);
13 | editor2.editor.setValue(document.getElementById("code2").value);
14 | editor3.editor.setValue(document.getElementById("code3").value);
15 | }
16 |
17 |
--------------------------------------------------------------------------------
/examples/veneer.css:
--------------------------------------------------------------------------------
1 | .CodeMirror-matchingbracket { border:1px solid #ccc; margin:-1px; }
2 | .CodeMirror-nonmatchingbracket { border:1px solid #f00; margin:-1px; }
3 |
4 | .buttons_container {
5 | background-color:#ccc;
6 | position:absolute;
7 | width:100%;
8 | height:1.5em;
9 | top:1.5em;
10 | }
11 |
12 | .editor_container {
13 | position:absolute;
14 | top:3em;
15 | bottom:0;
16 | width:100%;
17 | }
18 |
19 | .CodeMirror {
20 | width:100%;
21 | height:100%;
22 | }
23 |
24 | .repl_container {
25 | display:none;
26 | position:absolute;
27 | top:3em;
28 | bottom:0;
29 | width:100%;
30 | overflow-y:scroll;
31 | }
32 |
33 | .repl {
34 | width:100%;
35 | font-family: monospace, courier;
36 | font-size:10pt;
37 | background-color:#f9f9f9;
38 | }
39 |
40 | .buttons_container div .helptext { font-size:10pt; }
41 | .buttons_container div:hover { color:#000; background-color:#ccc; }
42 | .buttons_container div {
43 | font-size:1.25em;
44 | display:inline;
45 | background-color: #eee;
46 | cursor:pointer;
47 | border-right:3px solid #ccc;
48 | padding:0 .4em;
49 | }
50 | .clear { clear:both; margin:0; padding:0; border-width:0; displat:none; }
51 |
52 | .errors {
53 | position:absolute;
54 | top:.5em; left:.5em;
55 | z-index:100;
56 | width:46%;
57 | margin:0;
58 | padding: 0 2%;
59 | background-color:transparent;
60 | border-width:0;
61 | white-space:pre-wrap;
62 | }
63 |
64 | .error { background-color:#f00; color:#000;}
65 |
66 | .inputbox:last-child { padding:8px 8px; margin-bottom:8px}
67 |
68 | .inputbox {
69 | background-color:#fff;
70 | white-space: pre-wrap;
71 | border:1px solid #ccc;
72 | min-height:1em;
73 | padding:2px 8px;
74 | }
75 |
76 | .result {
77 | white-space: pre-wrap;
78 | background-color: #eee;
79 | margin:0;
80 | padding: 2px 8px;
81 | }
82 |
--------------------------------------------------------------------------------
/examples/veneer.js:
--------------------------------------------------------------------------------
1 | function Veneer_v1() {
2 | this.new_editor = function(container, vm, seed) {
3 | container.className += " veneer_container";
4 |
5 | var errors = document.createElement("div");
6 | errors.className += "errors";
7 | container.appendChild(errors);
8 |
9 | var cm_options = { mode: "scheme",
10 | matchBrackets: true,
11 | autoCloseBrackets: true,
12 | lineNumbers: false,
13 | lineWrapping: true};
14 |
15 |
16 | var editor_container = document.createElement("div");
17 | editor_container.className += "editor_container";
18 | container.appendChild(editor_container);
19 | var editor_elt;
20 | var editor = new CodeMirror(function(ed) {
21 | editor_container.appendChild(ed);
22 | editor_elt = ed;
23 | }, cm_options);
24 |
25 | var repl_container = document.createElement("div");
26 | repl_container.className += "repl_container";
27 | container.appendChild(repl_container);
28 |
29 | var repl = document.createElement("div");
30 | repl.className += "repl";
31 | repl_container.appendChild(repl);
32 |
33 | var buttons_container = document.createElement("div");
34 | buttons_container.className += "buttons_container";
35 | container.appendChild(buttons_container);
36 |
37 | var dump_button = document.createElement("div");
38 | dump_button.className += "dump_button";
39 | dump_button.appendChild(document.createTextNode("run!"));
40 | dump_button.style.padding = "0 2em";
41 | buttons_container.appendChild(dump_button);
42 |
43 | var edit_button = document.createElement("div");
44 | edit_button.className += "edit_button";
45 | edit_button.appendChild(document.createTextNode("edit"));
46 | buttons_container.appendChild(edit_button);
47 |
48 | var repl_button = document.createElement("div");
49 | repl_button.className += "repl_button";
50 | repl_button.appendChild(document.createTextNode("repl"));
51 | buttons_container.appendChild(repl_button);
52 |
53 | var edit_mode = "edit";
54 |
55 | var vertical_button = document.createElement("div");
56 | vertical_button.className += "vertical_button";
57 | vertical_button.appendChild(document.createTextNode("vertical"));
58 | buttons_container.appendChild(vertical_button);
59 | vertical_button.style.float = "right";
60 | vertical_button.onclick = function() {
61 | editor_container.style.display="block";
62 | editor_container.style.width="50%"
63 | editor_container.style.top="3em";
64 | editor_container.style.height="auto";
65 | editor_container.style.bottom="0";
66 |
67 | repl_container.style.display="block";
68 | repl_container.style.width="50%"
69 | repl_container.style.top="3em";
70 | repl_container.style.right="0";
71 | repl_container.style.height="auto";
72 | repl_container.style.bottom="0";
73 |
74 | edit_mode = "vertical";
75 | repl_button.style.display = "none";
76 | edit_button.style.display = "none";
77 | }
78 |
79 | var present_button = document.createElement("div");
80 | present_button.className += "present_button";
81 | present_button.appendChild(document.createTextNode("present"));
82 | buttons_container.appendChild(present_button);
83 | present_button.style.float = "right";
84 | present_button.onclick = function() {
85 | editor_container.style.display="block";
86 | editor_container.style.height="auto";
87 | editor_container.style.width="100%";
88 | editor_container.style.bottom="0";
89 |
90 | repl_container.style.display="none";
91 | repl_container.style.width="100%";
92 | repl_container.style.height="auto";
93 | repl_container.style.top="3em";
94 | repl_container.style.bottom="0";
95 |
96 |
97 | edit_mode = "edit";
98 | repl_button.style.display = "inline";
99 | edit_button.style.display = "inline";
100 | }
101 |
102 | // var clear = document.createElement("hr");
103 | // clear.className += "clear";
104 | // container.appendChild(clear);
105 |
106 | var current_input = repl_getline(false);
107 | function display_error(e) {
108 | var error = document.createElement("div");
109 | var error_txt = document.createTextNode(e);
110 | error.className += "error";
111 | error.appendChild(error_txt);
112 | errors.appendChild(error);
113 | setTimeout(function() { errors.removeChild(error); }, 3000);
114 | }
115 |
116 | var getTime;
117 | if (window.performance && window.performance.now) {
118 | getTime = function() { return window.performance.now(); };
119 | } else {
120 | getTime = function() { return (new Date()).getTime(); };
121 | }
122 |
123 | function load_input(inputbox) {
124 | inputbox = current_input;
125 | /* var textcontent = inputbox.innerHTML.replace(//ig, '\n')
126 | .replace(/<[p|div]\s/ig, '\n$0')
127 | .replace(/(<([^>]+)>)/ig, ""); */
128 |
129 | var pass = false;
130 | var textcontent = inputbox.textContent;
131 | try {
132 | var result = vm.read_eval(textcontent);
133 | var result_elt = document.createElement("div");
134 | result_elt.className += "result";
135 |
136 | function display_query(generator, parent) {
137 | var answer_text = document.createElement("div");
138 | var button = document.createElement("button");
139 | var append_answer = function(focus) {
140 | var answered;
141 | var time_before = getTime();
142 | var answer_val = generator();
143 | var run_time = (getTime() - time_before).toFixed(2);
144 | if (answer_val === null) {
145 | answered = "No.";
146 | answer_val = "";
147 | parent.removeChild(button);
148 | } else {
149 | answered = "Yes.";
150 | }
151 | var answer_val_pp = answered + " (" + run_time + "ms)\n" + answer_val;
152 | var answer_node = document.createTextNode("=> " + answer_val_pp + "\n");
153 | answer_text.appendChild(answer_node);
154 |
155 | if(focus) {
156 | button.focus();
157 | current_input.scrollIntoView(false);
158 | }
159 |
160 | return false;
161 | }
162 | button.onclick = function() { return append_answer(true); };
163 | button.appendChild(document.createTextNode("More answers!"));
164 | parent.appendChild(answer_text);
165 | parent.appendChild(button);
166 | append_answer(false);
167 | return answer_text;
168 | }
169 |
170 | function display_val(val, parent) {
171 | parent.appendChild(document.createTextNode(pretty_print(val)));
172 | }
173 |
174 | procedurep(result) ? display_query(result, result_elt)
175 | : display_val(result, result_elt);
176 |
177 | repl.appendChild(result_elt);
178 | inputbox.contentEditable = false;
179 | repl_getline(true);
180 | return false;
181 | } catch (e) {
182 | if(e instanceof ReaderError) {
183 | inputbox.appendChild(document.createTextNode("\n"));
184 | display_error(e.msg);
185 | pass = true;
186 | throw e.msg;
187 | } else {
188 | display_error(e);
189 | pass = false;
190 | throw e;
191 | }
192 | } finally { return pass; }
193 | }
194 |
195 | function repl_getline(focus) {
196 | var inputbox = document.createElement("div");
197 | inputbox.className += "inputbox";
198 | inputbox.contentEditable = true;
199 | inputbox.onkeypress = function(e) {
200 | if (e.keyCode == 13) {
201 | return load_input(inputbox);
202 | }
203 | };
204 |
205 | repl.appendChild(inputbox);
206 | if (focus) { inputbox.focus(); }
207 | current_input = inputbox;
208 | return inputbox;
209 | }
210 |
211 | var dump_editor = function(event) {
212 | if (edit_mode === "edit") {
213 | edit_mode = "repl";
214 | editor_container.style.display="none";
215 | repl_container.style.display="block";
216 | }
217 |
218 | vm.reset();
219 | if (!(typeof seed === 'undefined')) { vm.read_eval(seed); }
220 | current_input.textContent = editor.getValue();
221 | load_input(current_input);
222 |
223 | event.preventDefault();
224 | return false;
225 | };
226 | dump_button.onclick = dump_editor;
227 | edit_button.onclick = function(event) {
228 | if (edit_mode === "edit") {
229 | } else {
230 | edit_mode = "edit";
231 | editor_container.style.display="block";
232 | repl_container.style.display="none";
233 | editor.refresh();
234 | }
235 | };
236 | repl_button.onclick = function(event) {
237 | if (edit_mode === "edit") {
238 | edit_mode = "repl";
239 | repl_container.style.display="block";
240 | editor_container.style.display="none";
241 | } else if (edit_mode === "repl") {
242 | current_input.scrollIntoView(false);
243 | }
244 | };
245 |
246 | var shift = false;
247 |
248 | editor.setOption("extraKeys", {
249 | "Shift-Enter": function(cm) { dump_editor();}
250 | });
251 |
252 | vertical_button.onclick();
253 | return { editor: editor, editor_elt: editor_elt, repl: repl, errors: errors, dump_button: dump_button };
254 | };
255 |
256 |
257 | this.new_vm = function() { return new VeneerVM(); };
258 | }
259 |
--------------------------------------------------------------------------------
/mk.js:
--------------------------------------------------------------------------------
1 | function Var(c) { this.c = c; }
2 | function mkvar(c) { return new Var(c); }
3 | function varp(x) { return (x instanceof Var); }
4 | function vareq(x1, x2) { return x1.c === x2.c; }
5 |
6 | function MiniKanrenState(s, c, d, ty, ab, w) {
7 | this.substitution = s;
8 | this.counter = c;
9 | this.diseq = d;
10 | this.types = ty;
11 | this.absentee = ab;
12 | this.watch = w;
13 | }
14 | function Mks(s, c, d, ty, ab, w) { return new MiniKanrenState(s, c, d, ty, ab, w); }
15 |
16 | var not_found = [];
17 | function walk(u, s) {
18 | var pr;
19 | while(varp(u)) {
20 | pr = s.get(u.c, not_found);
21 | if (pr === not_found) {
22 | return u;
23 | } else {
24 | u = pr;
25 | }
26 | } return u;
27 | }
28 |
29 | function occurs_check(x, v, s) {
30 | var v1 = walk(v, s);
31 | if(varp(v1)) {
32 | return vareq(v1, x);
33 | } else if (pairp(v1)) {
34 | return occurs_check(x, v1.car, s) || occurs_check(x, v1.cdr, s);
35 | } else {
36 | return false;
37 | }
38 | }
39 |
40 | function ext_s_check(x, v, s) {
41 | return occurs_check(x, v, s) ? false : s.set(x.c, v);
42 | }
43 |
44 | function eqeq(u, v) {
45 | return function(mks) {
46 | var s_cs = unify_prefix(u, v, mks.substitution, null);
47 | return s_cs !== false ? normalize_constraint_store(Mks(s_cs.car, mks.counter, mks.diseq, mks.types, mks.absentee, mks.watch), s_cs.cdr) : mzero;
48 | };
49 | }
50 |
51 | function noteqeq(u, v) {
52 | return function(mks) {
53 | var d = disequality(u, v, mks.substitution);
54 | return d !== false ? unit(Mks(mks.substitution, mks.counter, cons(d, mks.diseq), mks.types, mks.absentee, mks.watch)) : mzero;
55 | };
56 | }
57 |
58 | function type_check(v, p, s, ty) {
59 | var v1 = walk(v, s);
60 | if (varp(v1)) {
61 | var existing_type = ty.get(v1, false);
62 | if(existing_type && existing_type !== p) {
63 | return false;
64 | } else { // add constraint
65 | return ty.set(v1, p);
66 | }
67 | } else { // ground; run test
68 | return p(v1) ? ty : false;
69 | }
70 | }
71 |
72 | function symbolo(s) { return typeo(s, symbolp); }
73 | function numbero(n) { return typeo(n, numberp); }
74 |
75 | function typeo(v, p) {
76 | return function(mks) {
77 | var s = mks.substitution;
78 | var ty = mks.types;
79 | var ty1 = type_check(v, p, s, ty);
80 | if (!ty1) {
81 | return mzero;
82 | } else if (ty1 === ty) {
83 | return unit(mks);
84 | } else {
85 | var mks1 = Mks(mks.substitution, mks.counter, mks.diseq, ty1, mks.absentee, mks.watch);
86 | return normalize_constraint_store(mks1, null);
87 | }
88 | };
89 | }
90 |
91 | function absento(s, f) {
92 | return function(mks) {
93 | return normalize_constraint_store(Mks(mks.substitution, mks.counter, mks.diseq, mks.types, cons(cons(s, f), mks.absentee), mks.watch), null);
94 | };
95 | }
96 |
97 | function unit(mks) { return cons(mks, mzero); }
98 | var mzero = null;
99 |
100 | function unify(u, v, s) {
101 | var u1 = walk(u, s);
102 | var v1 = walk(v, s);
103 | if (varp(u1) && varp(v1) && vareq(u1, v1)) { return s; }
104 | else if (varp(u1)) { return ext_s_check(u1, v1, s); }
105 | else if (varp(v1)) { return ext_s_check(v1, u1, s); }
106 | else if (pairp(u1) && pairp(v1)) {
107 | var s1 = unify(u1.car, v1.car, s);
108 | return (s1 !== false) && unify(u1.cdr, v1.cdr, s1);
109 | } else {
110 | return (u1 === v1) && s;
111 | }
112 | }
113 |
114 |
115 | function ext_s_check_prefix(x, v, s, cs) {
116 | if (occurs_check(x, v, s)) {
117 | return false;
118 | } else {
119 | return cons(s.set(x.c, v), cons(cons(x, v), cs));
120 | }
121 | }
122 |
123 | function unify_prefix(u, v, s, cs) {
124 | var u1 = walk(u, s);
125 | var v1 = walk(v, s);
126 | if (varp(u1) && varp(v1) && vareq(u1, v1)) { return cons(s, cs); }
127 | else if (varp(u1)) { return ext_s_check_prefix(u1, v1, s, cs); }
128 | else if (varp(v1)) { return ext_s_check_prefix(v1, u1, s, cs); }
129 | else if (pairp(u1) && pairp(v1)) {
130 | var s_cs = unify_prefix(u1.car, v1.car, s, cs);
131 | return (s_cs !== false) && unify_prefix(u1.cdr, v1.cdr, s_cs.car, s_cs.cdr);
132 | } else {
133 | return (u1 === v1) && cons(s, cs);
134 | }
135 | }
136 |
137 | function disequality(u, v, s) {
138 | var s_cs_hat = unify_prefix(u, v, s, null);
139 | if(s_cs_hat !== false) {
140 | var d = s_cs_hat.cdr;
141 | return (d === null) ? false : d;
142 | }
143 | else {
144 | return null;
145 | }
146 | }
147 |
148 | function watch_collect(v, k) {
149 | return cons(v, function(s) {
150 | var v1 = walk(v, s);
151 | if (varp(v1)) { return watch_collect(v1, k); }
152 | else if (pairp(v1)) {
153 | var k1 = function(x, s) {
154 | var k2 = function(y, s) { return k(cons(x,y), s); };
155 | return cdr(watch_collect(cdr(v1), k2))(s);
156 | };
157 | return cdr(watch_collect(car(v1), k1))(s);
158 | }
159 | else { return k(v1, s); }
160 | });
161 | }
162 |
163 | function watch(v, g) {
164 | return function(mks) {
165 | var watch = mks.watch;
166 | var v1 = walk(v, mks.substitution);
167 |
168 | // build collector and run it once
169 | var g1 = function(val) { return g[0]([val], g[1]); };
170 | var k = function(val, s) { return [g1(val)]; };
171 | var w = cdr(watch_collect(v1, k))(mks.substitution);
172 | if(pairp(w)) { // still not ground, queue it
173 | watch = watch.update(w.car.c, null, function(ws) {
174 | return cons(w.cdr, ws);
175 | });
176 | var mks1 = Mks(mks.substitution, mks.counter, mks.diseq, mks.types, mks.absentee, watch);
177 | return unit(mks1);
178 | } else { // done, run goal
179 | return w[0](mks);
180 | }
181 | }
182 | }
183 |
184 | function execute_goals(gs) {
185 | if (gs === null) {
186 | return unit;
187 | } else {
188 | return function(mks) {
189 | return bind(car(gs)(mks), execute_goals(cdr(gs)));
190 | }
191 | }
192 | }
193 |
194 | function normalize_surveilence(mks, prefix) {
195 | var watch = mks.watch;
196 | var done = null;
197 | while(prefix !== null) {
198 | var v = prefix.car.car;
199 | var ws = watch.get(v.c, false);
200 | var wsn = false;
201 |
202 | if (ws) {
203 | while (ws !== null) {
204 | // pick out a watch
205 | var w = car(ws)(mks.substitution);
206 | if(pairp(w)) { // requeue
207 | wsn = true;
208 | watch = watch.update(w.car.c, null, function(ws) {
209 | return cons(w.cdr, ws);
210 | });
211 | } else { // done
212 | done = cons(w[0], done);
213 | }
214 | ws = ws.cdr;
215 | }
216 | if (wsn === false) { watch = watch.delete(v.c); }
217 | }
218 | prefix = prefix.cdr;
219 | }
220 |
221 | // run all todo
222 | var mks1 = Mks(mks.substitution, mks.counter,mks.diseq, mks.types, mks.absentee, watch);
223 | return execute_goals(done)(mks1);
224 | }
225 |
226 | function normalize_constraint_store(mks, prefix) {
227 | return bind(normalize_surveilence(mks, prefix), normalize_constraint_store1);
228 | }
229 |
230 |
231 | function normalize_constraint_store1(mks) {
232 | var s = mks.substitution;
233 | var c = mks.counter;
234 | var d = mks.diseq;
235 | var dn = null;
236 | var ty = mks.types;
237 | var tyn = Immutable.Map();
238 | var abs = mks.absentee;
239 | var absn = null;
240 | var ws = mks.watch;
241 |
242 | // Normalize the type constraints
243 | ty.forEach(function(p, v) {
244 | tyn = type_check(v, p, s, tyn);
245 | return tyn;
246 | });
247 | if (!tyn) { return mzero; }
248 |
249 | // normalize the disequality constraints
250 | while(d !== null) {
251 | var es = d.car;
252 |
253 | if(es !== null) {
254 | var d_hat = disequality(map(car, es), map(cdr, es), s);
255 |
256 | if(d_hat === false) {
257 | return mzero;
258 | }
259 |
260 | dn = cons(d_hat, dn);
261 | }
262 |
263 | d = d.cdr;
264 | }
265 |
266 | // normalize the absento constraints
267 | while(abs !== null) {
268 | var abs_cur = abs.car;
269 | abs = abs.cdr;
270 |
271 | var abs_s = walk(abs_cur.car, s);
272 | var abs_f = walk(abs_cur.cdr, s);
273 |
274 | // defer until both terms are ground
275 | if (varp(abs_f) || varp(abs_s)) {
276 | absn = cons(cons(abs_s, abs_f), absn);
277 | }
278 | // split and requeue
279 | else if (pairp(abs_f)) {
280 | abs = cons(cons(abs_s, abs_f.car),
281 | cons(cons(abs_s, abs_f.cdr), abs ));
282 | }
283 | // both are ground and atomic; check for eqv?
284 | else if (abs_s === abs_f) {
285 | return mzero;
286 | }
287 | // forget constraint, it can never fail
288 | }
289 |
290 | return unit(Mks(s, c, dn, tyn, absn, ws));
291 | }
292 |
293 | function call_fresh(f) {
294 | return function(mks) {
295 | var c = mks.counter;
296 | return f(mkvar(c))(Mks(mks.substitution, (c + 1), mks.diseq, mks.types, mks.absentee, mks.watch));
297 | };
298 | }
299 |
300 | function disj(g1, g2) {
301 | return function(mks) { return mplus(g1(mks), g2(mks)); };
302 | }
303 | function conj(g1, g2) {
304 | return function(mks) { return bind(g1(mks), g2); };
305 | }
306 |
307 | function mplus($1, $2) {
308 | if ($1 === null) {
309 | return $2;
310 | } else if (procedurep($1)) {
311 | return function() { return mplus($2, $1()); };
312 | } else {
313 | return cons($1.car, mplus($1.cdr, $2));
314 | }
315 | }
316 |
317 | function bind($, g) {
318 | if ($ === null) {
319 | return mzero;
320 | } else if (procedurep($)) {
321 | return function() { return bind($(), g); };
322 | } else {
323 | return mplus(g($.car), bind($.cdr, g));
324 | }
325 | }
326 |
327 |
328 | function disj_dfs(g1, g2) {
329 | return function(mks) { return mplus_dfs(g1(mks), g2(mks)); };
330 | }
331 |
332 | function conj_dfs(g1, g2) {
333 | return function(mks) { return bind_dfs(g1(mks), g2); };
334 | }
335 |
336 | function mplus_dfs($1, $2) {
337 | if ($1 === null) {
338 | return $2;
339 | } else if (procedurep($1)) {
340 | return function() { return mplus_dfs($1(), $2); };
341 | } else {
342 | return cons($1.car, mplus_dfs($1.cdr, $2));
343 | }
344 | }
345 |
346 | function bind_dfs($, g) {
347 | if ($ === null) {
348 | return mzero;
349 | } else if (procedurep($)) {
350 | return function() { return bind_dfs($(), g); };
351 | } else {
352 | return mplus_dfs(g($.car), bind_dfs($.cdr, g));
353 | }
354 | }
355 |
356 | function pull($) {
357 | while(procedurep($)) {
358 | $ = $();
359 | } return $;
360 | }
361 |
362 | function take(n, $) {
363 | if (n <= 0) {
364 | return null;
365 | } else {
366 | var $1 = pull($);
367 | return ($1 === null) ? null : cons($1.car, take(n - 1, $1.cdr));
368 | }
369 | }
370 |
371 | function take_all($) {
372 | $ = pull($);
373 | return ($ === null) ? null : cons($.car, take_all($.cdr));
374 | }
375 |
376 | function reify(v, s) {
377 | var v1 = walk_star(v, s);
378 | return walk_star(v1, reify_s(v1, Immutable.Map()));
379 | }
380 |
381 | function walk_star(v, s) {
382 | var v1 = walk(v, s);
383 | if (varp(v1)) {
384 | return v1;
385 | } else if (pairp(v1)) {
386 | return cons(walk_star(v1.car, s),
387 | walk_star(v1.cdr, s));
388 | } else {
389 | return v1;
390 | }
391 | }
392 |
393 | function reify_s(v, s) {
394 | var v1 = walk(v, s);
395 | if (varp(v1)) {
396 | return s.set(v1.c, reify_name(s.size));
397 | } else if (pairp(v1)) {
398 | return reify_s(v1.cdr, reify_s(v1.car, s));
399 | } else {
400 | return s;
401 | }
402 | }
403 |
404 | function reify_name(n) {
405 | return { toString: function() { return ["_", n].join("."); } };
406 | }
407 |
408 | function pred_to_tag(p) {
409 | return assq(p, list(cons(symbolp, intern("sym")),
410 | cons(numberp, intern("num")))).cdr;
411 | }
412 |
413 | function query_map(qm, mks) {
414 | var s = mks.substitution;
415 | var d = mks.diseq;
416 | var t = mks.types;
417 | // convert the type store to alist
418 | var t1 = t.reduce(function(m, v, k) { return cons(cons(k, v), m); }, null);
419 |
420 | var sq1 = walk_star(qm, s);
421 | var dq1 = walk_star(d, s);
422 | var tq1 = walk_star(t1, s);
423 | var q = walk_star(list(sq1, dq1, tq1), reify_s(list(sq1, dq1, tq1), Immutable.Map()));
424 |
425 | return print_constraints(q.car, q.cdr.car, q.cdr.cdr.car, s);
426 | }
427 |
428 | function print_constraints(sq, dq, tq, s) {
429 | var subs = foldl(sq, [], function(m, a_v) {
430 | return m.concat([a_v.car, ": ", pretty_print(a_v.cdr), "\n"]);
431 | });
432 |
433 | var present_d = function(dd) {
434 | // dd is a disjunction of disequalities
435 | var diseqs = map(function(a){ return list(intern("=/="), a.car, a.cdr); }, dd);
436 | if (length(diseqs) > 1) {
437 | return pretty_print(cons(intern("or"), diseqs));
438 | } else if (diseqs !== null) {
439 | return pretty_print(diseqs.car);
440 | } else {
441 | return null;
442 | }
443 | };
444 | var present_t = function(tt) {
445 | return pretty_print(list(pred_to_tag(tt.cdr), tt.car));
446 | }
447 | return (dq !== null || tq !== null) ?
448 | (subs
449 | .concat(["{"])
450 | .concat(intersperse_map(dq, present_d, ", "))
451 | .concat([", "])
452 | .concat(intersperse_map(tq, present_t, ", "))
453 | .concat(["}\n"]).join("")) :
454 | subs.join("");
455 | }
456 |
457 | function intersperse_map(l, f, sep) {
458 | var m = [];
459 | var r;
460 | while(l !== null) {
461 | r = f(l.car);
462 | m = r === null ? m : m.concat([r, (l.cdr === null ? "" : sep)]);
463 | l = l.cdr;
464 | }
465 | return m;
466 | }
467 |
468 | function build_num(n) {
469 | if((n % 2) === 1) {
470 | return cons(1, build_num(Math.floor((n - 1) / 2)));
471 | } else if (n !== 0 && (n % 2) === 0) {
472 | return cons(0, build_num(Math.floor(n / 2)));
473 | } else {
474 | return null;
475 | }
476 | }
477 |
--------------------------------------------------------------------------------
/mk_test.js:
--------------------------------------------------------------------------------
1 |
2 | function fives(x) {
3 | return disj(eqeq(x, 5),
4 | function(a_c) {
5 | return function() { return fives(x)(a_c); }
6 | });
7 | }
8 | function sixes(x) {
9 | return disj(eqeq(x, 6),
10 | function(a_c) {
11 | return function() { return sixes(x)(a_c); }
12 | });
13 | }
14 |
15 |
16 | function node_log(x) { return console.log(require('util').inspect(x, true, 10)); }
17 | var empty_state = cons(null, 0);
18 | var test1 = call_fresh(function (q) { return eqeq(q, 5); })(empty_state);
19 | node_log(test1.car);
20 | node_log("-----");
21 |
22 | var fv;
23 | var sv;
24 | var test2 = function(x) {
25 | fv = x;
26 | return fives(x);
27 | };
28 |
29 | var res = conj(call_fresh(test2), call_fresh(sixes))(empty_state);
30 |
31 | node_log(assq(fv, take(5, res).car.car));
32 |
33 | var x = ref(null);
34 | var y = ref(null);
35 | var foo = conj(call_fresh(function(z) { x.set(z); return eqeq(x.get(), y.get()) }),
36 | call_fresh(function(z) { y.set(z); return eqeq(y.get(), 1) }));
37 |
38 | node_log(take(3, foo(empty_state)));
39 |
40 | function appendo(l, s, out) {
41 | return disj(conj(eqeq(null, l), eqeq(s, out)),
42 | call_fresh(function(a) {
43 | return call_fresh(function(d) {
44 | return conj(eqeq(cons(a, d), l),
45 | call_fresh(function(res) {
46 | return conj(function(s_c) {
47 | return function() {
48 | return appendo(d,s,res)(s_c); };
49 | }, eqeq(cons(a, res), out));
50 | }));
51 | });
52 | }));
53 | }
54 |
55 | var call_appendo =
56 | call_fresh(function(q) {
57 | return call_fresh(function(l) {
58 | return call_fresh(function(s) {
59 | return call_fresh(function(out) {
60 | return conj(appendo(l,s,out),
61 | eqeq(list(l, s), q)); }); }); }); });
62 |
63 | function pp(x) {
64 | if (pairp(x)) {
65 | return ["(", pp(x.car), ".", pp(x.cdr), ")"].join("");
66 | } else {
67 | return JSON.stringify(x);
68 | }
69 | }
70 |
71 | var test3 = call_fresh(function(a) { return appendo(list(1), a, list(1,2)); });
72 | var test4 = call_fresh(function(q) { return call_fresh(function(b) { return call_fresh(function(a) { return conj(eqeq(list(a,b), q),
73 | appendo(a, b, list(1,2,3))); }); }); });
74 |
75 | console.log("--");
76 | map(function(x) { return node_log(reify_first(x)); }, take(5, test4(empty_state)));
77 | node_log(eqeq(1,1)(empty_state));
78 |
--------------------------------------------------------------------------------
/reader.js:
--------------------------------------------------------------------------------
1 | var eof = ["eof"];
2 | function eofp(c) { return eof === c; }
3 |
4 | function Stream(string) {
5 | var length = string.length;
6 | this.pos = 0;
7 | this.line = 1;
8 | this.string = string;
9 | this.peek_char = function() {
10 | return (this.pos >= length) ? eof : string[this.pos];
11 | }
12 | this.read_char = function() {
13 | var old_pos = this.pos;
14 | this.pos++;
15 | if (string[old_pos] == "\n") { this.line++; }
16 | return (old_pos >= length) ? eof : string[old_pos];
17 | }
18 | this.unread_char = function() {
19 | if (string[this.pos-1] == "\n") { this.line--; }
20 | this.pos--;
21 | }
22 | }
23 |
24 | function whitespacep(c) { return /\s+/.test(c); }
25 | function symbolicp(c) { return /[a-zA-Z0-9=\/\\!@#$%^&*_+=\-?.~<>\:]/.test(c); }
26 | function number_stringp(s) { return /^([0-9]*\.)?[0-9]+$/.test(s); }
27 |
28 | function skip_whitespace(input_stream) {
29 | var c;
30 | while(true) {
31 | c = input_stream.read_char();
32 | if(!whitespacep(c)) { break; }
33 | }
34 | input_stream.unread_char();
35 | }
36 |
37 | function skip_whitespace_and_comments(input_stream) {
38 | var c;
39 | while(true) {
40 | c = input_stream.read_char();
41 | if(c == ";") {
42 | while(!eofp(c)) {
43 | c = input_stream.read_char();
44 | if(c == "\n") {
45 | break;
46 | }
47 | }
48 | }
49 | else if(!whitespacep(c)) { break; }
50 | }
51 | input_stream.unread_char();
52 | }
53 |
54 | function read_symbol(input_stream) {
55 | var buffer = [input_stream.read_char()];
56 | var c;
57 | while(true) {
58 | c = input_stream.read_char();
59 | if(!eofp(c) && symbolicp(c)) {
60 | buffer.push(c);
61 | } else {
62 | input_stream.unread_char();
63 | var result = buffer.join("");
64 | return (number_stringp(result) ? parseFloat(result) : intern(result));
65 | }
66 | }
67 | }
68 |
69 | function read_hex(input_stream) {
70 | var buffer = [input_stream.read_char()];
71 | var c;
72 | while(true) {
73 | c = input_stream.read_char();
74 | if(!eofp(c) && symbolicp(c)) {
75 | buffer.push(c);
76 | } else {
77 | input_stream.unread_char();
78 | var result = buffer.join("");
79 | return parseInt(result, 16);
80 | }
81 | }
82 | }
83 |
84 | function read_string(input_stream) {
85 | var buffer = [];
86 | var c;
87 | input_stream.read_char();
88 | while(c = input_stream.read_char()) {
89 | if(c == '"') {
90 | return buffer.join("");
91 | } else if (c == "\\") {
92 | buffer.push(input_stream.read_char());
93 | } else {
94 | buffer.push(c);
95 | }
96 | }
97 | }
98 |
99 | function read_after_whitespace(input_stream) {
100 | skip_whitespace(input_stream);
101 | return read(input_stream);
102 | }
103 |
104 | function read_after_comment(input_stream) {
105 | var c;
106 | while(true) {
107 | c = input_stream.read_char();
108 | if(c == "\n") { return read(input_stream); }
109 | else if (c === eof) { throw "eof"; }
110 | }
111 | }
112 |
113 | function read_quoted(input_stream) {
114 | input_stream.read_char();
115 | return cons(intern("quote"), cons(read(input_stream), null));
116 | }
117 |
118 | function read_quasiquoted(input_stream) {
119 | input_stream.read_char();
120 | return cons(intern("quasiquote"), cons(read(input_stream), null));
121 | }
122 |
123 | function read_unquoted(input_stream) {
124 | input_stream.read_char();
125 | return cons(intern("unquote"), cons(read(input_stream), null));
126 | }
127 |
128 | function read_list(input_stream) {
129 | input_stream.read_char();
130 | return read_list_aux(null, input_stream);
131 | }
132 |
133 | function read_list_aux(sexps, input_stream) {
134 | while (true) {
135 | skip_whitespace_and_comments(input_stream);
136 | var c = input_stream.peek_char();
137 | switch (c) {
138 | case eof:
139 | throw "unexpected eof";
140 | case ")":
141 | input_stream.read_char();
142 | return reverse_aux(sexps, null);
143 | case ".":
144 | return read_after_dot(sexps, input_stream);
145 | default:
146 | sexps = cons(read(input_stream), sexps);
147 | }
148 | }
149 | }
150 |
151 | function read_after_dot(sexps, input_stream) {
152 | input_stream.read_char();
153 | var last = read(input_stream);
154 | skip_whitespace(input_stream);
155 | var c = input_stream.peek_char();
156 | switch (c) {
157 | case eof:
158 | throw "unexpected eof";
159 | case ")":
160 | input_stream.read_char();
161 | break;
162 | default:
163 | throw "too many expressions after dot";
164 | }
165 | return reverse_aux(sexps, last);
166 | }
167 |
168 | function read_hash(input_stream) {
169 | input_stream.read_char();
170 | switch (input_stream.read_char()) {
171 | case "f": return false;
172 | case "t": return true;
173 | case "x": return read_hex(input_stream);
174 | case "\\": return input_stream.read_char();
175 | default: throw "unknown hash code";
176 | }
177 | }
178 |
179 | var readtable = {
180 | '"': read_string,
181 | "'": read_quoted,
182 | "`": read_quasiquoted,
183 | ",": read_unquoted,
184 | "(": read_list,
185 | ";": read_after_comment,
186 | "#": read_hash
187 | //eof: function(input_stream) { throw eof }
188 | };
189 |
190 | function reader_for(c) {
191 | var reader = readtable[c];
192 | if (reader) { return reader; }
193 | if (whitespacep(c)) { return read_after_whitespace; }
194 | if (symbolicp(c)) { return read_symbol; }
195 | return false;
196 | }
197 |
198 | function read(input_stream) {
199 | var c = input_stream.peek_char();
200 | var reader = reader_for(c);
201 | if(reader) { return reader(input_stream); }
202 | throw "no reader for: " + c;
203 | }
204 |
205 | function read_top(sexps, input_stream) {
206 | while (true) {
207 | skip_whitespace_and_comments(input_stream);
208 | var c = input_stream.peek_char();
209 | if (c === eof) {
210 | input_stream.read_char();
211 | return reverse_aux(sexps, null);
212 | } else {
213 | sexps = cons(read(input_stream), sexps);
214 | }
215 | }
216 | }
217 |
218 | function ReaderError(msg) { this.msg = msg; }
219 | function read_program(str) {
220 | try { return read_top(null, new Stream(str)); }
221 | catch(err) { throw new ReaderError(err); }
222 | }
223 |
--------------------------------------------------------------------------------
/resources/closebrackets.js:
--------------------------------------------------------------------------------
1 | // CodeMirror, copyright (c) by Marijn Haverbeke and others
2 | // Distributed under an MIT license: http://codemirror.net/LICENSE
3 |
4 | (function(mod) {
5 | if (typeof exports == "object" && typeof module == "object") // CommonJS
6 | mod(require("../../lib/codemirror"));
7 | else if (typeof define == "function" && define.amd) // AMD
8 | define(["../../lib/codemirror"], mod);
9 | else // Plain browser env
10 | mod(CodeMirror);
11 | })(function(CodeMirror) {
12 | var DEFAULT_BRACKETS = "()[]{}''\"\"";
13 | var DEFAULT_EXPLODE_ON_ENTER = "[]{}";
14 | var SPACE_CHAR_REGEX = /\s/;
15 |
16 | var Pos = CodeMirror.Pos;
17 |
18 | CodeMirror.defineOption("autoCloseBrackets", false, function(cm, val, old) {
19 | if (old != CodeMirror.Init && old)
20 | cm.removeKeyMap("autoCloseBrackets");
21 | if (!val) return;
22 | var pairs = DEFAULT_BRACKETS, explode = DEFAULT_EXPLODE_ON_ENTER;
23 | if (typeof val == "string") pairs = val;
24 | else if (typeof val == "object") {
25 | if (val.pairs != null) pairs = val.pairs;
26 | if (val.explode != null) explode = val.explode;
27 | }
28 | var map = buildKeymap(pairs);
29 | if (explode) map.Enter = buildExplodeHandler(explode);
30 | cm.addKeyMap(map);
31 | });
32 |
33 | function charsAround(cm, pos) {
34 | var str = cm.getRange(Pos(pos.line, pos.ch - 1),
35 | Pos(pos.line, pos.ch + 1));
36 | return str.length == 2 ? str : null;
37 | }
38 |
39 | // Project the token type that will exists after the given char is
40 | // typed, and use it to determine whether it would cause the start
41 | // of a string token.
42 | function enteringString(cm, pos, ch) {
43 | var line = cm.getLine(pos.line);
44 | var token = cm.getTokenAt(pos);
45 | if (/\bstring2?\b/.test(token.type)) return false;
46 | var stream = new CodeMirror.StringStream(line.slice(0, pos.ch) + ch + line.slice(pos.ch), 4);
47 | stream.pos = stream.start = token.start;
48 | for (;;) {
49 | var type1 = cm.getMode().token(stream, token.state);
50 | if (stream.pos >= pos.ch + 1) return /\bstring2?\b/.test(type1);
51 | stream.start = stream.pos;
52 | }
53 | }
54 |
55 | function buildKeymap(pairs) {
56 | var map = {
57 | name : "autoCloseBrackets",
58 | Backspace: function(cm) {
59 | if (cm.getOption("disableInput")) return CodeMirror.Pass;
60 | var ranges = cm.listSelections();
61 | for (var i = 0; i < ranges.length; i++) {
62 | if (!ranges[i].empty()) return CodeMirror.Pass;
63 | var around = charsAround(cm, ranges[i].head);
64 | if (!around || pairs.indexOf(around) % 2 != 0) return CodeMirror.Pass;
65 | }
66 | for (var i = ranges.length - 1; i >= 0; i--) {
67 | var cur = ranges[i].head;
68 | cm.replaceRange("", Pos(cur.line, cur.ch - 1), Pos(cur.line, cur.ch + 1));
69 | }
70 | }
71 | };
72 | var closingBrackets = "";
73 | for (var i = 0; i < pairs.length; i += 2) (function(left, right) {
74 | closingBrackets += right;
75 | map["'" + left + "'"] = function(cm) {
76 | if (cm.getOption("disableInput")) return CodeMirror.Pass;
77 | var ranges = cm.listSelections(), type, next;
78 | for (var i = 0; i < ranges.length; i++) {
79 | var range = ranges[i], cur = range.head, curType;
80 | var next = cm.getRange(cur, Pos(cur.line, cur.ch + 1));
81 | if (!range.empty()) {
82 | curType = "surround";
83 | } else if (left == right && next == right) {
84 | if (cm.getRange(cur, Pos(cur.line, cur.ch + 3)) == left + left + left)
85 | curType = "skipThree";
86 | else
87 | curType = "skip";
88 | } else if (left == right && cur.ch > 1 &&
89 | cm.getRange(Pos(cur.line, cur.ch - 2), cur) == left + left &&
90 | (cur.ch <= 2 || cm.getRange(Pos(cur.line, cur.ch - 3), Pos(cur.line, cur.ch - 2)) != left)) {
91 | curType = "addFour";
92 | } else if (left == '"' || left == "'") {
93 | if (!CodeMirror.isWordChar(next) && enteringString(cm, cur, left)) curType = "both";
94 | else return CodeMirror.Pass;
95 | } else if (cm.getLine(cur.line).length == cur.ch || closingBrackets.indexOf(next) >= 0 || SPACE_CHAR_REGEX.test(next)) {
96 | curType = "both";
97 | } else {
98 | return CodeMirror.Pass;
99 | }
100 | if (!type) type = curType;
101 | else if (type != curType) return CodeMirror.Pass;
102 | }
103 |
104 | cm.operation(function() {
105 | if (type == "skip") {
106 | cm.execCommand("goCharRight");
107 | } else if (type == "skipThree") {
108 | for (var i = 0; i < 3; i++)
109 | cm.execCommand("goCharRight");
110 | } else if (type == "surround") {
111 | var sels = cm.getSelections();
112 | for (var i = 0; i < sels.length; i++)
113 | sels[i] = left + sels[i] + right;
114 | cm.replaceSelections(sels, "around");
115 | } else if (type == "both") {
116 | cm.replaceSelection(left + right, null);
117 | cm.execCommand("goCharLeft");
118 | } else if (type == "addFour") {
119 | cm.replaceSelection(left + left + left + left, "before");
120 | cm.execCommand("goCharRight");
121 | }
122 | });
123 | };
124 | if (left != right) map["'" + right + "'"] = function(cm) {
125 | var ranges = cm.listSelections();
126 | for (var i = 0; i < ranges.length; i++) {
127 | var range = ranges[i];
128 | if (!range.empty() ||
129 | cm.getRange(range.head, Pos(range.head.line, range.head.ch + 1)) != right)
130 | return CodeMirror.Pass;
131 | }
132 | cm.execCommand("goCharRight");
133 | };
134 | })(pairs.charAt(i), pairs.charAt(i + 1));
135 | return map;
136 | }
137 |
138 | function buildExplodeHandler(pairs) {
139 | return function(cm) {
140 | if (cm.getOption("disableInput")) return CodeMirror.Pass;
141 | var ranges = cm.listSelections();
142 | for (var i = 0; i < ranges.length; i++) {
143 | if (!ranges[i].empty()) return CodeMirror.Pass;
144 | var around = charsAround(cm, ranges[i].head);
145 | if (!around || pairs.indexOf(around) % 2 != 0) return CodeMirror.Pass;
146 | }
147 | cm.operation(function() {
148 | cm.replaceSelection("\n\n", null);
149 | cm.execCommand("goCharLeft");
150 | ranges = cm.listSelections();
151 | for (var i = 0; i < ranges.length; i++) {
152 | var line = ranges[i].head.line;
153 | cm.indentLine(line, null, true);
154 | cm.indentLine(line + 1, null, true);
155 | }
156 | });
157 | };
158 | }
159 | });
160 |
--------------------------------------------------------------------------------
/resources/codemirror.css:
--------------------------------------------------------------------------------
1 | /* BASICS */
2 |
3 | .CodeMirror {
4 | /* Set height, width, borders, and global font properties here */
5 | font-family: monospace;
6 | height: 300px;
7 | }
8 |
9 | /* PADDING */
10 |
11 | .CodeMirror-lines {
12 | padding: 4px 0; /* Vertical padding around content */
13 | }
14 | .CodeMirror pre {
15 | padding: 0 4px; /* Horizontal padding of content */
16 | }
17 |
18 | .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
19 | background-color: white; /* The little square between H and V scrollbars */
20 | }
21 |
22 | /* GUTTER */
23 |
24 | .CodeMirror-gutters {
25 | border-right: 1px solid #ddd;
26 | background-color: #f7f7f7;
27 | white-space: nowrap;
28 | }
29 | .CodeMirror-linenumbers {}
30 | .CodeMirror-linenumber {
31 | padding: 0 3px 0 5px;
32 | min-width: 20px;
33 | text-align: right;
34 | color: #999;
35 | -moz-box-sizing: content-box;
36 | box-sizing: content-box;
37 | }
38 |
39 | .CodeMirror-guttermarker { color: black; }
40 | .CodeMirror-guttermarker-subtle { color: #999; }
41 |
42 | /* CURSOR */
43 |
44 | .CodeMirror div.CodeMirror-cursor {
45 | border-left: 1px solid black;
46 | }
47 | /* Shown when moving in bi-directional text */
48 | .CodeMirror div.CodeMirror-secondarycursor {
49 | border-left: 1px solid silver;
50 | }
51 | .CodeMirror.cm-fat-cursor div.CodeMirror-cursor {
52 | width: auto;
53 | border: 0;
54 | background: #7e7;
55 | }
56 | .CodeMirror.cm-fat-cursor div.CodeMirror-cursors {
57 | z-index: 1;
58 | }
59 |
60 | .cm-animate-fat-cursor {
61 | width: auto;
62 | border: 0;
63 | -webkit-animation: blink 1.06s steps(1) infinite;
64 | -moz-animation: blink 1.06s steps(1) infinite;
65 | animation: blink 1.06s steps(1) infinite;
66 | }
67 | @-moz-keyframes blink {
68 | 0% { background: #7e7; }
69 | 50% { background: none; }
70 | 100% { background: #7e7; }
71 | }
72 | @-webkit-keyframes blink {
73 | 0% { background: #7e7; }
74 | 50% { background: none; }
75 | 100% { background: #7e7; }
76 | }
77 | @keyframes blink {
78 | 0% { background: #7e7; }
79 | 50% { background: none; }
80 | 100% { background: #7e7; }
81 | }
82 |
83 | /* Can style cursor different in overwrite (non-insert) mode */
84 | div.CodeMirror-overwrite div.CodeMirror-cursor {}
85 |
86 | .cm-tab { display: inline-block; text-decoration: inherit; }
87 |
88 | .CodeMirror-ruler {
89 | border-left: 1px solid #ccc;
90 | position: absolute;
91 | }
92 |
93 | /* DEFAULT THEME */
94 |
95 | .cm-s-default .cm-keyword {color: #708;}
96 | .cm-s-default .cm-atom {color: #219;}
97 | .cm-s-default .cm-number {color: #164;}
98 | .cm-s-default .cm-def {color: #00f;}
99 | .cm-s-default .cm-variable,
100 | .cm-s-default .cm-punctuation,
101 | .cm-s-default .cm-property,
102 | .cm-s-default .cm-operator {}
103 | .cm-s-default .cm-variable-2 {color: #05a;}
104 | .cm-s-default .cm-variable-3 {color: #085;}
105 | .cm-s-default .cm-comment {color: #a50;}
106 | .cm-s-default .cm-string {color: #a11;}
107 | .cm-s-default .cm-string-2 {color: #f50;}
108 | .cm-s-default .cm-meta {color: #555;}
109 | .cm-s-default .cm-qualifier {color: #555;}
110 | .cm-s-default .cm-builtin {color: #30a;}
111 | .cm-s-default .cm-bracket {color: #997;}
112 | .cm-s-default .cm-tag {color: #170;}
113 | .cm-s-default .cm-attribute {color: #00c;}
114 | .cm-s-default .cm-header {color: blue;}
115 | .cm-s-default .cm-quote {color: #090;}
116 | .cm-s-default .cm-hr {color: #999;}
117 | .cm-s-default .cm-link {color: #00c;}
118 |
119 | .cm-negative {color: #d44;}
120 | .cm-positive {color: #292;}
121 | .cm-header, .cm-strong {font-weight: bold;}
122 | .cm-em {font-style: italic;}
123 | .cm-link {text-decoration: underline;}
124 | .cm-strikethrough {text-decoration: line-through;}
125 |
126 | .cm-s-default .cm-error {color: #f00;}
127 | .cm-invalidchar {color: #f00;}
128 |
129 | /* Default styles for common addons */
130 |
131 | div.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}
132 | div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
133 | .CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }
134 | .CodeMirror-activeline-background {background: #e8f2ff;}
135 |
136 | /* STOP */
137 |
138 | /* The rest of this file contains styles related to the mechanics of
139 | the editor. You probably shouldn't touch them. */
140 |
141 | .CodeMirror {
142 | line-height: 1;
143 | position: relative;
144 | overflow: hidden;
145 | background: white;
146 | color: black;
147 | }
148 |
149 | .CodeMirror-scroll {
150 | overflow: scroll !important; /* Things will break if this is overridden */
151 | /* 30px is the magic margin used to hide the element's real scrollbars */
152 | /* See overflow: hidden in .CodeMirror */
153 | margin-bottom: -30px; margin-right: -30px;
154 | padding-bottom: 30px;
155 | height: 100%;
156 | outline: none; /* Prevent dragging from highlighting the element */
157 | position: relative;
158 | -moz-box-sizing: content-box;
159 | box-sizing: content-box;
160 | }
161 | .CodeMirror-sizer {
162 | position: relative;
163 | border-right: 30px solid transparent;
164 | -moz-box-sizing: content-box;
165 | box-sizing: content-box;
166 | }
167 |
168 | /* The fake, visible scrollbars. Used to force redraw during scrolling
169 | before actuall scrolling happens, thus preventing shaking and
170 | flickering artifacts. */
171 | .CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
172 | position: absolute;
173 | z-index: 6;
174 | display: none;
175 | }
176 | .CodeMirror-vscrollbar {
177 | right: 0; top: 0;
178 | overflow-x: hidden;
179 | overflow-y: scroll;
180 | }
181 | .CodeMirror-hscrollbar {
182 | bottom: 0; left: 0;
183 | overflow-y: hidden;
184 | overflow-x: scroll;
185 | }
186 | .CodeMirror-scrollbar-filler {
187 | right: 0; bottom: 0;
188 | }
189 | .CodeMirror-gutter-filler {
190 | left: 0; bottom: 0;
191 | }
192 |
193 | .CodeMirror-gutters {
194 | position: absolute; left: 0; top: 0;
195 | z-index: 3;
196 | }
197 | .CodeMirror-gutter {
198 | white-space: normal;
199 | height: 100%;
200 | -moz-box-sizing: content-box;
201 | box-sizing: content-box;
202 | display: inline-block;
203 | margin-bottom: -30px;
204 | /* Hack to make IE7 behave */
205 | *zoom:1;
206 | *display:inline;
207 | }
208 | .CodeMirror-gutter-wrapper {
209 | position: absolute;
210 | z-index: 4;
211 | height: 100%;
212 | }
213 | .CodeMirror-gutter-elt {
214 | position: absolute;
215 | cursor: default;
216 | z-index: 4;
217 | }
218 |
219 | .CodeMirror-lines {
220 | cursor: text;
221 | min-height: 1px; /* prevents collapsing before first draw */
222 | }
223 | .CodeMirror pre {
224 | /* Reset some styles that the rest of the page might have set */
225 | -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;
226 | border-width: 0;
227 | background: transparent;
228 | font-family: inherit;
229 | font-size: inherit;
230 | margin: 0;
231 | white-space: pre;
232 | word-wrap: normal;
233 | line-height: inherit;
234 | color: inherit;
235 | z-index: 2;
236 | position: relative;
237 | overflow: visible;
238 | }
239 | .CodeMirror-wrap pre {
240 | word-wrap: break-word;
241 | white-space: pre-wrap;
242 | word-break: normal;
243 | }
244 |
245 | .CodeMirror-linebackground {
246 | position: absolute;
247 | left: 0; right: 0; top: 0; bottom: 0;
248 | z-index: 0;
249 | }
250 |
251 | .CodeMirror-linewidget {
252 | position: relative;
253 | z-index: 2;
254 | overflow: auto;
255 | }
256 |
257 | .CodeMirror-widget {}
258 |
259 | .CodeMirror-measure {
260 | position: absolute;
261 | width: 100%;
262 | height: 0;
263 | overflow: hidden;
264 | visibility: hidden;
265 | }
266 | .CodeMirror-measure pre { position: static; }
267 |
268 | .CodeMirror div.CodeMirror-cursor {
269 | position: absolute;
270 | border-right: none;
271 | width: 0;
272 | }
273 |
274 | div.CodeMirror-cursors {
275 | visibility: hidden;
276 | position: relative;
277 | z-index: 3;
278 | }
279 | .CodeMirror-focused div.CodeMirror-cursors {
280 | visibility: visible;
281 | }
282 |
283 | .CodeMirror-selected { background: #d9d9d9; }
284 | .CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }
285 | .CodeMirror-crosshair { cursor: crosshair; }
286 |
287 | .cm-searching {
288 | background: #ffa;
289 | background: rgba(255, 255, 0, .4);
290 | }
291 |
292 | /* IE7 hack to prevent it from returning funny offsetTops on the spans */
293 | .CodeMirror span { *vertical-align: text-bottom; }
294 |
295 | /* Used to force a border model for a node */
296 | .cm-force-border { padding-right: .1px; }
297 |
298 | @media print {
299 | /* Hide the cursor when printing */
300 | .CodeMirror div.CodeMirror-cursors {
301 | visibility: hidden;
302 | }
303 | }
304 |
305 | /* See issue #2901 */
306 | .cm-tab-wrap-hack:after { content: ''; }
307 |
308 | /* Help users use markselection to safely style text background */
309 | span.CodeMirror-selectedtext { background: none; }
310 |
--------------------------------------------------------------------------------
/resources/matchbrackets.js:
--------------------------------------------------------------------------------
1 | // CodeMirror, copyright (c) by Marijn Haverbeke and others
2 | // Distributed under an MIT license: http://codemirror.net/LICENSE
3 |
4 | (function(mod) {
5 | if (typeof exports == "object" && typeof module == "object") // CommonJS
6 | mod(require("../../lib/codemirror"));
7 | else if (typeof define == "function" && define.amd) // AMD
8 | define(["../../lib/codemirror"], mod);
9 | else // Plain browser env
10 | mod(CodeMirror);
11 | })(function(CodeMirror) {
12 | var ie_lt8 = /MSIE \d/.test(navigator.userAgent) &&
13 | (document.documentMode == null || document.documentMode < 8);
14 |
15 | var Pos = CodeMirror.Pos;
16 |
17 | var matching = {"(": ")>", ")": "(<", "[": "]>", "]": "[<", "{": "}>", "}": "{<"};
18 |
19 | function findMatchingBracket(cm, where, strict, config) {
20 | var line = cm.getLineHandle(where.line), pos = where.ch - 1;
21 | var match = (pos >= 0 && matching[line.text.charAt(pos)]) || matching[line.text.charAt(++pos)];
22 | if (!match) return null;
23 | var dir = match.charAt(1) == ">" ? 1 : -1;
24 | if (strict && (dir > 0) != (pos == where.ch)) return null;
25 | var style = cm.getTokenTypeAt(Pos(where.line, pos + 1));
26 |
27 | var found = scanForBracket(cm, Pos(where.line, pos + (dir > 0 ? 1 : 0)), dir, style || null, config);
28 | if (found == null) return null;
29 | return {from: Pos(where.line, pos), to: found && found.pos,
30 | match: found && found.ch == match.charAt(0), forward: dir > 0};
31 | }
32 |
33 | // bracketRegex is used to specify which type of bracket to scan
34 | // should be a regexp, e.g. /[[\]]/
35 | //
36 | // Note: If "where" is on an open bracket, then this bracket is ignored.
37 | //
38 | // Returns false when no bracket was found, null when it reached
39 | // maxScanLines and gave up
40 | function scanForBracket(cm, where, dir, style, config) {
41 | var maxScanLen = (config && config.maxScanLineLength) || 10000;
42 | var maxScanLines = (config && config.maxScanLines) || 1000;
43 |
44 | var stack = [];
45 | var re = config && config.bracketRegex ? config.bracketRegex : /[(){}[\]]/;
46 | var lineEnd = dir > 0 ? Math.min(where.line + maxScanLines, cm.lastLine() + 1)
47 | : Math.max(cm.firstLine() - 1, where.line - maxScanLines);
48 | for (var lineNo = where.line; lineNo != lineEnd; lineNo += dir) {
49 | var line = cm.getLine(lineNo);
50 | if (!line) continue;
51 | var pos = dir > 0 ? 0 : line.length - 1, end = dir > 0 ? line.length : -1;
52 | if (line.length > maxScanLen) continue;
53 | if (lineNo == where.line) pos = where.ch - (dir < 0 ? 1 : 0);
54 | for (; pos != end; pos += dir) {
55 | var ch = line.charAt(pos);
56 | if (re.test(ch) && (style === undefined || cm.getTokenTypeAt(Pos(lineNo, pos + 1)) == style)) {
57 | var match = matching[ch];
58 | if ((match.charAt(1) == ">") == (dir > 0)) stack.push(ch);
59 | else if (!stack.length) return {pos: Pos(lineNo, pos), ch: ch};
60 | else stack.pop();
61 | }
62 | }
63 | }
64 | return lineNo - dir == (dir > 0 ? cm.lastLine() : cm.firstLine()) ? false : null;
65 | }
66 |
67 | function matchBrackets(cm, autoclear, config) {
68 | // Disable brace matching in long lines, since it'll cause hugely slow updates
69 | var maxHighlightLen = cm.state.matchBrackets.maxHighlightLineLength || 1000;
70 | var marks = [], ranges = cm.listSelections();
71 | for (var i = 0; i < ranges.length; i++) {
72 | var match = ranges[i].empty() && findMatchingBracket(cm, ranges[i].head, false, config);
73 | if (match && cm.getLine(match.from.line).length <= maxHighlightLen) {
74 | var style = match.match ? "CodeMirror-matchingbracket" : "CodeMirror-nonmatchingbracket";
75 | marks.push(cm.markText(match.from, Pos(match.from.line, match.from.ch + 1), {className: style}));
76 | if (match.to && cm.getLine(match.to.line).length <= maxHighlightLen)
77 | marks.push(cm.markText(match.to, Pos(match.to.line, match.to.ch + 1), {className: style}));
78 | }
79 | }
80 |
81 | if (marks.length) {
82 | // Kludge to work around the IE bug from issue #1193, where text
83 | // input stops going to the textare whever this fires.
84 | if (ie_lt8 && cm.state.focused) cm.display.input.focus();
85 |
86 | var clear = function() {
87 | cm.operation(function() {
88 | for (var i = 0; i < marks.length; i++) marks[i].clear();
89 | });
90 | };
91 | if (autoclear) setTimeout(clear, 800);
92 | else return clear;
93 | }
94 | }
95 |
96 | var currentlyHighlighted = null;
97 | function doMatchBrackets(cm) {
98 | cm.operation(function() {
99 | if (currentlyHighlighted) {currentlyHighlighted(); currentlyHighlighted = null;}
100 | currentlyHighlighted = matchBrackets(cm, false, cm.state.matchBrackets);
101 | });
102 | }
103 |
104 | CodeMirror.defineOption("matchBrackets", false, function(cm, val, old) {
105 | if (old && old != CodeMirror.Init)
106 | cm.off("cursorActivity", doMatchBrackets);
107 | if (val) {
108 | cm.state.matchBrackets = typeof val == "object" ? val : {};
109 | cm.on("cursorActivity", doMatchBrackets);
110 | }
111 | });
112 |
113 | CodeMirror.defineExtension("matchBrackets", function() {matchBrackets(this, true);});
114 | CodeMirror.defineExtension("findMatchingBracket", function(pos, strict, config){
115 | return findMatchingBracket(this, pos, strict, config);
116 | });
117 | CodeMirror.defineExtension("scanForBracket", function(pos, dir, style, config){
118 | return scanForBracket(this, pos, dir, style, config);
119 | });
120 | });
121 |
--------------------------------------------------------------------------------
/resources/scheme.js:
--------------------------------------------------------------------------------
1 | // CodeMirror, copyright (c) by Marijn Haverbeke and others
2 | // Distributed under an MIT license: http://codemirror.net/LICENSE
3 |
4 | /**
5 | * Author: Koh Zi Han, based on implementation by Koh Zi Chun
6 | */
7 |
8 | (function(mod) {
9 | if (typeof exports == "object" && typeof module == "object") // CommonJS
10 | mod(require("../../lib/codemirror"));
11 | else if (typeof define == "function" && define.amd) // AMD
12 | define(["../../lib/codemirror"], mod);
13 | else // Plain browser env
14 | mod(CodeMirror);
15 | })(function(CodeMirror) {
16 | "use strict";
17 |
18 | CodeMirror.defineMode("scheme", function () {
19 | var BUILTIN = "builtin", COMMENT = "comment", STRING = "string",
20 | ATOM = "atom", NUMBER = "number", BRACKET = "bracket";
21 | var INDENT_WORD_SKIP = 2;
22 |
23 | function makeKeywords(str) {
24 | var obj = {}, words = str.split(" ");
25 | for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
26 | return obj;
27 | }
28 |
29 | var keywords = makeKeywords("λ case-lambda call/cc class define-class exit-handler field import inherit init-field interface let*-values let-values let/ec mixin opt-lambda override protect provide public rename require require-for-syntax syntax syntax-case syntax-error unit/sig unless when with-syntax and begin call-with-current-continuation call-with-input-file call-with-output-file case cond define define-syntax delay do dynamic-wind else for-each if lambda let let* let-syntax letrec letrec-syntax map or syntax-rules abs acos angle append apply asin assoc assq assv atan boolean? caar cadr call-with-input-file call-with-output-file call-with-values car cdddar cddddr cdr ceiling char->integer char-alphabetic? char-ci<=? char-ci=? char-ci>? char-downcase char-lower-case? char-numeric? char-ready? char-upcase char-upper-case? char-whitespace? char<=? char=? char>? char? close-input-port close-output-port complex? cons cos current-input-port current-output-port denominator display eof-object? eq? equal? eqv? eval even? exact->inexact exact? exp expt #f floor force gcd imag-part inexact->exact inexact? input-port? integer->char integer? interaction-environment lcm length list list->string list->vector list-ref list-tail list? load log magnitude make-polar make-rectangular make-string make-vector max member memq memv min modulo negative? newline not null-environment null? number->string number? numerator odd? open-input-file open-output-file output-port? pair? peek-char port? positive? procedure? quasiquote quote quotient rational? rationalize read read-char real-part real? remainder reverse round scheme-report-environment set! set-car! set-cdr! sin sqrt string string->list string->number string->symbol string-append string-ci<=? string-ci=? string-ci>? string-copy string-fill! string-length string-ref string-set! string<=? string=? string>? string? substring symbol->string symbol? #t tan transcript-off transcript-on truncate values vector vector->list vector-fill! vector-length vector-ref vector-set! with-input-from-file with-output-to-file write write-char zero?");
30 | var indentKeys = makeKeywords("define let letrec let* lambda fresh");
31 |
32 | function stateStack(indent, type, prev) { // represents a state stack object
33 | this.indent = indent;
34 | this.type = type;
35 | this.prev = prev;
36 | }
37 |
38 | function pushStack(state, indent, type) {
39 | state.indentStack = new stateStack(indent, type, state.indentStack);
40 | }
41 |
42 | function popStack(state) {
43 | state.indentStack = state.indentStack.prev;
44 | }
45 |
46 | var binaryMatcher = new RegExp(/^(?:[-+]i|[-+][01]+#*(?:\/[01]+#*)?i|[-+]?[01]+#*(?:\/[01]+#*)?@[-+]?[01]+#*(?:\/[01]+#*)?|[-+]?[01]+#*(?:\/[01]+#*)?[-+](?:[01]+#*(?:\/[01]+#*)?)?i|[-+]?[01]+#*(?:\/[01]+#*)?)(?=[()\s;"]|$)/i);
47 | var octalMatcher = new RegExp(/^(?:[-+]i|[-+][0-7]+#*(?:\/[0-7]+#*)?i|[-+]?[0-7]+#*(?:\/[0-7]+#*)?@[-+]?[0-7]+#*(?:\/[0-7]+#*)?|[-+]?[0-7]+#*(?:\/[0-7]+#*)?[-+](?:[0-7]+#*(?:\/[0-7]+#*)?)?i|[-+]?[0-7]+#*(?:\/[0-7]+#*)?)(?=[()\s;"]|$)/i);
48 | var hexMatcher = new RegExp(/^(?:[-+]i|[-+][\da-f]+#*(?:\/[\da-f]+#*)?i|[-+]?[\da-f]+#*(?:\/[\da-f]+#*)?@[-+]?[\da-f]+#*(?:\/[\da-f]+#*)?|[-+]?[\da-f]+#*(?:\/[\da-f]+#*)?[-+](?:[\da-f]+#*(?:\/[\da-f]+#*)?)?i|[-+]?[\da-f]+#*(?:\/[\da-f]+#*)?)(?=[()\s;"]|$)/i);
49 | var decimalMatcher = new RegExp(/^(?:[-+]i|[-+](?:(?:(?:\d+#+\.?#*|\d+\.\d*#*|\.\d+#*|\d+)(?:[esfdl][-+]?\d+)?)|\d+#*\/\d+#*)i|[-+]?(?:(?:(?:\d+#+\.?#*|\d+\.\d*#*|\.\d+#*|\d+)(?:[esfdl][-+]?\d+)?)|\d+#*\/\d+#*)@[-+]?(?:(?:(?:\d+#+\.?#*|\d+\.\d*#*|\.\d+#*|\d+)(?:[esfdl][-+]?\d+)?)|\d+#*\/\d+#*)|[-+]?(?:(?:(?:\d+#+\.?#*|\d+\.\d*#*|\.\d+#*|\d+)(?:[esfdl][-+]?\d+)?)|\d+#*\/\d+#*)[-+](?:(?:(?:\d+#+\.?#*|\d+\.\d*#*|\.\d+#*|\d+)(?:[esfdl][-+]?\d+)?)|\d+#*\/\d+#*)?i|(?:(?:(?:\d+#+\.?#*|\d+\.\d*#*|\.\d+#*|\d+)(?:[esfdl][-+]?\d+)?)|\d+#*\/\d+#*))(?=[()\s;"]|$)/i);
50 |
51 | function isBinaryNumber (stream) {
52 | return stream.match(binaryMatcher);
53 | }
54 |
55 | function isOctalNumber (stream) {
56 | return stream.match(octalMatcher);
57 | }
58 |
59 | function isDecimalNumber (stream, backup) {
60 | if (backup === true) {
61 | stream.backUp(1);
62 | }
63 | return stream.match(decimalMatcher);
64 | }
65 |
66 | function isHexNumber (stream) {
67 | return stream.match(hexMatcher);
68 | }
69 |
70 | return {
71 | startState: function () {
72 | return {
73 | indentStack: null,
74 | indentation: 0,
75 | mode: false,
76 | sExprComment: false
77 | };
78 | },
79 |
80 | token: function (stream, state) {
81 | if (state.indentStack == null && stream.sol()) {
82 | // update indentation, but only if indentStack is empty
83 | state.indentation = stream.indentation();
84 | }
85 |
86 | // skip spaces
87 | if (stream.eatSpace()) {
88 | return null;
89 | }
90 | var returnType = null;
91 |
92 | switch(state.mode){
93 | case "string": // multi-line string parsing mode
94 | var next, escaped = false;
95 | while ((next = stream.next()) != null) {
96 | if (next == "\"" && !escaped) {
97 |
98 | state.mode = false;
99 | break;
100 | }
101 | escaped = !escaped && next == "\\";
102 | }
103 | returnType = STRING; // continue on in scheme-string mode
104 | break;
105 | case "comment": // comment parsing mode
106 | var next, maybeEnd = false;
107 | while ((next = stream.next()) != null) {
108 | if (next == "#" && maybeEnd) {
109 |
110 | state.mode = false;
111 | break;
112 | }
113 | maybeEnd = (next == "|");
114 | }
115 | returnType = COMMENT;
116 | break;
117 | case "s-expr-comment": // s-expr commenting mode
118 | state.mode = false;
119 | if(stream.peek() == "(" || stream.peek() == "["){
120 | // actually start scheme s-expr commenting mode
121 | state.sExprComment = 0;
122 | }else{
123 | // if not we just comment the entire of the next token
124 | stream.eatWhile(/[^/s]/); // eat non spaces
125 | returnType = COMMENT;
126 | break;
127 | }
128 | default: // default parsing mode
129 | var ch = stream.next();
130 |
131 | if (ch == "\"") {
132 | state.mode = "string";
133 | returnType = STRING;
134 |
135 | } else if (ch == "'") {
136 | returnType = ATOM;
137 | } else if (ch == '#') {
138 | if (stream.eat("|")) { // Multi-line comment
139 | state.mode = "comment"; // toggle to comment mode
140 | returnType = COMMENT;
141 | } else if (stream.eat(/[tf]/i)) { // #t/#f (atom)
142 | returnType = ATOM;
143 | } else if (stream.eat(';')) { // S-Expr comment
144 | state.mode = "s-expr-comment";
145 | returnType = COMMENT;
146 | } else {
147 | var numTest = null, hasExactness = false, hasRadix = true;
148 | if (stream.eat(/[ei]/i)) {
149 | hasExactness = true;
150 | } else {
151 | stream.backUp(1); // must be radix specifier
152 | }
153 | if (stream.match(/^#b/i)) {
154 | numTest = isBinaryNumber;
155 | } else if (stream.match(/^#o/i)) {
156 | numTest = isOctalNumber;
157 | } else if (stream.match(/^#x/i)) {
158 | numTest = isHexNumber;
159 | } else if (stream.match(/^#d/i)) {
160 | numTest = isDecimalNumber;
161 | } else if (stream.match(/^[-+0-9.]/, false)) {
162 | hasRadix = false;
163 | numTest = isDecimalNumber;
164 | // re-consume the intial # if all matches failed
165 | } else if (!hasExactness) {
166 | stream.eat('#');
167 | }
168 | if (numTest != null) {
169 | if (hasRadix && !hasExactness) {
170 | // consume optional exactness after radix
171 | stream.match(/^#[ei]/i);
172 | }
173 | if (numTest(stream))
174 | returnType = NUMBER;
175 | }
176 | }
177 | } else if (/^[-+0-9.]/.test(ch) && isDecimalNumber(stream, true)) { // match non-prefixed number, must be decimal
178 | returnType = NUMBER;
179 | } else if (ch == ";") { // comment
180 | stream.skipToEnd(); // rest of the line is a comment
181 | returnType = COMMENT;
182 | } else if (ch == "(" || ch == "[") {
183 | var keyWord = ''; var indentTemp = stream.column(), letter;
184 | /**
185 | Either
186 | (indent-word ..
187 | (non-indent-word ..
188 | (;something else, bracket, etc.
189 | */
190 |
191 | while ((letter = stream.eat(/[^\s\(\[\;\)\]]/)) != null) {
192 | keyWord += letter;
193 | }
194 |
195 | if (keyWord.length > 0 && indentKeys.propertyIsEnumerable(keyWord)) { // indent-word
196 |
197 | pushStack(state, indentTemp + INDENT_WORD_SKIP, ch);
198 | } else { // non-indent word
199 | // we continue eating the spaces
200 | stream.eatSpace();
201 | if (stream.eol() || stream.peek() == ";") {
202 | // nothing significant after
203 | // we restart indentation 1 space after
204 | pushStack(state, indentTemp + 1, ch);
205 | } else {
206 | pushStack(state, indentTemp + stream.current().length, ch); // else we match
207 | }
208 | }
209 | stream.backUp(stream.current().length - 1); // undo all the eating
210 |
211 | if(typeof state.sExprComment == "number") state.sExprComment++;
212 |
213 | returnType = BRACKET;
214 | } else if (ch == ")" || ch == "]") {
215 | returnType = BRACKET;
216 | if (state.indentStack != null && state.indentStack.type == (ch == ")" ? "(" : "[")) {
217 | popStack(state);
218 |
219 | if(typeof state.sExprComment == "number"){
220 | if(--state.sExprComment == 0){
221 | returnType = COMMENT; // final closing bracket
222 | state.sExprComment = false; // turn off s-expr commenting mode
223 | }
224 | }
225 | }
226 | } else {
227 | stream.eatWhile(/[\w\$_\-!$%&*+\.\/:<=>?@\^~]/);
228 |
229 | if (keywords && keywords.propertyIsEnumerable(stream.current())) {
230 | returnType = BUILTIN;
231 | } else returnType = "variable";
232 | }
233 | }
234 | return (typeof state.sExprComment == "number") ? COMMENT : returnType;
235 | },
236 |
237 | indent: function (state) {
238 | if (state.indentStack == null) return state.indentation;
239 | return state.indentStack.indent;
240 | },
241 |
242 | lineComment: ";;"
243 | };
244 | });
245 |
246 | CodeMirror.defineMIME("text/x-scheme", "scheme");
247 |
248 | });
249 |
--------------------------------------------------------------------------------
/veneer.css:
--------------------------------------------------------------------------------
1 | .CodeMirror-matchingbracket { border:1px solid #ccc; margin:-1px; }
2 | .CodeMirror-nonmatchingbracket { border:1px solid #f00; margin:-1px; }
3 |
4 | .CodeMirror { float:left; height:100%; width:50%; }
5 |
6 | .clear { clear:both; margin:0; padding:0; border-width:0; visibility:hidden; }
7 |
8 | .repl {
9 | font-family: monospace, courier;
10 | font-size:13px;
11 | float:left;
12 | height:100%;
13 | width:50%;
14 | overflow-y:scroll;
15 | margin:0;
16 | padding: 0;
17 | background-color:#f9f9f9;
18 | border-width:0;
19 | }
20 |
21 | .errors {
22 | position:absolute;
23 | top:.5em; left:.5em;
24 | z-index:100;
25 | width:46%;
26 | margin:0;
27 | padding: 0 2%;
28 | background-color:transparent;
29 | border-width:0;
30 | }
31 |
32 | .error { background-color:#f00; color:#000; }
33 |
34 | .inputbox:last-child { margin-bottom:1em; }
35 |
36 | .inputbox {
37 | background-color:#fff;
38 | white-space: pre-wrap;
39 | display:block;
40 | border:1px solid #ccc;
41 | min-height:1em;
42 | padding:2px 8px;
43 | }
44 |
45 | .result {
46 | white-space: pre-wrap;
47 | background-color: #eee;
48 | margin:0;
49 | padding: 2px 8px;
50 | }
51 |
52 | .dump_button {
53 | z-index:99;
54 | font-size:36pt;
55 | position:absolute; right:50%;
56 | margin-right:16px;
57 | background-color: #eee;
58 | border: 3px solid #ccc;
59 | padding:0 .4em;
60 | cursor:pointer;
61 | }
62 |
63 | .dump_button .helptext { font-size:10pt; }
64 |
65 | .dump_button:hover { color:#fff; }
66 |
--------------------------------------------------------------------------------
/veneer.js:
--------------------------------------------------------------------------------
1 | function Veneer_v1() {
2 | this.new_editor = function(container, vm, seed) {
3 | var errors = document.createElement("div");
4 | errors.className += "errors";
5 | container.appendChild(errors);
6 |
7 | var options = { mode: "scheme",
8 | matchBrackets: true,
9 | autoCloseBrackets: true,
10 | lineNumbers: true};
11 | var editor = new CodeMirror(function(ed) {
12 | container.appendChild(ed);
13 | return ed;
14 | }, options);
15 |
16 | var repl = document.createElement("div");
17 | repl.className += "repl";
18 | container.appendChild(repl);
19 |
20 | var dump_button = document.createElement("div");
21 | dump_button.className += "dump_button";
22 | dump_button.appendChild(document.createTextNode("run!"));
23 | container.appendChild(dump_button);
24 |
25 | var clear = document.createElement("hr");
26 | clear.className += "clear";
27 | container.appendChild(clear);
28 |
29 | var current_input = repl_getline(false);
30 | function display_error(e) {
31 | var error = document.createElement("div");
32 | var error_txt = document.createTextNode(e);
33 | error.className += "error";
34 | error.appendChild(error_txt);
35 | errors.appendChild(error);
36 | setTimeout(function() { errors.removeChild(error); }, 3000);
37 | }
38 |
39 | var getTime;
40 | if (window.performance && window.performance.now) {
41 | getTime = function() { return window.performance.now(); };
42 | } else {
43 | getTime = function() { return (new Date()).getTime(); };
44 | }
45 |
46 | function load_input(inputbox) {
47 | inputbox = current_input;
48 | /* var textcontent = inputbox.innerHTML.replace(//ig, '\n')
49 | .replace(/<[p|div]\s/ig, '\n$0')
50 | .replace(/(<([^>]+)>)/ig, ""); */
51 |
52 | var pass = false;
53 | var textcontent = inputbox.textContent;
54 | try {
55 | var result = vm.read_eval(textcontent);
56 | var result_elt = document.createElement("div");
57 | result_elt.className += "result";
58 |
59 | function display_query(generator, parent) {
60 | var answer_text = document.createElement("div");
61 | var button = document.createElement("button");
62 | var append_answer = function(focus) {
63 | var answered;
64 | var time_before = getTime();
65 | var answer_val = generator();
66 | var run_time = (getTime() - time_before).toFixed(2);
67 | if (answer_val === null) {
68 | answered = "No.";
69 | answer_val = "";
70 | parent.removeChild(button);
71 | } else {
72 | answered = "Yes.";
73 | }
74 | var answer_val_pp = answered + " (" + run_time + "ms)\n" + answer_val;
75 | var answer_node = document.createTextNode("=> " + answer_val_pp + "\n");
76 | answer_text.appendChild(answer_node);
77 |
78 | if(focus) {
79 | button.focus();
80 | current_input.scrollIntoView(false);
81 | }
82 |
83 | return false;
84 | }
85 | button.onclick = function() { return append_answer(true); };
86 | button.appendChild(document.createTextNode("More answers!"));
87 | parent.appendChild(answer_text);
88 | parent.appendChild(button);
89 | append_answer(false);
90 | return answer_text;
91 | }
92 |
93 | function display_val(val, parent) {
94 | parent.appendChild(document.createTextNode(pretty_print(val)));
95 | }
96 |
97 | procedurep(result) ? display_query(result, result_elt)
98 | : display_val(result, result_elt);
99 |
100 | repl.appendChild(result_elt);
101 | inputbox.contentEditable = false;
102 | repl_getline(true);
103 | return false;
104 | } catch (e) {
105 | if(e instanceof ReaderError) {
106 | inputbox.appendChild(document.createTextNode("\n"));
107 | display_error(e.msg);
108 | pass = true;
109 | throw e.msg;
110 | } else {
111 | display_error(e);
112 | pass = false;
113 | throw e;
114 | }
115 | } finally { return pass; }
116 | }
117 |
118 | function repl_getline(focus) {
119 | var inputbox = document.createElement("pre");
120 | inputbox.className += "inputbox";
121 | inputbox.contentEditable = true;
122 | inputbox.onkeypress = function(e) {
123 | if (e.keyCode == 13) {
124 | return load_input(inputbox);
125 | }
126 | };
127 |
128 | repl.appendChild(inputbox);
129 | if (focus) { inputbox.focus(); }
130 | current_input = inputbox;
131 | return inputbox;
132 | }
133 |
134 |
135 | var dump_editor = function() {
136 | vm.reset();
137 | if (!(typeof seed === 'undefined')) { vm.read_eval(seed); }
138 | current_input.textContent = editor.getValue();
139 | load_input(current_input);
140 | return false;
141 | }
142 | dump_button.onclick = dump_editor;
143 |
144 | var shift = false;
145 |
146 | editor.setOption("extraKeys", {
147 | "Shift-Enter": function(cm) { dump_editor();}
148 | });
149 |
150 | return { editor: editor, repl: repl, errors: errors, dump_button: dump_button };
151 | };
152 |
153 |
154 | this.new_vm = function() { return new VeneerVM(); };
155 | }
156 |
--------------------------------------------------------------------------------
81 |