dart/step7_quote.dart

   1 import 'dart:io';
   2
   3 import 'core.dart';
   4 import 'env.dart';
   5 import 'printer.dart' as printer;
   6 import 'reader.dart' as reader;
   7 import 'types.dart';
   8
   9 final Env replEnv = new Env();
  10
  11 void setupEnv(List<String> argv) {
  12   // TODO(het): use replEnv#set once generalized tearoffs are implemented
  13   ns.forEach((sym, fun) => replEnv.set(sym, fun));
  14
  15   replEnv.set(new MalSymbol('eval'),
  16       new MalBuiltin((List<MalType> args) => EVAL(args.single, replEnv)));
  17
  18   replEnv.set(new MalSymbol('*ARGV*'),
  19       new MalList(argv.map((s) => new MalString(s)).toList()));
  20
  21   rep('(def! not (fn* (a) (if a false true)))');
  22   rep("(def! load-file "
  23       "(fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
  24 }
  25
  26 MalType quasiquote(MalType ast) {
  27   bool isPair(MalType ast) {
  28     return ast is MalIterable && ast.isNotEmpty;
  29   }
  30
  31   if (!isPair(ast)) {
  32     return new MalList([new MalSymbol("quote"), ast]);
  33   } else {
  34     var list = ast as MalIterable;
  35     if (list.first == new MalSymbol("unquote")) {
  36       return list[1];
  37     } else if (isPair(list.first) &&
  38         (list.first as MalIterable).first == new MalSymbol("splice-unquote")) {
  39       return new MalList([
  40         new MalSymbol("concat"),
  41         (list.first as MalIterable)[1],
  42         quasiquote(new MalList(list.sublist(1)))
  43       ]);
  44     } else {
  45       return new MalList([
  46         new MalSymbol("cons"),
  47         quasiquote(list[0]),
  48         quasiquote(new MalList(list.sublist(1)))
  49       ]);
  50     }
  51   }
  52 }
  53
  54 MalType READ(String x) => reader.read_str(x);
  55
  56 MalType eval_ast(MalType ast, Env env) {
  57   if (ast is MalSymbol) {
  58     var result = env.get(ast);
  59     if (result == null) {
  60       throw new NotFoundException(ast.value);
  61     }
  62     return result;
  63   } else if (ast is MalList) {
  64     return new MalList(ast.elements.map((x) => EVAL(x, env)).toList());
  65   } else if (ast is MalVector) {
  66     return new MalVector(ast.elements.map((x) => EVAL(x, env)).toList());
  67   } else if (ast is MalHashMap) {
  68     var newMap = new Map<MalType, MalType>.from(ast.value);
  69     for (var key in newMap.keys) {
  70       newMap[key] = EVAL(newMap[key], env);
  71     }
  72     return new MalHashMap(newMap);
  73   } else {
  74     return ast;
  75   }
  76 }
  77
  78 MalType EVAL(MalType ast, Env env) {
  79   while (true) {
  80     if (ast is! MalList) {
  81       return eval_ast(ast, env);
  82     } else {
  83       if ((ast as MalList).elements.isEmpty) {
  84         return ast;
  85       } else {
  86         var list = ast as MalList;
  87         if (list.elements.first is MalSymbol) {
  88           var symbol = list.elements.first as MalSymbol;
  89           var args = list.elements.sublist(1);
  90           if (symbol.value == "def!") {
  91             MalSymbol key = args.first;
  92             MalType value = EVAL(args[1], env);
  93             env.set(key, value);
  94             return value;
  95           } else if (symbol.value == "let*") {
  96             // TODO(het): If elements.length is not even, give helpful error
  97             Iterable<List<MalType>> pairs(List<MalType> elements) sync* {
  98               for (var i = 0; i < elements.length; i += 2) {
  99                 yield [elements[i], elements[i + 1]];
 100               }
 101             }
 102
 103             var newEnv = new Env(env);
 104             MalIterable bindings = args.first;
 105             for (var pair in pairs(bindings.elements)) {
 106               MalSymbol key = pair[0];
 107               MalType value = EVAL(pair[1], newEnv);
 108               newEnv.set(key, value);
 109             }
 110             ast = args[1];
 111             env = newEnv;
 112             continue;
 113           } else if (symbol.value == "do") {
 114             eval_ast(new MalList(args.sublist(0, args.length - 1)), env);
 115             ast = args.last;
 116             continue;
 117           } else if (symbol.value == "if") {
 118             var condition = EVAL(args[0], env);
 119             if (condition is MalNil ||
 120                 condition is MalBool && condition.value == false) {
 121               // False side of branch
 122               if (args.length < 3) {
 123                 return new MalNil();
 124               }
 125               ast = args[2];
 126               continue;
 127             } else {
 128               // True side of branch
 129               ast = args[1];
 130               continue;
 131             }
 132           } else if (symbol.value == "fn*") {
 133             var params = (args[0] as MalIterable)
 134                 .elements
 135                 .map((e) => e as MalSymbol)
 136                 .toList();
 137             return new MalClosure(
 138                 params,
 139                 args[1],
 140                 env,
 141                 (List<MalType> funcArgs) =>
 142                     EVAL(args[1], new Env(env, params, funcArgs)));
 143           } else if (symbol.value == "quote") {
 144             return args.single;
 145           } else if (symbol.value == "quasiquote") {
 146             ast = quasiquote(args.first);
 147             continue;
 148           }
 149         }
 150         var newAst = eval_ast(ast, env) as MalList;
 151         var f = newAst.elements.first;
 152         var args = newAst.elements.sublist(1);
 153         if (f is MalBuiltin) {
 154           return f.call(args);
 155         } else if (f is MalClosure) {
 156           ast = f.ast;
 157           env = new Env(f.env, f.params, args);
 158           continue;
 159         } else {
 160           throw 'bad!';
 161         }
 162       }
 163     }
 164   }
 165 }
 166
 167 String PRINT(MalType x) => printer.pr_str(x);
 168
 169 String rep(String x) {
 170   var parsed;
 171   try {
 172     parsed = READ(x);
 173   } on reader.ParseException catch (e) {
 174     return e.message;
 175   }
 176
 177   var evaledAst;
 178   try {
 179     evaledAst = EVAL(parsed, replEnv);
 180   } on NotFoundException catch (e) {
 181     return "'${e.value}' not found";
 182   }
 183   return PRINT(evaledAst);
 184 }
 185
 186 const prompt = 'user> ';
 187 main(List<String> args) {
 188   setupEnv(args.isEmpty ? const <String>[] : args.sublist(1));
 189   if (args.isNotEmpty) {
 190     rep("(load-file \"${args.first}\")");
 191     return;
 192   }
 193   while (true) {
 194     stdout.write(prompt);
 195     var input = stdin.readLineSync();
 196     if (input == null) return;
 197     var output;
 198     try {
 199       output = rep(input);
 200     } on reader.NoInputException {
 201       continue;
 202     }
 203     stdout.writeln(output);
 204   }
 205 }