impls/ts/step8_macros.ts

   1 import { readline } from "./node_readline";
   2
   3 import { Node, MalType, MalString, MalNil, MalList, MalVector, MalHashMap, MalSymbol, MalFunction, isAST, isSeq } from "./types";
   4 import { Env } from "./env";
   5 import * as core from "./core";
   6 import { readStr } from "./reader";
   7 import { prStr } from "./printer";
   8
   9 // READ
  10 function read(str: string): MalType {
  11     return readStr(str);
  12 }
  13
  14 function starts_with(lst: MalType[], sym: string): boolean {
  15     if (lst.length == 2) {
  16         let a0 = lst[0]
  17         switch (a0.type) {
  18             case Node.Symbol:
  19                 return a0.v === sym;
  20         }
  21     }
  22     return false;
  23 }
  24
  25 function qq_loop(elt: MalType, acc: MalList): MalList {
  26     if (elt.type == Node.List && starts_with(elt.list, "splice-unquote")) {
  27         return new MalList([MalSymbol.get("concat"), elt.list[1], acc]);
  28     } else {
  29         return new MalList([MalSymbol.get("cons"), quasiquote(elt), acc]);
  30     }
  31 }
  32
  33 function qq_foldr(xs : MalType[]): MalList {
  34     let acc = new MalList([])
  35     for (let i=xs.length-1; 0<=i; i-=1) {
  36          acc = qq_loop(xs[i], acc)
  37     }
  38     return acc;
  39 }
  40
  41 function quasiquote(ast: MalType): MalType {
  42     switch (ast.type) {
  43         case Node.Symbol:
  44             return new MalList([MalSymbol.get("quote"), ast]);
  45         case Node.HashMap:
  46             return new MalList([MalSymbol.get("quote"), ast]);
  47         case Node.List:
  48             if (starts_with(ast.list, "unquote")) {
  49                 return ast.list[1];
  50             } else {
  51                 return qq_foldr(ast.list);
  52             }
  53         case Node.Vector:
  54             return new MalList([MalSymbol.get("vec"), qq_foldr(ast.list)]);
  55         default:
  56             return ast;
  57     }
  58 }
  59
  60 function isMacro(ast: MalType, env: Env): boolean {
  61     if (!isSeq(ast)) {
  62         return false;
  63     }
  64     const s = ast.list[0];
  65     if (s.type !== Node.Symbol) {
  66         return false;
  67     }
  68     const foundEnv = env.find(s);
  69     if (!foundEnv) {
  70         return false;
  71     }
  72
  73     const f = foundEnv.get(s);
  74     if (f.type !== Node.Function) {
  75         return false;
  76     }
  77
  78     return f.isMacro;
  79 }
  80
  81 function macroexpand(ast: MalType, env: Env): MalType {
  82     while (isMacro(ast, env)) {
  83         if (!isSeq(ast)) {
  84             throw new Error(`unexpected token type: ${ast.type}, expected: list or vector`);
  85         }
  86         const s = ast.list[0];
  87         if (s.type !== Node.Symbol) {
  88             throw new Error(`unexpected token type: ${s.type}, expected: symbol`);
  89         }
  90         const f = env.get(s);
  91         if (f.type !== Node.Function) {
  92             throw new Error(`unexpected token type: ${f.type}, expected: function`);
  93         }
  94         ast = f.func(...ast.list.slice(1));
  95     }
  96
  97     return ast;
  98 }
  99
 100 function evalAST(ast: MalType, env: Env): MalType {
 101     switch (ast.type) {
 102         case Node.Symbol:
 103             const f = env.get(ast);
 104             if (!f) {
 105                 throw new Error(`unknown symbol: ${ast.v}`);
 106             }
 107             return f;
 108         case Node.List:
 109             return new MalList(ast.list.map(ast => evalMal(ast, env)));
 110         case Node.Vector:
 111             return new MalVector(ast.list.map(ast => evalMal(ast, env)));
 112         case Node.HashMap:
 113             const list: MalType[] = [];
 114             for (const [key, value] of ast.entries()) {
 115                 list.push(key);
 116                 list.push(evalMal(value, env));
 117             }
 118             return new MalHashMap(list);
 119         default:
 120             return ast;
 121     }
 122 }
 123
 124 // EVAL
 125 function evalMal(ast: MalType, env: Env): MalType {
 126     loop: while (true) {
 127         if (ast.type !== Node.List) {
 128             return evalAST(ast, env);
 129         }
 130         if (ast.list.length === 0) {
 131             return ast;
 132         }
 133
 134         ast = macroexpand(ast, env);
 135         if (!isSeq(ast)) {
 136             return evalAST(ast, env);
 137         }
 138
 139         if (ast.list.length === 0) {
 140             return ast;
 141         }
 142         const first = ast.list[0];
 143         switch (first.type) {
 144             case Node.Symbol:
 145                 switch (first.v) {
 146                     case "def!": {
 147                         const [, key, value] = ast.list;
 148                         if (key.type !== Node.Symbol) {
 149                             throw new Error(`unexpected token type: ${key.type}, expected: symbol`);
 150                         }
 151                         if (!value) {
 152                             throw new Error(`unexpected syntax`);
 153                         }
 154                         return env.set(key, evalMal(value, env));
 155                     }
 156                     case "let*": {
 157                         env = new Env(env);
 158                         const pairs = ast.list[1];
 159                         if (!isSeq(pairs)) {
 160                             throw new Error(`unexpected token type: ${pairs.type}, expected: list or vector`);
 161                         }
 162                         for (let i = 0; i < pairs.list.length; i += 2) {
 163                             const key = pairs.list[i];
 164                             const value = pairs.list[i + 1];
 165                             if (key.type !== Node.Symbol) {
 166                                 throw new Error(`unexpected token type: ${key.type}, expected: symbol`);
 167                             }
 168                             if (!key || !value) {
 169                                 throw new Error(`unexpected syntax`);
 170                             }
 171
 172                             env.set(key, evalMal(value, env));
 173                         }
 174                         ast = ast.list[2];
 175                         continue loop;
 176                     }
 177                     case "quote": {
 178                         return ast.list[1];
 179                     }
 180                     case "quasiquoteexpand": {
 181                         return quasiquote(ast.list[1]);
 182                     }
 183                     case "quasiquote": {
 184                         ast = quasiquote(ast.list[1]);
 185                         continue loop;
 186                     }
 187                     case "defmacro!": {
 188                         const [, key, value] = ast.list;
 189                         if (key.type !== Node.Symbol) {
 190                             throw new Error(`unexpected token type: ${key.type}, expected: symbol`);
 191                         }
 192                         if (!value) {
 193                             throw new Error(`unexpected syntax`);
 194                         }
 195                         const f = evalMal(value, env);
 196                         if (f.type !== Node.Function) {
 197                             throw new Error(`unexpected token type: ${f.type}, expected: function`);
 198                         }
 199                         return env.set(key, f.toMacro());
 200                     }
 201                     case "macroexpand": {
 202                         return macroexpand(ast.list[1], env);
 203                     }
 204                     case "do": {
 205                         const list = ast.list.slice(1, -1);
 206                         evalAST(new MalList(list), env);
 207                         ast = ast.list[ast.list.length - 1];
 208                         continue loop;
 209                     }
 210                     case "if": {
 211                         const [, cond, thenExpr, elseExrp] = ast.list;
 212                         const ret = evalMal(cond, env);
 213                         let b = true;
 214                         if (ret.type === Node.Boolean && !ret.v) {
 215                             b = false;
 216                         } else if (ret.type === Node.Nil) {
 217                             b = false;
 218                         }
 219                         if (b) {
 220                             ast = thenExpr;
 221                         } else if (elseExrp) {
 222                             ast = elseExrp;
 223                         } else {
 224                             ast = MalNil.instance;
 225                         }
 226                         continue loop;
 227                     }
 228                     case "fn*": {
 229                         const [, params, bodyAst] = ast.list;
 230                         if (!isSeq(params)) {
 231                             throw new Error(`unexpected return type: ${params.type}, expected: list or vector`);
 232                         }
 233                         const symbols = params.list.map(param => {
 234                             if (param.type !== Node.Symbol) {
 235                                 throw new Error(`unexpected return type: ${param.type}, expected: symbol`);
 236                             }
 237                             return param;
 238                         });
 239                         return MalFunction.fromLisp(evalMal, env, symbols, bodyAst);
 240                     }
 241                 }
 242         }
 243         const result = evalAST(ast, env);
 244         if (!isSeq(result)) {
 245             throw new Error(`unexpected return type: ${result.type}, expected: list or vector`);
 246         }
 247         const [f, ...args] = result.list;
 248         if (f.type !== Node.Function) {
 249             throw new Error(`unexpected token: ${f.type}, expected: function`);
 250         }
 251         if (f.ast) {
 252             ast = f.ast;
 253             env = f.newEnv(args);
 254             continue loop;
 255         }
 256
 257         return f.func(...args);
 258     }
 259 }
 260
 261 // PRINT
 262 function print(exp: MalType): string {
 263     return prStr(exp);
 264 }
 265
 266 const replEnv = new Env();
 267 function rep(str: string): string {
 268     return print(evalMal(read(str), replEnv));
 269 }
 270
 271 // core.EXT: defined using Racket
 272 core.ns.forEach((value, key) => {
 273     replEnv.set(key, value);
 274 });
 275 replEnv.set(MalSymbol.get("eval"), MalFunction.fromBootstrap(ast => {
 276     if (!ast) {
 277         throw new Error(`undefined argument`);
 278     }
 279     return evalMal(ast, replEnv);
 280 }));
 281 replEnv.set(MalSymbol.get("*ARGV*"), new MalList([]));
 282
 283 // core.mal: defined using the language itself
 284 rep("(def! not (fn* (a) (if a false true)))");
 285 rep(`(def! load-file (fn* (f) (eval (read-string (str "(do " (slurp f) "\nnil)")))))`);
 286 rep(`(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw "odd number of forms to cond")) (cons 'cond (rest (rest xs)))))))`);
 287
 288 if (typeof process !== "undefined" && 2 < process.argv.length) {
 289     replEnv.set(MalSymbol.get("*ARGV*"), new MalList(process.argv.slice(3).map(s => new MalString(s))));
 290     rep(`(load-file "${process.argv[2]}")`);
 291     process.exit(0);
 292 }
 293
 294 while (true) {
 295     const line = readline("user> ");
 296     if (line == null) {
 297         break;
 298     }
 299     if (line === "") {
 300         continue;
 301     }
 302     try {
 303         console.log(rep(line));
 304     } catch (e) {
 305         if (isAST(e)) {
 306             console.error("Error:", prStr(e));
 307         } else {
 308             const err: Error = e;
 309             console.error("Error:", err.message);
 310         }
 311     }
 312 }