2c:null 2d:["$","title",null,{"children":"Maclisp | Bob Kerns | Observable"}] 32:T6cb,md`Let's see how easy it is to implement enough Maclisp in Javascript to run [TEACH;LISP](https://github.com/PDP-10/its/tree/master/src/teach), since volunteers were kind enough to load it off ancient backup tapes and put it on Github! >I wrote TEACH;LISP circa 1975 in preparation for my (never-completed) undergraduate thesis at MIT. >I believe it was the first net-accessible online learning environment, and quite a few people got their >introduction to the language via this program. >Much of the lesson content was written by Kent Pitman (who later wrote the > [Pitmanual](http://www.maclisp.info/pitmanual/index.html). When I left MIT's Laboratory for Computer Science > in 1981 to join [Symbolics](http://symbolics.com), he took over maintenance of the code as well. > So technically, this isn't my code anymore. It started out in 1975-style MacLisp. Maclisp had already changed > considerably over the previous decade, but the next decade saw the NIL project, Commmon Lisp, > and a steady accumulation of new features and compatibility layers built upon this core. >The present effort serves a few purposes. > * Retro Computing. What could be more retro than reviving code I wrote 45 years ago? > * A visible exploration of language interpreter techniques. > * Exploring how some of the notebook-like features of TEACH;LISP might translate to a real noteboook environment. > * Explore approaches to language embedding in Observable. The first visible thing we'll nead is \`READ\`. Behind that, we'll need IO and filesystem access, but we can access the files on Github later. Let's start with strings as our data format; turn them into character iterators. (Really, ITS would be bytes, but I hope not to need to go there...).`33:T897,class LInputStream extends LBaseObject { constructor(content, name) { super(); this.content = content; this.name = name; this.filepos = 0; this.lineno = 0; this.charpos = this.charpos_prev = 0; this._unread = null; // Support PEEK this.closed = false; } next() { this.checkOpen(); if (this._unread) { try { this.filepos += this._unread.length; if (this._unread === '\n') { this.charpos_prev = this.charpos; this.charpos = 0; this.lineno++; } else { this.charpos++; } return { value: this._unread }; } finally { this._unread = null; } } if (this.filepos >= this.content.length) { return { done: true }; } const c = this.content.charAt(this.filepos); this.filepos += c.length; if (c === '\n') { this.charpos_prev = this.charpos; this.charpos = 0; this.lineno++; } else { this.charpos++; } return { value: c }; } [Symbol.iterator]() { this.checkOpen(); return this; } unread(ch) { this.checkOpen(); if (this._unread) { // Easy to support multiple but was not allowed in Maclisp IIRC, so... throw new Error("Only one unread character allowed."); } this._unread = ch; this.filepos -= ch.length; if (ch === '\n') { this.charpos = this.charpos_prev; this.lineno--; } else { this.charpos--; } } // Lookahead one character, returning it without consuming it. // Returns eofval on end. peek(eofval = null) { this.checkOpen(); const { value, done } = this.next(); if (done) return eofval; this.unread(value); return value; } // Any further operations are an error close() { this.closed = true; } checkOpen() { if (this.closed) { throw new Error(`The stream ${this.name} is closed.`); } } // Debugging hack show(start = Number.MAX_SAFE_INTEGER) { return ( this.content.substring( Math.max(0, Math.min(start, this.filepos - 15)), this.filepos ) + '<|>' + this.content.substr(this.filepos, 15) ); } }34:T5f1,md`OK, now that I have a test framework going on, and a test, I've fixed my silly bugs and have verified it works, and I'm ready to dig in! ---- OK, long pause, and I split out the testing and related stuff ([Literate Tests](https://observablehq.com/@bobkerns/literate-tests)) and did a bunch of polishing. I could do output streams now, but let's rely on Observable's cells for that for a bit longer, and get a basic \`READ\` going. \`READ\` worked by dispatching in various ways via a \`READTABLE\`. IIRC I'm going to need that for readmacros, and it's a reasonable implementation path, so let's do that. I don't need the specifics, just enough framework to get going. Specific API I'll add when the need shows up. ---- The dependencies won't load because of circular references, weird conditionalization, files that have been moved, files that are missing, even a few files wrtitten in PDP-10 assembler. I'm having to explore corners of the language I had hoped to ignore. I've implemented my own backquote facility, and my own \`SETF\` facility, to trim back the dependency surface. I've implemented the full argument list syntax with \`&OPTIONAL\`, \`&REST\`/\`&BODY\`, \`&AUX\` (except not yet \`&WHOLE\` for macros). This argument list syntax did not even exist when I wrote the package, but it eventually became part of the Common Lisp standard. I've also implemented the ancient LEXPR facility, which was already obsolete when I wrote the package, but was actually used by some of the code I was loading. `35:T2df6,class Reader { constructor(world) { this.world = world; this.readtable = world.readtable; } intern(str) { return this.world.intern(str); } // Skip whitespace, as denoted in the readtable. skip(stream, eofval) { while (true) { let { value, done } = stream.next(); if (done) return eofval; let op = this.readtable[value]; if (!op && value.charCodeAt(0) < 32) { op = 'symbol'; value = '^' + "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"[value.charCodeAt(0)]; } switch (op) { case 'space': break; case 'comment': stream.unread(value); this.skipComment(stream); break; default: stream.unread(value); return; } } } // Read a symbol readSymbol(stream, soFar) { const chars = soFar || []; while (true) { let { value, done } = stream.next(); if (done) { if (chars.length) { return this.intern(chars.join('')); } return undefined; } if (value === '/') { const { value: nval, done } = stream.next(); if (done) throw new Error('Premature EOF'); chars.push(nval); } else if (/^[a-zA-Z0-9.@~!%&$*+?<=>:\[\]{}^\\_-]$/.test(value)) { chars.push(value.toUpperCase()); } else if ( value !== '\r' && value !== '\t' && value !== ' ' && value !== '\n' && value !== '\f' && value.charCodeAt(0) < 32 ) { chars.push('^'); chars.push("@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"[value.charCodeAt(0)]); } else if (value.length > 1) { chars.push(value); } else { stream.unread(value); return this.intern(chars.join('')); } } } // Skip to the end of the line skipComment(stream) { while (true) { const { value, done } = stream.next(); if (done) { return; } if (value === '\n') { stream.unread(value); return; } } } // Read a list async readList(stream) { let head = null; let tail = null; while (true) { let { value, done } = stream.next(); if (done) return head; let op = value.length > 1 ? 'symbol' : this.readtable[value] || value; if (!op && value.charCodeAt(0) < 32) { op = 'symbol'; value = '^' + "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"[value.charCodeAt(0)]; } switch (op) { case 'space': stream.unread(value); await this.skip(stream); break; case 'comment': stream.unread(value); await this.skipComment(stream); break; case ')': return head; case '.': if (!tail) throw new Error('premature "." in list'); while (true) { this.skip(stream); const nCdr = await this.readInternal(stream, true); if (nCdr !== undefined) { tail.cdr = nCdr; await this.skip(stream); const { value, done } = stream.next(); if (done) { throw new Error('premature EOF after .'); } if (value !== ')') { stream.unread(value); throw new Error('Extra garbage after .'); } return head; } } default: stream.unread(value); const nCar = await this.readInternal(stream, true); if (nCar !== undefined) { if (!tail) { head = tail = new LCons(nCar, null); } else { tail = tail.cdr = new LCons(nCar, null); } } } } } // Read a number readNumber(stream) { const digits = []; let float = false; // Need more than just a prefix let ready = false; while (true) { const { value, done } = stream.next(); if (done) return Number(digits.join('')); if (value === '-' || value === '+') { if (digits.length === 0) { digits.push(value); } else { stream.unread(value); return this.readSymbol(stream, digits); } } else if (/[0-9]/.test(value)) { digits.push(value); ready = true; } else if (value === '.') { if (float === true) { throw new Error("Multiple decimal points"); } float = true; digits.push(value); } else if (!ready || this.readtable[value] === 'symbol') { stream.unread(value); return this.readSymbol(stream, digits); } else if (float) { stream.unread(value); return Number.parseFloat(digits.join('')); } else { stream.unread(value); return Number.parseInt(digits.join(''), LSymbol.IBASE); } } } // Read a string or stringlike value (e.g. |symbols|) // Maclisp actually did not have strings, but rather faked them // with symbols. I'm going to try to use actual strings rather than // duplicate that, but we'll see how that works out. readString(stream, term = '"') { const chars = []; let quote = false; while (true) { const { value, done } = stream.next(); if (done) { throw new Error("Premature end of string"); } if (quote) { switch (value) { case 't': chars.push("\t"); break; case 'n': chars.push("\n"); break; case 'r': break; case '/': chars.push("/"); break; case '|': chars.push("|"); break; default: chars.push(value); } quote = false; } else { switch (value) { case term: return chars.join(''); case '/': quote = true; break; default: chars.push(value); } } } } // Read # macros async readSharp(stream) { const { value: ch, done } = await stream.next(); if (done) throw new Error("Premature end"); switch (ch) { case "'": return list(LSymbol.FUNCTION, await this.readInternal(stream)); case '+': { const test = await this.readInternal(stream); const value = await this.readInternal(stream); if (featurep(this.world, test)) { return value; } return undefined; } case '-': { const test = await this.readInternal(stream); const value = await this.readInternal(stream); if (!featurep(this.world, test)) { return value; } return undefined; } case '/': { const { value, done } = stream.next(); if (done) throw new Error("Premature end"); return value.charCodeAt(0); } case '^': { const { value, done } = stream.next(); if (done) throw new Error("Premature EOF"); return value.charCodeAt(0) - "A".charCodeAt(0); } case '\\': { const name = await this.readInternal(stream); const val = { SPACE: ' ', SP: ' ', TAB: ' ', RETURN: '\r', NEWLINE: '\n', FORMFEED: '\f', LINEFEED: '\f', NL: '\n' }[name]; if (val) return val.charCodeAt(0); throw new Error(`The character #\\${name} is not defined.`); } case 'o': { const pbase = LSymbol.IBASE.value; try { LSymbol.IBASE.value = 8; return await this.readInternal(stream); } finally { LSymbol.IBASE.value = pbase; } } case 'x': { const pbase = LSymbol.IBASE.value; try { LSymbol.IBASE.value = 16; return await this.readInternal(stream); } finally { LSymbol.IBASE.value = pbase; } } case 'M': return this.readInternal(stream); case 'Q': case 'N': await this.readInternal(stream); return undefined; case '.': { const form = await this.readInternal(stream); return this.world.eval(form); } default: throw new Error(`Unknown reader macro: #${ch}`); } } // Internal reader; can return undefined async readInternal(stream, once, eofval) { while (true) { await this.skip(stream); const pos = stream.filepos; try { let { value, done } = stream.next(); if (done) { if (eofval !== undefined) { return eofval; } throw new Error(`End of file`); } let op = value.length > 1 ? 'symbol' : this.readtable[value]; if (!op && value.charCodeAt(0) < 32) { op = 'symbol'; value = '^' + "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"[value.charCodeAt(0)]; } switch (op || value) { case 'space': stream.unread(value); await this.skip(stream); break; case '(': return this.readList(stream); case '+': if (/^[0-9]$/.test(stream.peek())) { return this.readNumber(stream); } return this.intern('+'); case '-': if (/^[0-9]$/.test(stream.peek())) { return -(await this.readNumber(stream)); } return this.intern('-'); case 'number': stream.unread(value); return this.readNumber(stream); case 'symbol': stream.unread(value); return this.readSymbol(stream); case 'comment': stream.unread(value); await this.skipComment(stream); break; case '"': return this.readString(stream); case '|': return this.intern(await this.readString(stream, '|')); case "'": return list(LSymbol.QUOTE, await this.readInternal(stream)); case '`': return list(LSymbol.BACKQ, await this.readInternal(stream)); case ',': { const { value: cv, done: cd } = stream.next(); if (cd) throw new Error('Premature EOF in comma'); const splice = cv === '.' || cv === '@'; const csym = splice ? LSymbol['COMMA*'] : LSymbol.COMMA; if (!splice) { stream.unread(cv); } return list(csym, await this.readInternal(stream)); } case '#': { const val = await this.readSharp(stream); if (once || val !== undefined) { return val; } } break; case '.': throw new Error('Unexpected "."'); case ')': throw new Error('unexpected ")"'); case undefined: throw new Error(`unexpected "${value}"`); default: throw new Error( `Unknown op ${op} for ${value} (${value.charCodeAt(0)})` ); } } catch (e) { e.filepos = pos; throw e; } } } async read(stream, eofval) { let read_start = stream.filepos; try { await this.skip(stream); read_start = stream.filepos; const val = await this.readInternal(stream, undefined, eofval); return val; } catch (e) { e.file = stream.name; e.filepos = stream.filepos; e.lineno = stream.lineno; e.charpos = stream.charpos; e.message = `${e.message} at ${e.file}:${stream.lineno}:${ stream.charpos } [${stream.show(read_start)}]`; throw e; } } }36:Tf94,LSymbol = { const sym = s => { if (s instanceof LSymbol) { return s; } else if (s === null) { return LSymbol.NIL; } throw new Error(`${lprint(s)} is not a symbol`); }; const setsym = s => { if (sym(s).name in ['NIL', 'T']) { throw new Error(`The symbol ${s.name} cannot be modified`); } return s; }; const validVal = name => v => v === undefined ? v : valid(e => `Assigning invalid value to ${this.name}: ${e}`); class LSymbol extends LBaseObject { constructor(name, value, plist) { super(); const vv = validVal(name); this.name = name; this.value = vv(value); this.plist = vv(plist) || null; // plist is never undefined. } toString() { if (this.pname) { return this.pname; } const pname = this.name.replace(/[^A-Z0-9!@$%^&*<>+=~_-]/g, c => `/${c}`); const pcountr = pname.replace(/[^\/]/g, ''); if (pcountr.length > 3) { return (this.pname = `|${this.name.replace(/\|/g, '/|')}|`); } return (this.pname = pname); } set(value) { this.value = validVal(this.name)(value); } getprop1(key) { let rest = this.plist; while (rest) { if (rest.car === key) return rest.cdr; rest = cddr(rest); } } // For implementation convenience getprop(key) { const cell = this.getprop1(sym(key)); if (cell) return car(cell); return null; } putprop(value, key) { valid(v => `Invalid value in PUTPROP ${this.name}: ${v}`)(value); const cell = this.getprop1(sym(key)); if (cell) { return rplaca(cell, value); } this.plist = listS(key, value, this.plist); return value; } remprop(key) { let head = this.plist; let p = null; let t = head; while (t) { if (car(t) == key) { if (p) { p.cdr = cddr(t); } else { this.plist = cddr(t); } return LSymbol.T; } p = t; t = cddr(t); } return null; } get expr() { return this.getprop(LSymbol.EXPR); } get fexpr() { return this.getprop(LSymbol.FEXPR); } get macro() { return this.getprop(LSymbol.MACRO); } get array() { return this.getprop(LSymbol.ARRAY); } set expr(fn) { Reflect.defineProperty(fn, 'name', { value: this.name }); return this.putprop(fn, LSymbol.EXPR); } set fexpr(fn) { Reflect.defineProperty(fn, 'name', { value: this.name }); return this.putprop(fn, LSymbol.FEXPR); } set macro(fn) { Reflect.defineProperty(fn, 'name', { value: this.name }); return this.putprop(fn, LSymbol.MACRO); } set array(fn) { Reflect.defineProperty(fn, 'name', { value: this.name }); return this.putprop(fn, LSymbol.ARRAY); } } // These are shared between all worlds. LSymbol.globals = [ 'DO', 'AND', 'OR', 'LAMBDA', 'EXPR', 'FEXPR', 'MACRO', 'T', 'NIL', 'NOT', 'QUOTE', 'FUNCTION', 'MACLISP', 'PAGING', 'WEB', 'FEATURE', 'NOFEATURE', 'FIXNUM', 'FLONUM', 'ARRAY', 'BASE', 'IBASE', 'STORE', 'STRING', 'LOCAL', 'OBARRAY', 'BACKQ', 'COMMA', 'COMMA*', 'STATUS', 'LOAD', 'EVAL', '&OPTIONAL', '&REST', '&BODY', // Same as &REST but provides code formatting clue. '&WHOLE', '&AUX', 'LOCATION', 'VERSION', '--LEXPR-FRAME--' ].map(s => new LSymbol(s)); LSymbol.globals.forEach(s => (LSymbol[s.name] = s)); LSymbol.NIL.value = null; LSymbol.T.value = LSymbol.T; LBaseObject.T = LSymbol.T; LBaseObject.LSymbol = LSymbol; Reflect.defineProperty(LSymbol.prototype, Symbol.toStringTag, { get() { return this.name || this.constructor.name; } }); Object.assign(LSymbol, { sym, setsym }); return LSymbol; }37:T2f75,class World { constructor() { this.readtable = new LReadTable(L_DEFAULT_READTABLE); this.obarray = new LObarray(); this.stack = [new ApplyFrame(LSymbol.MACLISP, null)]; this.reader = new Reader(this); this.modules = []; this.loading = []; this.features = [ LSymbol.MACLISP, LSymbol.PAGING, LSymbol.WEB, LSymbol.STRING ]; this.initObarray(); } skip(stream, eofval) { return this.reader.skip(stream, eofval); } read(stream, eofval) { if (typeof stream === 'string') { return this.read(new LInputStream(stream), eofval); } try { return this.reader.read(stream, eofval); } catch (e) { if (!e.file && stream.path) { e.file = stream.path; } if (!e.filepos) { e.filepos = stream.filepos; e.lineno = stream.lineno; e.charpos = stream.charpos; e.message = `${e.message} at ${e.file}:${stream.lineno}:${stream.charpos}`; } } } intern(str) { return this.obarray[str] === undefined ? (this.obarray[str] = new LSymbol(str)) : this.obarray[str]; } // Set up the initial symbols in the symbol table ("obarray"). initObarray() { // Wrap an ordinary function to ignore WORLD. const w = fn => (world, ...args) => fn(...args); // wrap a FEXPR const fexpr = fn => (world, form) => fn(world, form); const ob = this.obarray; // Access/create a symbol. const o = s => this.intern(s); // Define an autoload const AUTOLOAD = o('AUTOLOAD'); const autoload = (name, loc) => o(name).putprop(loc, AUTOLOAD); // Copy in the global symbols with references in LSymbol. LSymbol.globals.forEach(s => (ob[s.name] = s)); ob.OBARRAY = LSymbol.OBARRAY; ob.OBARRAY.value = ob; ob.READTABLE = new LSymbol('READTABLE'); ob.READTABLE.value = this.readtable; ob.NIL = null; ob.T.value = true; o('TYO').value = o('TYO'); o('TYI').value = o('TYI'); o('BASE').value = 10; o('IBASE').value = 10; o('EVAL').expr = w(f => this.eval(f)); o('APPLY').expr = w((f, ...args) => this.apply(f, ...args)); o('QUOTE').fexpr = fexpr(f_quote); o('FUNCTION').fexpr = fexpr(f_function); const arith = (fixop, fop, op, fn) => { o(fixop).expr = (world, ...args) => fn(fixnum)(args); o(op).expr = o(fop).expr = (world, ...args) => fn(num)(args); }; o('^').expr = w((b, e) => Math.exp(b, e)); arith('+', '+$', 'PLUS', nums => args => args.reduce((acc, v) => acc + nums(v), 0) ); arith('-', '-$', 'DIFFERENCE', nums => args => args .slice(1) .reduce((acc, v) => acc - nums(v), nums(args.length ? args[0] : 0)) ); arith('*', '*$', 'TIMES', nums => args => args.reduce((acc, v) => acc * nums(v), 1) ); arith('/', '/$', 'QUOTIENT', nums => args => args .slice(1) .reduce((acc, v) => acc / nums(v), nums(args.length ? args[0] : 1)) ); o('1+').expr = w(n => fixnum(n) + 1); o('1-').expr = w(n => fixnum(n) - 1); o('=').expr = w((a, b) => a === b); o('!=').expr = w((a, b) => a === b); o('>').expr = w((a, b) => a > b); o('>=').expr = w((a, b) => a >= b); o('<=').expr = w((a, b) => a <= b); o('IF').fexpr = fexpr(f_if); o('DEFUN').fexpr = fexpr(f_defun); o('DEFVAR').fexpr = fexpr(f_defvar); o('DEFCONST').fexpr = fexpr(f_defconst); o('DEFMACRO').fexpr = fexpr(f_defmacro); o('DEFPROP').fexpr = fexpr(f_defprop); o('MACROEXPAND').expr = macroexpand; o('MACROEXPAND-1').expr = macroexpand_1; o('READ').expr = (world, stream, eof) => world.read(stream, eof); o('STATUS').fexpr = fexpr(f_status); o('SSTATUS').fexpr = fexpr(f_sstatus); o('SETSYNTAX').expr = w(nop); o('LISTP').expr = w(listp); o('ATOM').expr = w(atom); o('CONS').expr = w(cons); o('LIST').expr = w(list); o('LIST*').expr = w(listS); o('NCONS').expr = w(ncons); o('CAR').expr = w(car); o('CDR').expr = w(cdr); o('CAAR').expr = w(caar); o('CADR').expr = w(cadr); o('CDAR').expr = w(cdar); o('CDDR').expr = w(cddr); o('CAAAR').expr = w(caaar); o('CAADR').expr = w(caadr); o('CADAR').expr = w(cadar); o('CADDR').expr = w(caddr); o('CDAAR').expr = w(cdaar); o('CDADR').expr = w(cdadr); o('CDDAR').expr = w(cddar); o('CDDDR').expr = w(cdddr); o('CAAAAR').expr = w(caaaar); o('CAAADR').expr = w(caaadr); o('CAADAR').expr = w(caadar); o('CAADDR').expr = w(caaddr); o('CADAAR').expr = w(cadaar); o('CADADR').expr = w(cadadr); o('CADDAR').expr = w(caddar); o('CADDDR').expr = w(cadddr); o('CDAAAR').expr = w(cdaaar); o('CDAADR').expr = w(cdaadr); o('CDADAR').expr = w(cdadar); o('CDADDR').expr = w(cdaddr); o('CDDAAR').expr = w(cddaar); o('CDDADR').expr = w(cddadr); o('CDDDAR').expr = w(cdddar); o('CDDDDR').expr = w(cddddr); o('RPLACA').expr = w(rplaca); o('RPLACD').expr = w(rplacd); o('SUBST').expr = w(subst); o('APPEND').expr = w(append); o('MAPC').expr = mapc; o('MAPCAR').expr = mapcar; o('DELQ').expr = w(delq); o('DELETE').expr = w(e_delete); o('MEMQ').expr = w(memq); o('SI:LOOP-TMEMBER').expr = w(memq); o('MEMBER').expr = w(member); o('ASSQ').expr = w(assq); o('SI:LOOP-TASSOC').expr = w(assq); o('ASSOC').expr = w(assoc); o('BACKQ').fexpr = fexpr(f_backq); o('GET').expr = w(getprop); o('PUTPROP').expr = w(putprop); o('PLIST').expr = w(plist); o('REMPROP').expr = w(remprop); o('INTERN').expr = (world, s) => world.intern(s); o('NOT').expr = w(v => (v ? null : LSymbol.T)); o('NULL').expr = w(v => (v ? null : LSymbol.T)); o('SYMBOLP').expr = w(symbolp); o('BOUNDP').expr = w(boundp); o('FBOUNDP').expr = w(fboundp); o('MAKBOUNDP').expr = w(v => ((setsym(v).value = undefined), v)); o('EQUAL').expr = w(equal); o('EQ').expr = w(eq); o('SI:LOOP-TEQUAL').expr = w(eq); o('SYMEVAL').expr = w(symeval); o('GENSYM').expr = w(gensym); o('COPYSYMBOL').expr = w(gensym); o('SET').expr = (world, symbol, val) => (setsym(symbol).value = val); o('SETQ').fexpr = fexpr(f_setq); o('SETQ-IF-UNBOUND').fexpr = fexpr(f_setq_if_unbound); o('ASCII').expr = ascii; o('*ARRAY').expr = w(Sarray); o('ARRAY').fexpr = fexpr(f_array); o('STORE').fexpr = fexpr(f_store); o('ARRAY-STORE').expr = w(arrayStore); o('ARRAYCALL').expr = w(arraycall); o('COND').fexpr = fexpr(f_cond); o('CASEQ').fexpr = fexpr(f_caseq); o('PROGN').fexpr = fexpr(f_progn); o('PROGV').fexpr = f_progv; o('AND').fexpr = fexpr(f_and); o('OR').fexpr = fexpr(f_or); o('EVAL-WHEN').fexpr = fexpr(f_eval_when); o('SPECIAL').fexpr = fexpr(nop); o('*EXPR').fexpr = fexpr(nop); o('LET').fexpr = fexpr(f_let); o('DO').fexpr = fexpr(f_do); o('COMMENT').fexpr = fexpr(nop); o('DECLARE').fexpr = fexpr(nop); o('HERALD').fexpr = fexpr(f_herald); o('FEATUREP').expr = featurep; o('DEF-OR-AUTOLOADABLE').fexpr = fexpr(nop); o('NOUUO').expr = w(nop); o('*RSET').expr = w(nop); o('ARG').expr = w(arg); o('LISTIFY').expr = w(listify); o('BACKTRACE').expr = backtrace; o('ERROR').expr = w(error); o('ENDPAGEFN').expr = w(nop); o('OPEN').expr = w(open); o('LOAD').expr = e_load; o('INCLUDE').fexpr = fexpr(f_include); o('READ').expr = w(stream => this.read(stream)); o('CLOSE').expr = w(close); o('LOG').expr = w(log); autoload('FORMAT', 'attach;null'); autoload('BACKQ', 'attach;null'); autoload('BACKQ', 'attach;null'); autoload('COMMA', 'attach;null'); autoload('COMMA*', 'attach;null'); } // Evaluate a form. The CAR denotes a function of some type. // It can be a LAMBDA expression, or a symbol with an EXPR property, // in which case, normal evalation happens. // A symbol with a FEXPR property denotes a special form; evaluation // is handled by the function stored in that property. // A symbol with a MACRO property denotes a macro form; the macro // function is invoked to produce a new expression which is evaluated // in its place. async eval(form) { const evalArgs = arglist => evalList(this, arglist); const do_eval = async () => { if (form instanceof LSymbol) { const val = form.value; if (val === undefined) { throw new Error(`The symbol ${form.name} is not bound.`); } return val; } else if (form === null) { return null; } else if (form === true) { return true; } else if (typeof form === 'number') { return form; } else if (typeof form === 'string') { return form; } if (form instanceof LCons) { const { car: fn, cdr: arglist } = form; if (fn instanceof LSymbol) { const macro = fn.macro; if (macro) { return this.eval(await this.apply(macro, form)); } const fexpr = fn.fexpr; if (fexpr) { return this.apply(fexpr, cdr(form)); } const expr = fn.expr; if (expr) { return this.apply(expr, ...(await evalArgs(arglist))); } } else if (fn instanceof LCons) { return this.apply(fn, ...(await evalArgs(arglist))); } if (fn instanceof LSymbol) { throw new Error(`Function ${lprint(fn)} is not defined.`); } throw new Error(`Bad Function: ${lprint(fn)}`); } throw new Error(`Bad form: ${form}`); }; const val = await this.withFrame(new EvalFrame(form), do_eval); return valid( v => `The expression ${lprint(form)} evaluated to invalid value ${v}.` )(val); } // Evaluate a sequence of forms and return the last value async prognBody(body, logTag) { let result = null; for (const f of iter(body)) { result = await this.eval(f); if (logTag) { console.log(logTag, lprint(f), lprint(result)); } } return result; } // Evaluate a sequence of forms and return a list of the results. async evalList(list) { const result = []; for (const e of iter(list)) { result.push(await this.eval(e)); } return result; } // Apply the supplied function to the supplied arguments. // Function can be a Javascript function taking (world, ...args), // or a LAMBDA expression, or a symbol with an EXPR property // that is one of the above. // May return a promise apply(fn, ...args) { if (typeof fn === 'function' && fn.noframe) { return fn(this, ...args); } const do_apply = frame => { if (typeof fn === 'function') { return fn(this, ...args); } else if (fn instanceof LSymbol && fn.expr) { return this.apply(fn.expr, ...args); } else if (fn instanceof LCons && fn.car === LSymbol.LAMBDA) { const { car: bindings, cdr: body } = cdr(fn); if (symbolp(bindings)) { // Weird LEXPR cruft, but it's out there. frame.bind(LSymbol['--LEXPR-FRAME--'], frame); frame.lexprCount = [...iter(args)].length; frame.applyBindings([bindings], [frame.lexprCount]); return this.prognBody(body); } else { const nnfn = (...args) => makeFunction(this, null, bindings, body)(this, ...args); return nnfn(...args); } } throw new Error(`Bad function in APPLY: ${fn}`); }; return this.withFrame(new ApplyFrame(fn, args), do_apply); } bind(sym, val) { return this.stack[this.stack.length - 1].bind(sym, val); } // Activate a stack frame. This provides backtrace and unwinding. async withFrame(frame, fn) { try { this.stack.push(frame); const val = await fn(frame); frame.return = val; return val; } catch (error) { // Fill in the stack on the innermost level error.lstack = error.lstack || [...this.stack]; frame.error = error; throw error; } finally { this.stack.pop().unwind(); } } }38:T62c,md`### Evaluation The \`World\` includes the evaluation functionaty; it is basically a complete interpreter. Interpreted Maclisp uses shallow-bound dynamic variables, rather than lexical variables that are more the norm in modern languages. Compiled Maclisp uses a mixture; variables are lexical (except not closed over) except when declared to be \`special\` (i.e. dynamic). Because some of the code depends on dynamic variables, I went with the interpreter behavior, to avoid having to implement both. Lexical variables are not that difficult—we had them in NIL and Symbolics lisps, and it's the route I would go for any modern language. Dynamic variables complicate threading. In Symbolics Lisp, it meant that on every thread context switch, the dynamic variables from one stack had to be unwound, and reinstated for the stack being resumed. Our evaluation stack frames below implement this, as it turns out to also be useful for debugging. After an error, looking at old stack frames is not very informative, unless new the values being unwound are swapped into the frame, instead of the old values being restored by overwriting. This also supports "evaluate in frame" debugging capabilities, something Maclisp had, and which is the norm in modern debuggers. Evaluation and apply frames alternate; the eval frames show what form was being evaluated, and the apply frame shows the result of evaluating each of the arguments. The frames can be examined in various ways, including via the Observable inspector, and by running Lisp code via the \`(backtrace)\` function. `39:T559,ApplyFrame = { class ApplyFrame extends Frame { constructor(fn, args) { super({ fn, args, bindings: new Map() }); } applyBindings(bindings, values) { let i = 0; if (bindings) { for (const b of bindings) { this.bind(b, values[i++]); } } } bind(variable, value) { // variable can be NIL, meaning ignore. if (variable) { // Save current this.bindings.set(setsym(variable), variable.value); // Set new variable.value = valid( v => `The variable ${variable.name} is being set to invalid value ${v}.` )(value); } } // Restore all the bound variables from this apply frame. unwind() { this.bindings.forEach((value, sym) => { // Swap old and new values. const v = setsym(sym).value; sym.value = value; this.bindings.set(sym, v); }); } } Reflect.defineProperty(ApplyFrame.prototype, Symbol.toStringTag, { get() { const fnName = !this.fn ? '??' : this.fn.name ? `#'${this.fn.name}` : typeof this.fn === 'function' ? lprint(this.fn) : `#'${lprint(this.fn)}`; return `apply ${fnName} (${ this.args ? [...iter(this.args)].map(lprint).join(' ') : '' })`; } }); return ApplyFrame; }3a:Tdaf,LCons = { const valid = LBaseObject.valid; const vcns = v => (v instanceof LCons ? v : thrw(`Not a CONS: ${v}`)); const car = l => (l !== null ? vcns(l).car : null); const cdr = l => (l !== null ? vcns(l).cdr : null); const caar = l => car(car(l)); const cdar = l => cdr(car(l)); const cadr = l => car(cdr(l)); const cddr = l => cdr(cdr(l)); const caaar = l => car(car(car(l))); const cadar = l => car(cdr(car(l))); const caadr = l => car(car(cdr(l))); const caddr = l => car(cdr(cdr(l))); const cdaar = l => cdr(car(car(l))); const cddar = l => cdr(cdr(car(l))); const cdadr = l => cdr(car(cdr(l))); const cdddr = l => cdr(cdr(cdr(l))); const caaaar = l => car(car(car(car(l)))); const caadar = l => car(car(cdr(car(l)))); const caaadr = l => car(car(car(cdr(l)))); const caaddr = l => car(car(cdr(cdr(l)))); const cadaar = l => car(cdr(car(car(l)))); const caddar = l => car(cdr(cdr(car(l)))); const cadadr = l => car(cdr(car(cdr(l)))); const cadddr = l => car(cdr(cdr(cdr(l)))); const cdaaar = l => cdr(car(car(car(l)))); const cdadar = l => cdr(car(cdr(car(l)))); const cdaadr = l => cdr(car(car(cdr(l)))); const cdaddr = l => cdr(car(cdr(cdr(l)))); const cddaar = l => cdr(cdr(car(car(l)))); const cdddar = l => cdr(cdr(cdr(car(l)))); const cddadr = l => cdr(cdr(car(cdr(l)))); const cddddr = l => cdr(cdr(cdr(cdr(l)))); class LCons extends LBaseObject { constructor(car, cdr) { super(); const check = valid(v => `Invalid Lisp object to CONS: ${v}`); this.car = check(car); this.cdr = check(cdr); } [Symbol.iterator]() { function* listIter(l) { while (l) { yield car(l); l = cdr(l); } } return listIter(this); } getprop1(key) { let rest = this.cdr; while (rest) { if (rest.car === key) return cdr(rest); rest = cddr(rest); } } // For implementation convenience getprop(key) { const cell = this.getprop1(key); if (cell) return car(cell); return null; } setprop(value, key) { const cell = this.getprop1(key); if (cell) { if (cell instanceof LCons) { return (cell.car = value); } throw new Error(`${lprint(cell)} is not a CONS.`); } this.cdr = new LCons(key, new LCons(value, this.cdr)); return value; } remprop(key) { let p = this; let t = cdr(p); while (t) { if (car(t) == key) { p.cdr = cddr(t); return LBaseObject.T; } p = t; t = cddr(t); } return null; } toString() { // optimize "."; const frags = ['(']; let l = this; while (l) { if (l instanceof LCons) { if (l !== this) frags.push(' '); frags.push(lprint(l.car)); } else if (l) { frags.push(' . '); frags.push(lprint(l)); break; } l = l.cdr; } frags.push(')'); return frags.join(''); } } Object.assign(LCons, { vcns, car, cdr, caar, cdar, cadr, cddr, caaar, cadar, caadr, caddr, cdaar, cddar, cdadr, cdddr, caaaar, caadar, caaadr, caaddr, cadaar, caddar, cadadr, cadddr, cdaaar, cdadar, cdaadr, cdaddr, cddaar, cdddar, cddadr, cddddr }); LBaseObject.LCons = LCons; return LCons; }3b:T6dd,Sarray = (name, type, dim1, dim2, dim3, dim4, dim5) => { const dims = [dim1, dim2, dim3, dim4, dim5].map(d => typeof d === 'number' ? d : 1 ); const [d1, d2, d3, d4, d5] = dims; const len = dims.reduce((acc, v) => (typeof v === 'number' ? v : 1) * acc, 1); const index = (i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0) => i1 * d1 + i2 * d2 + i3 * d3 + i4 * d4 + i5 * d5; const fillArray = val => array => { for (let i = 0; i < len; i++) { array[i] = val; } return array; }; const initArray = val => array => { const fill = fillArray(val); const arrayGet = (...dims) => { const i = index(...dims); if (i < 0 || i >= len) throw new RangeError(); return array[i]; }; const arraySet = (val, ...dims) => { const i = index(...dims); if (i < 0 || i >= len) throw new RangeError(); return (array[i] = val); }; const arrayFn = (world, ...args) => arrayGet(...args); arrayFn.fill = fill; arrayFn.get = arrayGet; arrayFn.set = arraySet; arrayFn.type = type; if (name) arrayFn.name = name; arrayFn.length = length; arrayFn.dimensions = dims; }; const makeArray = () => { switch (type) { case LSymbol.OBARRAY: return new LObarray(dims[0]); case LSymbol.READTABLE: return new LReadTable(dims[0]); case LSymbol.T: return initArray(null)([]).fill(); case LSymbol.FIXNUM: return initArray(0)(new Int32Array(len)); case LSymbol.FLONUM: return initArray(0)(new Float32Array(len)); default: throw new Error(`Unknown array type ${lprint(type)}`); } }; const array = makeArray(); if (name) { putprop(name, array, LSymbol.ARRAY); } return array; }3c:Td72,makeFunction = (world, name, arglist, body) => { const aRest = LSymbol['&REST']; const aOptional = LSymbol['&OPTIONAL']; const aAux = LSymbol['&AUX']; const aBody = LSymbol['&BODY']; const fn = (world, ...args) => { const do_bindings_lexpr = async frame => { // Weird LEXPR cruft, but it's out there. frame.bind(LSymbol['--LEXPR-FRAME--'], frame); const lexprCount = (frame.lexprCount = args.length); frame.bind(arglist, lexprCount); return world.prognBody(body); }; const do_bindings = async frame => { const destructure = (b, a) => b === null ? null : symbolp(b) ? frame.bind(b, a) : listp(b) ? (destructure(car(b), car(a)), destructure(cdr(b), cdr(a))) : thrw(`Illegal binding: ${b}`); let mode = 'REQUIRED'; let i = 0; for (const a of iter(arglist)) { switch (a) { case aOptional: mode = 'OPTIONAL'; break; case aRest: case aBody: mode = 'REST'; break; case aAux: mode = 'AUX'; break; default: switch (mode) { case 'REQUIRED': if (i >= args.length) { throw new Error(`Too few arguments in ${lprint(name)}.`); } destructure(a, args[i++]); break; case 'OPTIONAL': if (a instanceof LSymbol) { frame.bind(setsym(a), args[i++] || null); } else { const arg_present = args.length > i++; if (a) { destructure( car(a), arg_present ? args[i - 1] : await world.eval(cadr(a)) ); const initp = car(cddr(a)); if (initp) { frame.bind(setsym(initp), arg_present ? LSymbol.T : null); } } else { i++; } } break; case 'REST': if (a) { frame.bind(setsym(a), list(...args.slice(i))); } mode = 'DONE'; break; case 'AUX': if (a) { if (symbolp(a)) { frame.bind(setsym(a), null); } else if (listp(a)) { destructure(a, await world.eval(cadr(a))); } else { throw new Error(`Illegal &AUX parameter: ${lprint(a)}`); } } break; default: throw new Error( `Invalid argument list in ${lprint(name)}: ${lprint(arglist)}` ); } } } return world.prognBody(body); }; Reflect.defineProperty(do_bindings, 'name', { value: lprint(name || 'anon') }); return world.withFrame( new ApplyFrame(do_bindings, []), symbolp(arglist) ? do_bindings_lexpr : do_bindings ); }; Reflect.defineProperty(fn, 'name', { value: lprint(name || 'anon') }); Reflect.defineProperty(fn, 'lambda', { value: listS(LSymbol.LAMBDA, arglist, body) }); Reflect.defineProperty(fn, 'noframe', { value: true }); return fn; }3d:T4c5,f_defun = (world, form) => { const makeLambda = (arglist, body) => listS(LSymbol.LAMBDA, arglist, body); const namespec = car(form); if (namespec instanceof LSymbol) { const name = namespec; form = cdr(form); if (car(form) === LSymbol.MACRO) { console.log('DEFUN', name.name, 'MACRO'); form = cdr(form); name.macro = makeLambda(car(form), cdr(form)); } else { console.log('DEFUN', name.name, 'EXPR'); name.expr = makeFunction(world, name, car(form), cdr(form)); } setLocation(name); return name; } else { const name = car(namespec); const prop = cadr(namespec); console.log('DEFUN-PROP', lprint(name), lprint(prop)); form = cdr(form); switch (prop) { case LSymbol.MACRO: console.log('DEFUN', name.name, 'MACRO'); name.macro = makeLambda(car(form), cdr(form)); break; case LSymbol.EXPR: console.log('DEFUN', name.name, 'EXPR'); name.expr = makeFunction(world, name, car(form), cdr(form)); break; default: console.log('DEFUN', name.name, prop.name); name.putprop(makeLambda(car(form), cdr(form)), prop); } setLocation(name); return name; } }3e:T5b5,f_do = { const skipMarker = Symbol.for('SKIP'); const f_do = async (world, form) => { console.log('DO'); const oldform = symbolp(car(form)); const once = cadr(form) === null; const [nspecl, ntestl, ...nbody] = [...iter(form)]; const [ovar, oinit, ostep, otest, ...obody] = [...iter(form)]; const specs = oldform ? [list(ovar, oinit, ostep)] : [...nspecl]; const vars = specs.map(car); const inits = await evalList(world, specs.map(cadr)); const steps = specs.map(s => (cddr(s) ? car(cddr(s)) : skipMarker)); const [ntest, ...nexitforms] = oldform ? [] : [...ntestl]; const test = once ? LSymbol.T : oldform ? otest : ntest; const exitforms = oldform ? null : nexitforms; const body = oldform ? obody : nbody; const frame = new ApplyFrame(LSymbol.DO, null); const do_do = async () => { frame.applyBindings(vars, inits); while (true) { if (await world.eval(test)) { return world.prognBody(exitforms || null); } await world.prognBody(body); let i = 0; const nvals = []; for (const nvar of vars) { const step = steps[i++]; if (step !== skipMarker) { const nval = await world.eval(step); if (nvar) { nvals.push(nval); } } } frame.applyBindings(vars, nvals); } }; return world.withFrame(frame, do_do); }; return f_do; }3f:T690,f_backq = async (world, form) => { const copy = async (f, lvl) => { if (f instanceof LCons) { const ocar = car(f); const ocdr = cdr(f); if (lvl === 0) { if (ocar === LSymbol.COMMA) { return await world.eval(cadr(f)); } if (ocar == LSymbol.BACKQ) { const ncdr = await copy(ocdr, lvl + 1); if (ncdr !== ocdr) { return new LCons(ocar, ncdr); } return f; } if (ocar instanceof LCons && car(ocar) === LSymbol['COMMA*']) { return await world.eval(cadr(ocar)); } const ncar = await copy(car(f), lvl); const ncdr = await copy(cdr(f), lvl); if (ncar === car(f) && ncdr === cdr(f)) { return f; } else { return new LCons(ncar, ncdr); } } else { switch (ocar) { case LSymbol.COMMA: case LSymbol['COMMA*']: { const ncdr = await copy(ocdr, lvl - 1); if (ncdr !== ocdr) { return new LCons(ocar, ncdr); } return f; } case LSymbol.BACKQ: { const ncdr = await copy(ocdr, lvl + 1); if (ncdr !== ocdr) { return new LCons(ocar, ncdr); } return f; } default: const ncar = await copy(ocar, lvl); const ncdr = await copy(ocdr, lvl); if (ncar === car(f) && ncdr === cdr(f)) { return f; } else { return new LCons(ncar, ncdr); } } } } else { return f; } }; return copy(car(form), 0); }40:T5d4,e_load = async (world, path) => { const fpath = toPath( nonnil(v => `Invalid argument to load: ${lprint(v)}`)(path) ); const stream = await open(fpath); const key = `LOAD ${stream.name}`; let form = null; const do_load = async frame => { try { world.loading.push(fpath); world.bind(LSymbol.LOCATION, null); const eof = ['EOF']; while (stream.peek()) { form = await world.skip(stream, eof); if (form === eof) { console.log(key, 'EOF'); world.modules.push(fpath); return null; } LSymbol.LOCATION.value = cons(stream.name || null, stream.filepos || 0); form = await world.read(stream, eof); if (form === eof) { console.log(key, 'EOF'); world.modules.push(fpath); return null; } const val = await world.eval(form); console.log(key, lprint(form), lprint(val)); } } catch (e) { if (!e.file) { e.file = stream.name; e.filepos = stream.filepos; e.lineno = stream.lineno; e.charpos = stream.charpos; e.message = `${e.message} at ${e.file}:${stream.lineno}:${stream.charpos}`; } if (!e.loading) { e.loading = [...world.loading]; } console.error(key, lprint(form), e); throw e; } finally { world.loading.pop(); stream.close(); } }; await world.withFrame(new ApplyFrame(do_load, []), do_load); return null; }41:T6a1,Evaluation = { class Evaluation { constructor(args) { Object.assign(this, args); } async ev(input) { const world = this.world; const [m, p, pp, ppp, s, ss, sss] = [ '-', '+', '++', '+++', '*', '**', '***' ].map(s => world.intern(s)); const EOF = ['EOF']; const stream = new LInputStream(input, 'EV'); while (true) { try { const form = await world.read(stream, EOF); if (form === EOF) { return new Evaluation({ value: s.value, input, form: m.value, world }); } m.value = form; const value = await world.eval(form); console.log('EV', form, value); // mimic the Maclisp REPL ppp.value = pp.value; pp.value = p.value; p.value = form; sss.value = ss.value; ss.value = s.value; s.value = value; } catch (error) { const backtrace = error.lstack || []; return new Evaluation({ error, backtrace, input, form: m.value, world }); } } return new Evaluation({ value: s.value, input, form: m.value, world }); } toString() { return this.error ? this.error.message : lprint(this.value); } } Reflect.defineProperty(Evaluation.prototype, Symbol.toStringTag, { get() { return this.error ? 'ERROR' : this.value === undefined ? this.constructor.name : lprint(this.value); } }); return Evaluation; }42:T6a8,md`# TEACH;LISP The following is my current attempts to load this code, and to work around some of the issues by supplying my own implementation of \`SETF\`. When I get \`SETF\`/\`PUSH\`/\`POP\` finished (soon) I will move it to an attachment in [my virtual filesystem notebook](https://observablehq.com/@bobkerns/locate-its-files). All the other Lisp code is loaded directly from Github, where it has been recovered from various backup tapes. My working strategy is to trim back on dependencies, replacing just what is needed, until I can get it to load. By "trim back", I mean I just redirect the file to an empty file. The compatibility stuff to handle loading compiled vs uncompiled, Maclisp + NIL Lisp + Franz Lisp + Lisp Machine + Multics Lisp is a nightmare made worse by different assumptions about what files are found where. And, of course, I must rely on source files; this is not a [PDP-10 emulator](http://www.avanthar.com/healyzh/decemulation/pdp10emu.html). Along the way I occassionally hit something in the interpreter that I haven't implemented yet. That is turning out to be a small fraction of the time. The Github files are an amalgam of backup tapes from different times and systems, [starting with these](https://web.archive.org/web/20080603053827/http://www.its.os.org:80/) (which are no longer available at this location). (There were four ITS systems at MIT (plus a few others): AI, ML, DM, and MC. MIT-MC is the one where both Lisp development and TEACH;LISP were ongoing during the period of interest. In addition, the directories have been sanitized to remove personal; i.e. any code that lived in my personal directory is not there—as well as my personal email, etc. `43:T1ac8,PATCHES = ev(` ;;; Missing stuff after I exclude files that are too problematic and useless. (defvar macroexpanded nil) (defun FIND-MACRO-DEFINITION (frob &aux fval) ;;; Find a macro definition wherever it lives (cond ((not (symbolp frob)) ()) ((and (boundp 'MACROLIST) (cdr (assq frob macrolist)))) ((setq fval (get frob 'MACRO)) ((+internal-try-autoloadp frob) (find-macro-definition frob))))) ;;; Utility macros (defmacro when (pred &body body) \`(cond (,pred ,@body))) (defmacro unless (pred &body body) \`(cond ((not ,pred) ,@body))) ;;; My own SETF implementation (Based on pattern matching) ;;; A pattern looks like this: \`(my-accesor ,object ,@parameters). ;; Pattern matcher. Patterns look like backquote expressions, but run in reverse. (defun match (pattern form &optional (alist (cons nil form)) (level -1)) (cond ((eq pattern form) alist) ((atom pattern) nil) ((and (eq (car pattern) 'comma) (= level 0)) (cons (cons (cadr pattern) form) alist)) ((and (eq (car pattern) 'comma*) (not (cdr pattern)) (= level 0)) ;; We're only handling the case where ,@var occurrs at the end. ;; I think that's unlikely to be useful for the present purposes. (cons (cons (cadr pattern) form) alist)) ((eq (car pattern) 'comma) (match (cadr pattern) form alist (1- level))) ((eq (car pattern) 'comma*) (match (cadr pattern) form alist (1- level))) ((eq (car pattern) 'backq) (match (cadr pattern) form alist (1+ level))) ((atom form) nil) (t (let ((left (match (car pattern) (car form) alist level))) (and left (match (cdr pattern) (cdr form) left level)))))) ;;; Return a list of variables in a pattern (defun pattern-variables (pattern &optional list) (cond ((atom pattern) list) ((eq (car pattern) 'comma) (cons (cadr pattern) list)) ((eq (car pattern) 'comma*) (cons (cadr pattern) list)) (t (pattern-variables (car pattern) (pattern-variables (cdr pattern) list))))) ;;; Define a SETF handler (defmacro defsetf (name (pattern value) filter &body expander) (let ((form (gensym)) (bindings (gensym)) (vars (pattern-variables pattern))) \`(defun ,name (,form, value) (let ((,bindings (match ',pattern ,form))) (when (and ,bindings ,filter) (let ,(mapcar #'(lambda (b) \`(,b (assoc ',b ,bindings))) vars) ,@expander)))))) ;;; One pass trying all the rules (defun setf-try (target value) (or (setf-symbol target value) (setf-get target value) (setf-car target value) (setf-cdr target value) (setf-caar target value) (setf-cdar target value) (setf-cadr target value) (setf-cddr target value) (setf-caaar target value) (setf-cdaar target value) (setf-cadar target value) (setf-cddar target value) (setf-caadr target value) (setf-cdadr target value) (setf-caddr target value) (setf-cdddr target value) (setf-caaaar target value) (setf-cdaaar target value) (setf-cadaar target value) (setf-cddaar target value) (setf-caadar target value) (setf-cdadar target value) (setf-caddar target value) (setf-cdddar target value) (setf-caaadr target value) (setf-cdaadr target value) (setf-cadadr target value) (setf-cddadr target value) (setf-caaddr target value) (setf-cdaddr target value) (setf-cadddr target value) (setf-cddddr target value))) ;;; The SETF macro itself: (defmacro setf (target value) (let ((prev nil)) (do ((prev nil exp) (exp target (macroexpand-1 exp)) (nfail nil (eq prev exp)) (fail nil nfail) (retval (setf-try target value) (setf-try exp value))) ((or retval fail) (or retval (error "Could not expand")))))) ;;; SETF definitions: (defsetf setf-symbol (\`,sym value) t (when (symbolp sym) \`(setq ,sym ,value))) (defsetf setf-get (\`(get ,obj ,key) value) t \`(putprop ,obj ,value ,key)) (defsetf setf-car (\`(car ,obj) value) t \`(rplaca ,obj ,value)) (defsetf setf-cdr (\`(cdr ,obj) value) t \`(rplacd ,obj ,value)) (defsetf setf-caar (\`(car ,obj) value) t \`(rplaca (car ,obj) ,value)) (defsetf setf-cdar (\`(cdr ,obj) value) t \`(rplaca (cdr ,obj) ,value)) (defsetf setf-cadr (\`(car ,obj) value) t \`(rplacd (car ,obj) ,value)) (defsetf setf-cddr (\`(cdr ,obj) value) t \`(rplacd (cdr ,obj) ,value)) (defsetf setf-caaar (\`(car ,obj) value) t \`(rplaca (caar ,obj) ,value)) (defsetf setf-cdaar (\`(cdr ,obj) value) t \`(rplaca (cdar ,obj) ,value)) (defsetf setf-cadar (\`(car ,obj) value) t \`(rplaca (cadr ,obj) ,value)) (defsetf setf-cddar (\`(cdr ,obj) value) t \`(rplaca (cddr ,obj) ,value)) (defsetf setf-caadr (\`(car ,obj) value) t \`(rplacd (caar ,obj) ,value)) (defsetf setf-cdadr (\`(cdr ,obj) value) t \`(rplacd (cdar ,obj) ,value)) (defsetf setf-caddr (\`(car ,obj) value) t \`(rplaca (cadr ,obj) ,value)) (defsetf setf-cdddr (\`(cdr ,obj) value) t \`(rplacd (cddr ,obj) ,value)) (defsetf setf-caaaar (\`(car ,obj) value) t \`(rplaca (caaar ,obj) ,value)) (defsetf setf-cadaar (\`(cdr ,obj) value) t \`(rplaca (cadar ,obj) ,value)) (defsetf setf-caadar (\`(car ,obj) value) t \`(rplaca (caadr ,obj) ,value)) (defsetf setf-caddar (\`(cdr ,obj) value) t \`(rplaca (caddr ,obj) ,value)) (defsetf setf-caaadr (\`(car ,obj) value) t \`(rplacd (caaar ,obj) ,value)) (defsetf setf-cadadr (\`(cdr ,obj) value) t \`(rplacd (cadar ,obj) ,value)) (defsetf setf-caaddr (\`(car ,obj) value) t \`(rplaca (caadr ,obj) ,value)) (defsetf setf-cadddr (\`(cdr ,obj) value) t \`(rplacd (caddr ,obj) ,value)) (defsetf setf-cdaaar (\`(car ,obj) value) t \`(rplaca (cdaar ,obj) ,value)) (defsetf setf-cddaar (\`(cdr ,obj) value) t \`(rplaca (cddar ,obj) ,value)) (defsetf setf-cdadar (\`(car ,obj) value) t \`(rplaca (cdadr ,obj) ,value)) (defsetf setf-cdddar (\`(cdr ,obj) value) t \`(rplaca (cdddr ,obj) ,value)) (defsetf setf-cdaadr (\`(car ,obj) value) t \`(rplacd (cdaar ,obj) ,value)) (defsetf setf-cddadr (\`(cdr ,obj) value) t \`(rplacd (cddar ,obj) ,value)) (defsetf setf-cdaddr (\`(car ,obj) value) t \`(rplaca (cdadr ,obj) ,value)) (defsetf setf-cddddr (\`(cdr ,obj) value) t \`(rplacd (cdddr ,obj) ,value)) ;;; PUSH and POP ;;; This is where the edge cases of handling SETF come into play. ;;; The naive implementation (like this one, currently) evaluates ;;; the entire path to the cell being set twice. (defmacro push (value dest) (let ((tmp (gensym))) \`(setf ,dest (cons ,value ,dest)))) (defmacro pop (dest) (let ((tmp (gensym))) \`(let ((,tmp ,dest)) (setf ,dest (cdr ,tmp)) ,(car ,tmp)))) `)44:T71d,md`# Testing Testing is having some performance problems, so I've disabled most of them for now. I'll have to look into the cause. I've been informally testing with ad hoc tests in cells, and bulk testing by loading large amounts of code, so it's definitely not untested, but it lacks the ongoing test support of a test suite, sigh. \`\`\`js TESTS.add( [ { id: 'read-symbol', in: 'frobule', out: 'FROBULE' }, { id: 'read-nil', in: 'nil', value: null }, { id: 'read-nil-print', in: 'nil', out: 'NIL' }, { id: 'read-number', in: '75', value: 75 }, { id: 'read-number-print', in: '75', out: '75' }, { id: 'read-empty-list', in: '()', value: null }, { id: 'read-cons', in: '( a . b )', out: '(A . B)' }, { id: 'read-cons-nil', in: '(a . nil)', out: '(A)' }, { id: 'read-list-1', in: '(7)', out: '(7)' }, { id: 'read-list-3', in: '(8 foo bar)', out: '(8 FOO BAR)' }, { id: 'read-empty-string', in: '""', value: '' }, { id: 'read-empty-string-print', in: '""', out: '""' }, { id: 'read-string', in: '"testing"', out: '"testing"' }, { id: 'list-nested', in: '(a (b) c (d))', out: '(A (B) C (D))' }, { id: 'quote', in: "'foo", out: '(QUOTE FOO)' }, { id: 'sharp-quote', in: "#'foo", out: '(FUNCTION FOO)' }, { id: 'quotes-nested', in: "('foo #'bar)", out: '((QUOTE FOO) (FUNCTION BAR))' }, { id: 'condition-true', in: '#+maclisp 5', value: 5 }, { id: 'condition-false', in: '#-maclisp 5 6', value: 6 }, { id: 'condition-nested', in: '(#+maclisp 5 #-maclisp 7 . 8)', out: '(5 . 8)' } ].map(t => ({ id: t.id, test: () => (t.value !== undefined ? a => a : lprint)( read(WORLD)(t.in) ), expect: ex => ex.toEqual(t.value !== undefined ? t.value : t.out) })) ) \`\`\` `45:[] 30:{"id":"981f72f516ca0065","slug":"maclisp","title":"Maclisp","thumbnail":"ceada1e7e0c359640d9f478970a3c41f44d5d1061fc36a9656b8edd388b172c5","access_level":"public","create_time":"$D2019-12-04T02:54:03.176Z","update_time":"$D2021-09-07T16:20:25.044Z","view_time":null,"first_public_time":"$D2019-12-10T21:19:47.231Z","has_unpublished_edits":null,"fork":false,"stars":10,"starred":false,"owner":{"type":"team","id":"a2a391e81ef70f60","login":"bobkerns","name":"Bob Kerns","avatar_url":"https://avatars-next.observableusercontent.com/d3d634f0561198d48f6c5a897f4009b95f14b0014fb7d85f3b6cc5415336b639","tier":"starter_2024"},"version":4504,"publish_version":4504,"role":null,"authored":false,"authors":[{"type":"individual","id":"c30fe465bb675dbe","login":"bobkerns","name":"Bob Kerns","avatar_url":"https://avatars-next.observableusercontent.com/d3d634f0561198d48f6c5a897f4009b95f14b0014fb7d85f3b6cc5415336b639","tier":null}],"members":[{"type":"individual","id":"c30fe465bb675dbe","login":"bobkerns","name":"Bob Kerns","avatar_url":"https://avatars-next.observableusercontent.com/d3d634f0561198d48f6c5a897f4009b95f14b0014fb7d85f3b6cc5415336b639","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":true,"trashed":false,"lapsed":null,"subscribed":null,"forks":3,"collection":null,"type":"notebook","body":{"titling":"auto","title":"Maclisp","cells":[{"id":0,"value":"md`# Maclisp`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3773,"value":"md`**This web page is a working, self-documenting Lisp Interpreter.\\ \nRead on for more info**`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2,"value":"$32","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":7,"value":"md`>I'm not sure how I'm going to organize this as a presentation. I'd like to capture a bit of the process, but without getting too convoluted, and focus on the result. We'll see how it goes...`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3706,"value":"md`> Click to the left of any cell to open it for editing and see how it\n> is implemented. All the core code for the Maclisp interepreter (subset)\n> is right here on this page. It is a substantial subset; I have been loading\n> many libraries. You can create new cells and explore. Later I show one approach\n> to integrating Lisp into cells while leveraging Observable's dependency\n> management. I would like to explore automated dependency management via\n> static analysis (which is pretty straight-forward to do in Lisp).\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":10,"value":"md`## Strings and character-mode input\n\n> I'll use a convention of classes named with an initial L for Lisp datatypes (that is, things visible to the interpreter). The names will be for my convenience, not always mapping to anything in the Maclisp docs or implementation. We'll be relying primarily on my memory of how it functioned and was implemented, in any case...`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":13,"value":"md`Let's start with input streams. File input is a better starting point than terminal, since it enables testing.\n\nFor the sheer hell of it, I'm going to support Unicode. Maclisp was long before Unicode; we had 7-bit ASCII (and for some things, like the filesystem, 6-BIT, limited to upper case).`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":17,"value":"$33","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":20,"value":"md`By the way, we should have a common base class for all Lisp-visible objects. It's nice I don't have to write these in order. I'll go back and edit \\`LInputStream\\` to extend this.\n\nLow level objects printed with an syntax that could not be read. I don't know what \\`PRINT\\` did with them exactly, but let's go with \\`#<_type_-_id_>\\` and make sure that's unreadable in the \\`READTABLE\\` later.\n\nSo we have, for example, this live test case: \\`${new LBaseObject().toString()}\\`.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":24,"value":"LBaseObject = {\n // I like having separate numbering for each type\n const COUNTER = Symbol.for('counter');\n class LBaseObject {\n toString() {\n const idx = (this.constructor[COUNTER] =\n (this.constructor[COUNTER] || 0) + 1);\n return `#<${this.constructor.name}-${idx.toString(16)}>`;\n }\n }\n LBaseObject.valid = e => v =>\n v instanceof LBaseObject ||\n typeof v === 'function' ||\n typeof v === 'number' ||\n typeof v === 'string' ||\n v === null\n ? v\n : v === true\n ? LBaseObject.T\n : v === false\n ? null\n : thrw(e(v));\n return LBaseObject;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":37,"value":"md`And let's test our input stream before we go further...\n\nOne of my lasting regrets is that we in the early Lisp community did not invent unit testing frameworks. We had everything we needed...so I'll toss together a little something here. I'm not sure the best way to integrate testing with Observable, so I've been playing around a bit.\n\nI think what I just implemented will work well enough. Failures are easy to spot and you just open up the cell to examine or change the test code, plus there's a summary table generated at the end.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":40,"value":"TESTS.add([\n {\n id: 'Input-1',\n options: {\n text: 'This is a test.'\n },\n test(options) {\n const input = new LInputStream(options.text, 'Input-1');\n return [...input].join('');\n },\n expect(ex) {\n ex.toEqual(this.options.text);\n }\n },\n {\n id: 'Input-peek',\n options: {\n text: 'This is a test.'\n },\n test(options) {\n const input = new LInputStream(options.text, 'Input-1');\n return [input.peek(), input.peek(), ...input].join('');\n },\n expect(ex) {\n ex.toEqual('TT' + this.options.text);\n }\n }\n])","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":215,"value":"$34","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3552,"value":"md`## Reader\nI'm going to need a reader to read and parse Lisp code.\n\nIt turned out I needed just about all of the reader's detailed functionality except for the ability to customize further. The code I'm trying to run has tracked 20 years of LISP evolution and is all over the map, rather than the relatively clean code I wrote originally. (Even that was in some obscure corners of the implementation to give the right user experience.)\n\nRather than allowing user-defined modifications to the syntax, I mostly hardwired the specific combination of features in use in the body of code I'm loading. Even so, there was a fair bit to get right that made it a lot more complex than the simple recursive-descent parsing I've used when I could define my own syntax without any\ncompatibility constraints.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3560,"value":"md`#### Readtable\nThe readtable is a Maclisp object, a specialized type of array. I don't try for\nany real compatibilty. For now, I ignore attempts to change its settings, allow\ncopying, and hardwire what I need.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":683,"value":"LReadTable = {\n class LReadTable extends LBaseObject {\n constructor(state = {}) {\n super();\n Object.assign(this, state);\n }\n }\n LReadTable.initReadtable = readtable => {\n const assignSet = (chars, tag) =>\n [...chars].reduce((acc, ch) => ((acc[ch] = tag), acc), {});\n return Object.assign(\n readtable,\n { '.': '.', ';': 'comment' },\n assignSet(\n \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@~!%&$*/%^?<=>:[]{}\\\\_\",\n 'symbol'\n ),\n assignSet(\"0123456789+-\", 'number'),\n assignSet(\" \\t\\n\\f\", 'space')\n );\n };\n return LReadTable;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":697,"value":"L_DEFAULT_READTABLE = new LReadTable(LReadTable.initReadtable({}))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3562,"value":"md`#### Reader\nI moved the \\`Reader\\` into a class for compact modularity and to minimize the inter-cell dependencies.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1014,"value":"$35","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1169,"value":"// Used for feature checks\nfeaturep = {\n const featurep = (world, v) => {\n if (v instanceof LCons) {\n switch (car(v)) {\n case LSymbol.AND:\n for (const s of cdr(v)) {\n if (!featurep(world, s)) return null;\n }\n return LSymbol.T;\n case LSymbol.NOT:\n return (!featurep(world, cadr(v)) && LSymbol.T) || null;\n case LSymbol.OR:\n for (const s of cdr(v)) {\n if (featurep(world, s)) return LSymbol.T;\n }\n return null;\n case LSymbol.LOCAL:\n return featurep(world, cadr(v));\n default:\n throw new Error(`Bad spec: ${lprint(v)}`);\n }\n }\n return (world.features.find(s => s === v) && LSymbol.T) || null;\n };\n return featurep;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":787,"value":"md`### Symbols\nI'm going to need symbols, of course, and an obarray (symbol table) to store them in.\n\nThe \\`LSymbol\\` class also includes various well-known symbols frequently referenced in code.\nThese are included in every World's obarray, so end up being shared. This is more convenient\nthan making sure every place that needs them has access to the current World.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":776,"value":"$36","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3568,"value":"md`#### Obarray\nThe obarray (symbol table) is a Maclisp object. Like the readtable, it is a specialized\nkind of array. The only operation I presently allow is \"intern\", that is, look up and return\na symbol by name, creating it if needed. This is usually done automatically by the reader,\nbut can by called manually.\n\nTEACH;LISP uses multiple obarrays to separate namespaces, keeping its internal code from being\nexposed to the student and possibly leading to confusion.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":785,"value":"class LObarray extends LBaseObject {}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":872,"value":"md`## World\nA bit of fancy initialization here to avoid circularity. Basically, all the global state in one place,\nso that there's no inter-cell references, avoiding most of the circularity issues. As a side-effect, we get\nmultiple worlds, sharing only a few key symbols.\n\nThis gives access to the reader (including readtable and obarray) and evaluator.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":840,"value":"$37","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":827,"value":"WORLD = new World()","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3572,"value":"$38","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1444,"value":"class Frame extends LBaseObject {\n constructor(args) {\n super();\n Object.assign(this, args);\n }\n unwind() {}\n\n toString() {\n return this[Symbol.toStringTag];\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1447,"value":"EvalFrame = {\n class EvalFrame extends Frame {\n constructor(form) {\n super({ form });\n }\n }\n Reflect.defineProperty(EvalFrame.prototype, Symbol.toStringTag, {\n get() {\n return `eval ${lprint(this.form)}`;\n }\n });\n return EvalFrame;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1452,"value":"$39","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":808,"value":"md`### Lists (CONS)\nOf course, we need conses so we can have lists. Symbols have property lists. We use \\`null\\` \nfor the empty list \\`NIL\\` Which is also a symbol, so we'll have to fake it somewhere\n(as did the real implementation)`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":805,"value":"$3a","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1821,"value":"md`### Utilities\nVarious type checking stuff.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1826,"value":"num = n => {\n if (typeof n === 'number') {\n return n;\n }\n throw new Error(`${lprint(n)} is not a number.`);\n };","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1829,"value":"fixnum = n => {\n if (\n num(n) % 1 !== 0 ||\n n > Number.MAX_SAFE_INTEGER ||\n n < Number.MIN_SAFE_INTEGER\n ) {\n throw new Error(`${lprint(n)} is not a fixnum`);\n }\n return n;\n }","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1836,"value":"sym = LSymbol.sym","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1825,"value":"setsym = LSymbol.setsym","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2100,"value":"nonnil = e => v => (v !== null ? v : thrw(e(v)))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2650,"value":"md`Check for valid cons (vcns) or list (vlst)`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2648,"value":"vcns = LCons.vcns","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2654,"value":"vlst = v => (v === null ? null : vcns(v))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2021,"value":"thrw = e => {\n throw new Error(e);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2019,"value":"defined = e => v => (v === undefined ? thrw(e(v)) : v)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2077,"value":"valid = LBaseObject.valid","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1839,"value":" nop = () => null;","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2825,"value":"md`Make a Lisp list iterable by substituting \\`[]\\` for \\`null\\` AKA \\`()\\``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2828,"value":"iter = l => l || []","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2997,"value":"iterator = l => iter(l)[Symbol.iterator]()","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2280,"value":"md`Evaluates a list of forms and returns the values (in a Promise) as a Javascript list.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2044,"value":"evalList = (world, list) => world.evalList(list)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":890,"value":"lprint = {\n const lprint = v =>\n v === null\n ? 'NIL' //\n : typeof v === 'string'\n ? `\"${v.replace(/[\"\\\\]/g, c => `\\\\${c}`)}\"` //\n : typeof v === 'function'\n ? `#'${v.name || (v.lambda && lprint(v.lambda)) || 'anon'}` //\n : String(v);\n return lprint;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2272,"value":"md`### LISP Functions\nThese are called from World.apply(), often via a wrapper that discards the 1st argument (World)\nif it is not needed. This makes it easier to use these routines in Javascript. Most are synchronous,\nbut beware of exceptions (like I/O).\n\nWhen World assigns these to a symbol as a function, they will be given the symbol's name as the function\nname. This can be avoided by wrapping them—the wrapper gets the name.\n\nAfter the World argument, they receive the same arguments as the Lisp function does.\n\nFor the behavior, see the [Pitmanual (Maclisp documentation by Kent Pitman)](http://www.maclisp.info/pitmanual/index.html).`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3101,"value":"listp = l => (l === null ? LSymbol.T : l instanceof LCons ? LSymbol.T : null)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3226,"value":"atom = a => !(a instanceof LCons)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3579,"value":"md`[Pitmanual: Lists](http://www.maclisp.info/pitmanual/list.html)`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":879,"value":"cons = (car, cdr) => new LCons(car, cdr)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3907,"value":"ncons = v => new LCons(v, null)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":882,"value":"list = (...args) => args.reduceRight((acc, v) => cons(v, acc), null)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":933,"value":"md`Maclisp \\`list*\\`.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":927,"value":"listS = (...args) => {\n const last = args.pop();\n return args.reduceRight((acc, v) => cons(v, acc), last);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":902,"value":"cdr = LCons.cdr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":906,"value":"car = LCons.car","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2875,"value":"caar = LCons.caar","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2880,"value":"cdar = LCons.cdar","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":909,"value":"cadr = LCons.cadr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":912,"value":"cddr = LCons.cddr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2886,"value":"caaar = LCons.caaar\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2890,"value":"caadr = LCons.caadr\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2893,"value":"cadar = LCons.cadar","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2895,"value":"caddr = LCons.caddr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2897,"value":"cdaar = LCons.cdaar","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2899,"value":"cdadr = LCons.cdadr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2901,"value":"cddar = LCons.cddar","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2903,"value":"cdddr = LCons.cdddr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2905,"value":"caaaar = LCons.caaaar","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2907,"value":"caaadr = LCons.caaadr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2909,"value":"caadar = LCons.caadar","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2911,"value":"caaddr = LCons.caaddr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2913,"value":"cadaar = LCons.cadaar","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2915,"value":"cadadr = LCons.cadadr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2917,"value":"caddar = LCons.caddar","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2919,"value":"cadddr = LCons.cadddr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2921,"value":"cdaaar = LCons.cdaaar","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2923,"value":"cdaadr = LCons.cdaadr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2925,"value":"cdadar = LCons.cdadar","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2927,"value":"cdaddr = LCons.cdaddr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2929,"value":"cddaar = LCons.cddaar","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2931,"value":"cddadr = LCons.cddadr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2885,"value":"cdddar = LCons.cdddar","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2934,"value":"cddddr = LCons.cddddr","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":943,"value":"rplaca = (l, v) => {\n if (l instanceof LCons) {\n return (l.car = v);\n }\n throw new Error(`${lprint(l)} is not a CONS`);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":946,"value":"rplacd = (l, v) => {\n if (l instanceof LCons) {\n return (l.cdr = v);\n }\n throw new Error(`${lprint(l)} is not a CONS`);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2860,"value":"subst = {\n const subst = (n, o, l) => {\n if (l === o) {\n return n;\n } else if (l instanceof LCons) {\n const ocar = car(l);\n const ocdr = cdr(l);\n const ncar = subst(n, o, ocar);\n const ncdr = subst(n, o, ocdr);\n if (ncar === ocar && ncdr === ncar) {\n return l;\n }\n return cons(ncar, ncdr);\n } else {\n return l;\n }\n };\n return subst;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2983,"value":"append = (...args) => {\n let head = null;\n let tail = null;\n const last = args.pop() || null;\n for (const l of args) {\n for (const i of iter(l)) {\n const n = cons(i, null);\n if (tail) {\n tail = tail.cdr = n;\n } else {\n head = tail = n;\n }\n }\n }\n if (tail) {\n tail.cdr = last;\n } else {\n head = last;\n }\n return head;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3074,"value":"do_map = (world, fn) => async lists => {\n const list_iterator = l =>\n listp(l) ? iterator(l) : thrw(`Not a list: ${lprint(l)}`);\n const iterators = lists.map(list_iterator);\n let done = false;\n while (!done) {\n done = true;\n const values = [];\n for (const i of iterators) {\n const v = i.next();\n if (v.done) {\n values.push(null);\n } else {\n values.push(v.value);\n done = false;\n }\n }\n if (!done) await fn(values);\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2299,"value":"mapc = async (world, fn, ...lists) => {\n const do_mapc = async values => {\n await world.apply(fn, ...values);\n };\n await do_map(world, do_mapc)(lists);\n return lists[1] || null;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3069,"value":"mapcar = async (world, fn, ...lists) => {\n let result = null;\n let tail = null;\n const do_mapcar = async values => {\n const r = await world.apply(fn, ...values);\n if (tail) {\n tail = tail.cdr = cons(r, null);\n } else {\n result = tail = cons(r, null);\n }\n };\n await do_map(world, do_mapcar)(lists);\n return result;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3012,"value":"memq = (q, l) => {\n let t = l;\n while (t) {\n if (q === car(t)) {\n return t;\n }\n t = cdr(t);\n }\n return t;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3014,"value":"member = (q, l) => {\n let t = l;\n while (t) {\n if (equal(q, car(t))) {\n return t;\n }\n t = cdr(t);\n }\n return t;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3019,"value":"assq = (q, l) => {\n for (const e of iter(l)) {\n if (q === car(e)) {\n return cdr(e);\n }\n }\n return null;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3022,"value":"assoc = (q, l) => {\n for (const e of iter(l)) {\n if (equal(q, car(e))) {\n return cdr(e);\n }\n }\n return null;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3004,"value":"delq = (q, l) => {\n let head = l;\n let tail = l;\n let prev = null;\n while (tail) {\n const v = car(tail);\n if (q === v) {\n if (head === tail) {\n // Skip at head.\n head = tail = cdr(tail);\n } else {\n // Splice out current\n tail = prev.cdr = tail.cdr;\n }\n } else {\n // Move to next\n prev = tail;\n tail = tail.cdr;\n }\n }\n return head;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3007,"value":"e_delete = (q, l) => {\n let head = l;\n let tail = l;\n let prev = null;\n while (tail) {\n const v = car(tail);\n if (equal(q, v)) {\n if (head === tail) {\n // Skip at head.\n head = tail = cdr(tail);\n } else {\n // Splice out current\n tail = prev.cdr = tail.cdr;\n }\n } else {\n // Move to next\n prev = tail;\n tail = tail.cdr;\n }\n }\n return head;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3584,"value":"md`[Pitmanual: Symbol manipulation](http://www.maclisp.info/pitmanual/symbol.html)`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2136,"value":"ascii = (world, c) => world.intern(String.fromCharCode(c))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1564,"value":"plist = sym => {\n if (sym instanceof LSymbol) {\n return sym.plist;\n } else if (sym instanceof LCons) {\n return sym.cdr;\n } else if (sym === null) {\n return null;\n }\n throw new Error(`Invalid argument to PLIST: ${lprint(sym)}`);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":920,"value":"putprop = (plist, value, key) => {\n if (plist && plist.putprop) {\n valid(v => `Invalid property name: ${lprint(v)}`)(key);\n valid(v => `Invalid property value: ${lprint(v)}`)(value);\n return plist.putprop(value, key);\n }\n throw new Error(`${lprint(plist)} is not a symbol or list.`);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":901,"value":"getprop = (plist, key) => {\n if (plist && plist.getprop) {\n return plist.getprop(key);\n }\n throw new Error(`${lprint(plist)} is not a symbol or list.`);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3727,"value":"remprop = (plist, key) => {\n if (plist && plist.remprop) {\n return plist.remprop(key);\n }\n throw new Error(`${lprint(plist)} is not a symbol or list.`);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3764,"value":"gensym = {\n let prefix = 'G';\n let num = 0;\n return arg => {\n if (typeof arg === 'string') {\n prefix = arg;\n } else if (typeof arg === 'number') {\n num = arg;\n }\n const numpart = '000' + num++;\n return new LSymbol(prefix + numpart.substr(numpart.length - 4));\n };\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2027,"value":"symeval = s =>\n defined(() => `The symbol ${s.name} is not defined.`)(sym(s).value)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3041,"value":"symbolp = s => s instanceof LSymbol","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2193,"value":"boundp = v => (sym(v).value === undefined ? null : LSymbol.T)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2196,"value":"fboundp = v =>\n sym(v).getprop(LSymbol.EXPR) ||\n v.getprop(LSymbol.FEXPR) ||\n v.getprop(LSymbol.MACRO)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3426,"value":"funcall = (world, fn, ...args) => world.apply(fn, ...args);","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2581,"value":"macroexpand_1 = async (world, form) => {\n if (!listp(form)) return form;\n const mac = car(form);\n if (mac instanceof LSymbol && mac.macro) {\n const exp = await world.apply(mac.macro, form);\n return exp;\n }\n return form;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2587,"value":"macroexpand = async (world, form) => {\n let oldForm = form;\n let newForm = null;\n while (oldForm !== (newForm = await macroexpand_1(world, oldForm))) {\n oldForm = newForm;\n }\n return newForm;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3900,"value":"copysymbol = (s, flag) =>\n new LSymbol(sym(s).name, undefined, flag ? append(s.plist, null) : null)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3587,"value":"md`[Pitmanual: Character manipulation](http://www.maclisp.info/pitmanual/charac.html)\n\nAmazingly, strings are not a native feature to Maclisp. There are a couple of approaches\nto bring string functionality, but the only native support is using symbols. Rather than\nrely on such (including a compatibility layer to bring Common Lisp functionatliy), I just\nbuild on Javascript's strings. Here, Lisp strings are Javascript strings.\n\nIf read with double-quotes, you get strings, not symbols, and you probably wanted string\nfunctionality but not symbol functionality (like in every modern Lisp).`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2489,"value":"equal = {\n const equal = (a, b) => {\n if (a === b) return true;\n if (a instanceof LCons && b instanceof LCons) {\n return equal(car(a), car(b)) && equal(cdr(a), cdr(b));\n }\n return null;\n };\n return equal;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2856,"value":"eq = (a, b) => a === b","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2275,"value":"md`[Pitmanual: Arrays](http://www.maclisp.info/pitmanual/array.html)\n\nArrays in Maclisp can be called as functions, so I wrap Javascript arrays\nin a function, allowing them to be called..\n\n(*ARRAY _info_ _type_ _initial_)`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2147,"value":"$3b","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3441,"value":"arraycall = (world, array, type, ...idx) => world.apply(array, ...idx)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3428,"value":"arrayStore = (world, value, array, ...dims) => {\n return array.store(value, ...dims);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3594,"value":"md`Support for crazy \\`LEXPR\\` functions, that don't actually receive their arguments, but just provide a count and allow the function to query for its arguments. I would have omitted this, but...some of the dependencies depend on this. This was already obsolete in 1975 when I wrote my code...\n\nI described \\`(backtrace\\)\\` earlier when discussing the evaluator.\n\nFor more information, see [Pitmanual: Definitional Forms](http://www.maclisp.info/pitmanual/def.html).\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3132,"value":"arg = n => {\n // More bizarre Maclisp LEXPR cruft.\n const frame = symeval(LSymbol['--LEXPR-FRAME--']);\n const args = [...iter(frame.args)];\n if (n) {\n return args[n - 1];\n }\n return args.length;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3130,"value":"listify = (n) => {\n // This is a bizarre Maclisp thing. We could search up the stack for the frame, but it'll be faster\n // to keep it in a bound global.\n const frame = symeval(LSymbol['--LEXPR-FRAME--']);\n const args = [...iter(frame.args)];\n const do_listify = (n, m) => {\n let r = null;\n for (let i = n; i < m; i--) {\n r = cons(args[i - 1], r);\n }\n return r;\n };\n if (n < 0) {\n return do_listify(args.length, args.length + n + 1);\n } else {\n return do_listify(n, 1);\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3142,"value":"/// Get a LISP backtrace\nbacktrace = {\n const backtrace = world => list(...iter(world.stack));\n return backtrace;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3931,"value":"error = e => thrw(e)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3150,"value":"ev('(backtrace)')","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1797,"value":"md`### FEXPRs (special forms, control structures)\nMaclisp defines special forms (forms which do not follow the normal pattern of evaluating all the\narguments, then apply the function to the arguments.\n\nFEXPRs generally need to receive the World to handle evaluation. They typically are async as well,\nbecause the evaluated forms may be async.\n\nAfter the World argument, FEXPRs receive a single argument—the form arguments, not including the name of the FEXPR. (to be fixed).\n\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1848,"value":"f_quote = (world, form) => car(form)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3598,"value":"md`\\`(function fn)\\` is like \\`quote\\` for functions. Unlike \\`quote\\` which always returns\nits literal argument, \\`(function fn)\\` may return any functional equivalent to _fn_, the\nonly requirement being it can be called as a function with \\`funcall\\` or \\`apply\\`.\n\nWe always return a Javascript function object. This may be a function implemented in\nJavascript, or a trampoline function that prepares bindings and invokes the interpreter.\n\nThis buys some efficiency, some simplicity, and allows Lisp functions to be easily called from\nJavascript. They only need the first argument to be supplied as the correct World; that can be\nbound with a wrapper giving a function specific to the given world but not requiring it to be\npassed.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1844,"value":"f_function = (world, form) =>\n car(form) instanceof LSymbol\n ? car(form).expr ||\n thrw(`${lprint(car(form))} is not defined as a function.`)\n : listp(car(form))\n ? makeFunction(world, null, cadar(form), cddar(form))\n : typeof car(form) === 'function'\n ? car(form)\n : thrw(`${lprint(car(form))} is not a valid function.`)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1853,"value":"f_if = async (world, form) =>\n (await world.eval(car(form))) !== null\n ? world.eval(cadr(form))\n : world.prognBody(cddr(form))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1801,"value":"f_cond = async (world, form) => {\n for (const clause of iter(form)) {\n if (await world.eval(car(clause))) {\n return world.prognBody(cdr(clause));\n }\n }\n return null;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1872,"value":"f_caseq = async (world, form) => {\n const key = await world.eval(car(form));\n for (const { car: keys, cdr: exprs } of iter(cdr(form))) {\n if (key === keys) {\n return world.prognBody(exprs);\n } else if (keys instanceof LCons) {\n if ([...keys].find(k => k === key)) {\n return world.prognBody(exprs);\n }\n }\n }\n return null;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2552,"value":"f_progn = (world, form) => world.prognBody(form)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2472,"value":"md`\\`makeFunction\\` compiles a lambda into a Javascript trampoline that handles the bindings\nincluding \\`&OPTIONAL\\` and \\`&REST\\`. It then dispatches to the interpreter for the body.\n\nIt does not yet handle \\`&WHOLE\\` for macros.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2361,"value":"$3c","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2528,"value":"makeMacro = (world, name, arglist, body) => {\n const fn = makeFunction(\n world,\n `${String(name)}-fn`,\n list(null, ...iter(arglist)),\n body\n );\n const nfn = (world, form) => fn(world, form, ...iter(cdr(form)));\n\n Reflect.defineProperty(nfn, 'lambda', {\n value: fn.lambda\n });\n Reflect.defineProperty(nfn, 'name', {\n value: fn.name\n });\n return nfn;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2624,"value":"setLocation = name => (\n LSymbol.LOCATION.value &&\n setsym(name).putprop(LSymbol.LOCATION.value, LSymbol.LOCATION),\n name\n)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2205,"value":"$3d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1357,"value":"f_defmacro = (world, form) => {\n const name = car(form);\n form = cdr(form);\n name.macro = makeMacro(world, name, car(form), cdr(form));\n setLocation(name);\n return name;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2850,"value":"f_defvar = async (world, form) =>\n (setsym(car(form)).value = await world.eval(cadr(form)))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1857,"value":"f_defconst = async (world, form) =>\n (setsym(car(form)).value = await world.eval(cadr(form)))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2868,"value":"f_defprop = (world, form) => putprop(car(form), cadr(form), caddr(form))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1891,"value":"f_eval_when = (world, form) => {\n const when = car(form);\n console.log('EVAL-WHEN', ...[...iter(when)].map(s => sym(s).name));\n if (memq(LSymbol.EVAL, when) || memq(LSymbol.LOAD, when)) {\n return world.prognBody(cdr(form), 'EVAL-WHEN');\n }\n return null;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3058,"value":"f_progv = {\n const f_progv = async (world, form) => {\n const bvl = await world.eval(car(form));\n const vals = await world.eval(cadr(form));\n const body = cddr(form);\n const frame = new ApplyFrame(f_progv, vals);\n const do_progv = async () => {\n frame.applyBindings([...iter(bvl)], [...iter(vals)]);\n return await world.prognBody(body);\n };\n return world.withFrame(frame, do_progv);\n };\n return f_progv;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1945,"value":"f_let = async (world, form) => {\n const bindings1 = car(form);\n const bindings = symbolp(car(bindings1)) ? [bindings1] : iter(bindings1);\n const binding_exprs = [...bindings];\n const vals = await evalList(world, binding_exprs.map(cadr));\n const body = cdr(form);\n const frame = new ApplyFrame(\n listS(LSymbol.LAMBDA, list(...binding_exprs.map(car)), body),\n vals\n );\n const extract_vals = b => v =>\n b instanceof LCons\n ? (extract_vals(car(b))(car(v)), extract_vals(cdr(b))(cdr(v)))\n : b === null\n ? null\n : b instanceof LSymbol\n ? frame.bind(b, v)\n : thrw(`Illegal binding variable ${lprint(b)}`);\n const do_let = () => {\n console.log('LET-BIND', binding_exprs);\n binding_exprs.forEach((b, i) => extract_vals(car(b))(vals[i]));\n return world.prognBody(body);\n };\n return world.withFrame(frame, do_let);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2123,"value":"$3e","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1862,"value":"f_setq = async (world, form) => {\n let t = form;\n let val = null;\n while (t) {\n val = await world.eval(cadr(t));\n setsym(car(t)).value = val;\n t = cddr(t);\n }\n return val;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2306,"value":"f_setq_if_unbound = async (world, form) => {\n let t = form;\n let val = null;\n while (t) {\n if (setsym(car(t)).value === undefined) {\n val = await world.eval(cadr(t));\n setsym(car(t)).value = val;\n }\n t = cddr(t);\n }\n return val;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2390,"value":"$3f","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2480,"value":"f_or = async (world, form) => {\n for (const e of iter(form)) {\n const val = await world.eval(e);\n if (val) {\n return val;\n }\n }\n return null;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2485,"value":"f_and = async (world, form) => {\n let val = LSymbol.T;\n for (const e of iter(form)) {\n val = await world.eval(e);\n if (!val) {\n return null;\n }\n }\n return val;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3431,"value":"f_array = (world, form) => {\n return Sarray(...iter(form));\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3434,"value":"f_store = async (world, form) => {\n const [arr, type, ...idx] = [...iter(car(form))];\n const val = cadr(form);\n return arrayStore(\n await world.eval(val),\n await world.eval(arr),\n ...(await world.evalList(idx))\n );\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2165,"value":"f_include = (world, form) => {\n const file = car(form);\n return e_load(world, file);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2323,"value":"f_herald = (world, form) => {\n console.log('HERALD', lprint(car(form)), lprint(cadr(form)));\n putprop(car(form), cadr(form), LSymbol.VERSION);\n return null;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3605,"value":"md`System status and control [Pitmanual: STATUS and SSTATUS and their options](http://www.maclisp.info/pitmanual/system.html#24.5)`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1817,"value":"f_status = (world, form) => {\n switch (car(form)) {\n case LSymbol.FEATURE:\n return cdr(form)\n ? world.features.find(f => cadr(form) === f) || null\n : list(...world.features);\n case LSymbol.NOFEATURE:\n return world.features.find(f => cadr(form)) ? null : LSymbol.T;\n case LSymbol.MACRO:\n switch (cadr(form)) {\n case \"`\".charCodeAt(0):\n return list(world.intern('BACKQ'));\n }\n case LSymbol.STATUS:\n return null;\n }\n throw new Error(`Unsuported STATUS operation ${lprint(car(form))}`);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1813,"value":"f_sstatus = (world, form) => {\n if (car(form) === LSymbol.FEATURE) {\n const feat = cadr(form);\n // Blacklist features for PDP10\n if (!/PDP10/i.test(sym(feat).name)) {\n if (!world.features.find(f => f === feat)) {\n world.features.push(feat);\n }\n }\n }\n return null;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1637,"value":"md`### File operations`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1961,"value":"toPath = f => {\n if (typeof f === 'string') {\n return f;\n }\n const nn = nonnil(v => `Incomplete path spec: ${lprint(v)}`);\n const dskdir = nn(car(f));\n const dir = cdr(dskdir)\n ? sym(nn(cadr(dskdir))).name.substr(0, 6)\n : sym(nn(car(dskdir))).name.substr(0, 6);\n const name = sym(nn(cadr(f))).name.substr(0, 6);\n const ext = cddr(f) && nn(car(cddr(f))).name.substr(0, 6);\n if (ext) {\n return `${dir};${name} ${ext}`;\n }\n return `${dir};${name}`;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1982,"value":"toPath(await L`((teach) lesson progn)`)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2284,"value":"md`Utility to read from a string and return it as a value`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1964,"value":"rd = s => WORLD.read(s)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2287,"value":"md`Backtick template to read a Lisp expression. As it returns a \\`Promise\\`, use \\`await\\` to get the actual value to pass to a function.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1971,"value":"L = (pieces, ...vals) => rd(String.raw(pieces, ...vals))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3609,"value":"md`IO functions. Currently, we only support reading and loading from files. The virtual filesystem\nan [ObservableHQ notebook](https://observablehq.com/@bobkerns/locate-its-files) that interfaces to the [Github repository that contains the files for the ITS filesystem](https://github.com/PDP-10/its/tree/master/src). It supports aliases for files that have moved, and attachments to add or replace files.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1641,"value":"open = async (path, mode) => {\n const fpath = toPath(path);\n console.log('OPENING', fpath);\n const response = await accessFile(fpath, {\n mode: 'cors',\n headers: { Accept: 'text/plain' }\n });\n if (!response) {\n throw new Error(`File Not Found: ${fpath}`);\n }\n const stream = new LInputStream(await response.text(), fpath);\n return stream;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1644,"value":"$40","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2002,"value":"load = path => e_load(WORLD, path)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2118,"value":"close = stream => (stream.close(), null)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3614,"value":"md`Log to the browser's console.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3473,"value":"log = (...args) => (console.log('LOG', ...args), args[0] || null)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3623,"value":"md`Observable evaluations, Using \\`Evaluation.ev(string)\\` to run Lisp code allows us to chain dependencies\nbetween notebook cells, so that code is automatically rerun when earlier steps in the dependency chain are modified.\n\nYou start by calling the global ev(), and after that, ev() on each previous return result. Order of cells\ndoes not matter. You may place as much or little code in each cell as you wish.\n${await evInto(\n 'X0',\n 'X1',\n `(defun fact (n)\n (if (= n 1)\n n\n (* n (fact (1- n)))))\n`\n)}\n \n${await evInto('X1', 'X2', `(fact 5)`)}\n\nYou can expand the error below, and then expand the backtrace, to see result.\n\n${await evInto('X2', 'X3', `(progn (erroring form))`)}\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1413,"value":"$41","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3654,"value":"evInto = {\n const deps = [];\n const evInto = async (oldId, id, code) => {\n const div = html`

`;\n const txt = md`\n\\`\\`\\`lisp\n\n${id} = ${oldId}.ev(\\`\n${code}\n\\`)\n\\`\\`\\`\n`;\n const inspector = new Inspector(div);\n const oEv = (deps[oldId] = deps[oldId] = new Evaluation({ world: WORLD }));\n inspector.pending();\n try {\n inspector.fulfilled((deps[id] = await oEv.ev(code)));\n } catch (e) {\n inspector.rejected(e);\n }\n return md`${div}\n${txt}\n`;\n };\n return evInto;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1316,"value":"ev = (str, world = WORLD) =>\n new Evaluation({ world, value: null, input: null, form: null }).ev(str)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3711,"value":"$42","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1919,"value":"md`Loading from: [teach;start](${locateFile(\n \"teach;start\"\n)}), after loading any local patches.\nThe source for LIBLSP;STRUCT FASL is missing. I'm pondering a native implementation. The original\nuses hunks (I checked the binary), which seem a waste to implement, and a native implementation\ncan make interfacing to/from Javascript work more smoothly.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1684,"value":"TEACH = PATCHES.ev(`\n(progn\n \n\n (load \"attach;boot\")\n ;; Resolve MACAID/DEFMAX circular dependency\n ;; This will be ovdrwritten by the real definition in MACAID\n (defmacro defsimplemac (name varlist &body body)\n \\`(defmacro name ,varlist, ,@body))\n\n (load \"lisp;macaid\")\n ;; SETF has way too many irrelevant dependencies, many of them circular.\n ;; I've decided implementing my own is far simpler.\n ;;(load \"nilcom;setf\")\n (load \"teach;start\")\n)`)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3781,"value":"$43","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":767,"value":"$44","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":170,"value":"md`## Test Summary`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":497,"value":"TESTS.summary()","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1363,"value":"{\n try {\n return ev('((lambda (a b) (+ a b)) 6 7)');\n } catch (e) {\n return e.stack;\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":175,"value":"md`## Library Imports`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1896,"value":"import {\n accessFile,\n locateFile,\n locateFiles,\n listFiles,\n findFile,\n findFiles\n} from '@bobkerns/locate-its-files'","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":48,"value":"expect = ['expect@25.5.0', 'jest-extended@0.11.5', 'jest-chain@1.1.5'].map(l =>\n require(l)\n)[0] // Enforce load order.","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":305,"value":"import { idGen } from '@bobkerns/utilities'","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":668,"value":"import { def } from '@bobkerns/def'","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":310,"value":"d3 = require('d3@5')","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":654,"value":"def`test_styles VALUE`(test_styles.cloneNode(true))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":642,"value":"import { TESTS, test_styles } from '@bobkerns/literate-tests@1067'","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3640,"value":"Inspector = (await require('@observablehq/inspector')).Inspector","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3646,"value":"typeof Inspector.Inspector","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W45","stdlib":"1"}} 31:"$30:body"