rust/src/step8_macros.rs

   1 // support precompiled regexes in reader.rs
   2 #![feature(phase)]
   3 #[phase(plugin)]
   4 extern crate regex_macros;
   5 extern crate regex;
   6
   7 use std::collections::HashMap;
   8 use std::os;
   9
  10 use types::{MalVal,MalRet,MalFunc,Nil,False,Sym,List,Vector,Hash_Map,Func,
  11             _nil,symbol,string,list,vector,hash_map,malfunc,malfuncd};
  12 use env::{Env,env_new,env_bind,env_root,env_find,env_set,env_get};
  13 mod readline;
  14 mod types;
  15 mod reader;
  16 mod printer;
  17 mod env;
  18 mod core;
  19
  20 // read
  21 fn read(str: String) -> MalRet {
  22     reader::read_str(str)
  23 }
  24
  25 // eval
  26 fn is_pair(x: MalVal) -> bool {
  27     match *x {
  28         List(ref lst) => lst.len() > 0,
  29         _ => false,
  30     }
  31 }
  32
  33 fn quasiquote(ast: MalVal) -> MalVal {
  34     if !is_pair(ast.clone()) {
  35         return list(vec![symbol("quote"), ast])
  36     }
  37
  38     match *ast.clone() {
  39         List(ref args) => {
  40             let ref a0 = args[0];
  41             match **a0 {
  42                 Sym(ref s) => {
  43                     if s.to_string() == "unquote".to_string() {
  44                         let ref a1 = args[1];
  45                         return a1.clone();
  46                     }
  47                 },
  48                 _ => (),
  49             }
  50             if is_pair(a0.clone()) {
  51                 match **a0 {
  52                     List(ref a0args) => {
  53                         let a00 = a0args[0].clone();
  54                         match *a00 {
  55                             Sym(ref s) => {
  56                                 if s.to_string() == "splice-unquote".to_string() {
  57                                     return list(vec![symbol("concat"),
  58                                                      a0args[1].clone(),
  59                                                      quasiquote(list(args.slice(1,args.len()).to_vec()))])
  60                                 }
  61                             },
  62                             _ => (),
  63                         }
  64                     },
  65                     _ => (),
  66                 }
  67             }
  68             let rest = list(args.slice(1,args.len()).to_vec());
  69             return list(vec![symbol("cons"),
  70                              quasiquote(a0.clone()),
  71                              quasiquote(rest)])
  72         },
  73         _ => _nil(), // should never reach
  74     }
  75 }
  76
  77 fn is_macro_call(ast: MalVal, env: Env) -> bool {
  78     match *ast {
  79         List(ref lst) => {
  80             let ref a0 = *lst[0];
  81             match *a0 {
  82                 Sym(ref a0sym) => {
  83                     if env_find(env.clone(), a0sym.to_string()).is_some() {
  84                         match env_get(env, a0sym.to_string()) {
  85                             Ok(f) => {
  86                                 match *f {
  87                                     MalFunc(ref mfd) => {
  88                                         mfd.is_macro
  89                                     },
  90                                     _ => false,
  91                                 }
  92                             },
  93                             _ => false,
  94                         }
  95                     } else {
  96                         false
  97                     }
  98                 },
  99                 _ => false,
 100             }
 101         },
 102         _ => false,
 103     }
 104 }
 105
 106 fn macroexpand(mut ast: MalVal, env: Env) -> MalRet {
 107     while is_macro_call(ast.clone(), env.clone()) {
 108         match *ast.clone() {
 109             List(ref args) => {
 110                 let ref a0 = args[0];
 111                 match **a0 {
 112                     Sym(ref s) => {
 113                         match env_get(env.clone(), s.to_string()) {
 114                             Ok(mf) => {
 115                                 match *mf {
 116                                     MalFunc(_) => {
 117                                         match mf.apply(args.slice(1,args.len()).to_vec()) {
 118                                             Ok(r) => ast = r,
 119                                             Err(e) => return Err(e),
 120                                         }
 121                                     },
 122                                     _ => break,
 123                                 }
 124                             },
 125                             Err(e) => return Err(e),
 126                         }
 127                     },
 128                     _ => break,
 129                 }
 130             },
 131             _ => break,
 132         }
 133     }
 134     Ok(ast)
 135 }
 136
 137 fn eval_ast(ast: MalVal, env: Env) -> MalRet {
 138     let ast2 = ast.clone();
 139     match *ast2 {
 140     //match *ast {
 141         Sym(ref sym) => {
 142             env_get(env.clone(), sym.clone())
 143         },
 144         List(ref a) | Vector(ref a) => {
 145             let mut ast_vec : Vec<MalVal> = vec![];
 146             for mv in a.iter() {
 147                 let mv2 = mv.clone();
 148                 match eval(mv2, env.clone()) {
 149                     Ok(mv) => { ast_vec.push(mv); },
 150                     Err(e) => { return Err(e); },
 151                 }
 152             }
 153             Ok(match *ast { List(_) => list(ast_vec),
 154                             _       => vector(ast_vec) })
 155         },
 156         Hash_Map(ref hm) => {
 157             let mut new_hm: HashMap<String,MalVal> = HashMap::new();
 158             for (key, value) in hm.iter() {
 159                 match eval(value.clone(), env.clone()) {
 160                     Ok(mv) => { new_hm.insert(key.to_string(), mv); },
 161                     Err(e) => return Err(e),
 162                 }
 163             }
 164             Ok(hash_map(new_hm))
 165         },
 166         _ => {
 167             Ok(ast)
 168         }
 169     }
 170 }
 171
 172 fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
 173     'tco: loop {
 174
 175     //println!("eval: {}, {}", ast, env.borrow());
 176     //println!("eval: {}", ast);
 177     let mut ast2 = ast.clone();
 178     match *ast2 {
 179         List(_) => (),  // continue
 180         _ => return eval_ast(ast2, env),
 181     }
 182
 183     // apply list
 184     match macroexpand(ast2, env.clone()) {
 185         Ok(a) => {
 186             ast2 = a;
 187         },
 188         Err(e) => return Err(e),
 189     }
 190     match *ast2 {
 191         List(_) => (),  // continue
 192         _ => return Ok(ast2),
 193     }
 194     let ast3 = ast2.clone();
 195
 196     match *ast2 {
 197         List(ref args) => {
 198             if args.len() == 0 {
 199                 return Ok(ast3);
 200             }
 201             let ref a0 = *args[0];
 202             match *a0 {
 203                 Sym(ref a0sym) => {
 204                     match a0sym.as_slice() {
 205                         "def!" => {
 206                             let a1 = (*args)[1].clone();
 207                             let a2 = (*args)[2].clone();
 208                             let res = eval(a2, env.clone());
 209                             match res {
 210                                 Ok(r) => {
 211                                     match *a1 {
 212                                         Sym(ref s) => {
 213                                             env_set(&env.clone(), s.clone(), r.clone());
 214                                             return Ok(r);
 215                                         },
 216                                         _ => {
 217                                             return Err("def! of non-symbol".to_string())
 218                                         }
 219                                     }
 220                                 },
 221                                 Err(e) => return Err(e),
 222                             }
 223                         },
 224                         "let*" => {
 225                             let let_env = env_new(Some(env.clone()));
 226                             let a1 = (*args)[1].clone();
 227                             let a2 = (*args)[2].clone();
 228                             match *a1 {
 229                                 List(ref binds) | Vector(ref binds) => {
 230                                     let mut it = binds.iter();
 231                                     while it.len() >= 2 {
 232                                         let b = it.next().unwrap();
 233                                         let exp = it.next().unwrap();
 234                                         match **b {
 235                                             Sym(ref bstr) => {
 236                                                 match eval(exp.clone(), let_env.clone()) {
 237                                                     Ok(r) => {
 238                                                         env_set(&let_env, bstr.clone(), r);
 239                                                     },
 240                                                     Err(e) => {
 241                                                         return Err(e);
 242                                                     },
 243                                                 }
 244                                             },
 245                                             _ => {
 246                                                 return Err("let* with non-symbol binding".to_string());
 247                                             },
 248                                         }
 249                                     }
 250                                 },
 251                                 _ => return Err("let* with non-list bindings".to_string()),
 252                             }
 253                             ast = a2;
 254                             env = let_env.clone();
 255                             continue 'tco;
 256                         },
 257                         "quote" => {
 258                             return Ok((*args)[1].clone());
 259                         },
 260                         "quasiquote" => {
 261                             let a1 = (*args)[1].clone();
 262                             ast = quasiquote(a1);
 263                             continue 'tco;
 264                         },
 265                         "defmacro!" => {
 266                             let a1 = (*args)[1].clone();
 267                             let a2 = (*args)[2].clone();
 268                             match eval(a2, env.clone()) {
 269                                 Ok(r) => {
 270                                     match *r {
 271                                         MalFunc(ref mfd) => {
 272                                             match *a1 {
 273                                                 Sym(ref s) => {
 274                                                     let mut new_mfd = mfd.clone();
 275                                                     new_mfd.is_macro = true;
 276                                                     let mf = malfuncd(new_mfd);
 277                                                     env_set(&env.clone(), s.clone(), mf.clone());
 278                                                     return Ok(mf);
 279                                                 },
 280                                                 _ => return Err("def! of non-symbol".to_string()),
 281                                             }
 282                                         },
 283                                         _ => return Err("def! of non-symbol".to_string()),
 284                                     }
 285                                 },
 286                                 Err(e) => return Err(e),
 287                             }
 288                         },
 289                         "macroexpand" => {
 290                             let a1 = (*args)[1].clone();
 291                             return macroexpand(a1, env.clone())
 292                         },
 293                         "do" => {
 294                             let el = list(args.slice(1,args.len()-1).to_vec());
 295                             match eval_ast(el, env.clone()) {
 296                                 Err(e) => return Err(e),
 297                                 Ok(_) => {
 298                                     let ref last = args[args.len()-1];
 299                                     ast = last.clone();
 300                                     continue 'tco;
 301                                 },
 302                             }
 303                         },
 304                         "if" => {
 305                             let a1 = (*args)[1].clone();
 306                             let cond = eval(a1, env.clone());
 307                             if cond.is_err() { return cond; }
 308                             match *cond.unwrap() {
 309                                 False | Nil => {
 310                                     if args.len() >= 4 {
 311                                         let a3 = (*args)[3].clone();
 312                                         ast = a3;
 313                                         env = env.clone();
 314                                         continue 'tco;
 315                                     } else {
 316                                         return Ok(_nil());
 317                                     }
 318                                 },
 319                                 _ => {
 320                                     let a2 = (*args)[2].clone();
 321                                     ast = a2;
 322                                     env = env.clone();
 323                                     continue 'tco;
 324                                 },
 325                             }
 326                         },
 327                         "fn*" => {
 328                             let a1 = (*args)[1].clone();
 329                             let a2 = (*args)[2].clone();
 330                             return Ok(malfunc(eval, a2, env.clone(), a1));
 331                         },
 332                         "eval" => {
 333                             let a1 = (*args)[1].clone();
 334                             match eval(a1, env.clone()) {
 335                                 Ok(exp) => {
 336                                     ast = exp;
 337                                     env = env_root(&env);
 338                                     continue 'tco;
 339                                 },
 340                                 Err(e) => return Err(e),
 341                             }
 342                         },
 343                         _ => ()
 344                     }
 345                 }
 346                 _ => (),
 347             }
 348             // function call
 349             /*
 350             if is_macro_call(ast3.clone(), env.clone()) {
 351                 println!("macro call");
 352             }
 353             */
 354             return match eval_ast(ast3, env.clone()) {
 355                 Err(e) => Err(e),
 356                 Ok(el) => {
 357                     match *el {
 358                         List(ref args) => {
 359                             let args2 = args.clone();
 360                             match *args2[0] {
 361                                 Func(f) => f(args.slice(1,args.len()).to_vec()),
 362                                 MalFunc(ref mf) => {
 363                                     let mfc = mf.clone();
 364                                     let alst = list(args.slice(1,args.len()).to_vec());
 365                                     let new_env = env_new(Some(mfc.env.clone()));
 366                                     match env_bind(&new_env, mfc.params, alst) {
 367                                         Ok(_) => {
 368                                             ast = mfc.exp;
 369                                             env = new_env;
 370                                             continue 'tco;
 371                                         },
 372                                         Err(e) => Err(e),
 373                                     }
 374                                 },
 375                                 _ => Err("attempt to call non-function".to_string()),
 376                             }
 377                         }
 378                         _ => Err("Invalid apply".to_string()),
 379                     }
 380                 }
 381             }
 382         }
 383         _ => return Err("Expected list".to_string()),
 384     }
 385
 386     }
 387 }
 388
 389 // print
 390 fn print(exp: MalVal) -> String {
 391     exp.pr_str(true)
 392 }
 393
 394 fn rep(str: String, env: Env) -> Result<String,String> {
 395     match read(str) {
 396         Err(e) => Err(e),
 397         Ok(ast) => {
 398             //println!("read: {}", ast);
 399             match eval(ast, env) {
 400                 Err(e)  => Err(e),
 401                 Ok(exp) => Ok(print(exp)),
 402             }
 403         }
 404     }
 405 }
 406
 407 fn main() {
 408     // core.rs: defined using rust
 409     let repl_env = env_new(None);
 410     for (k, v) in core::ns().into_iter() { env_set(&repl_env, k, v); }
 411     // see eval() for definition of "eval"
 412     env_set(&repl_env, "*ARGV*".to_string(), list(vec![]));
 413
 414     // core.mal: defined using the language itself
 415     let _ = rep("(def! not (fn* (a) (if a false true)))".to_string(),
 416                 repl_env.clone());
 417     let _ = rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))".to_string(),
 418                 repl_env.clone());
 419
 420     // Invoked with command line arguments
 421     let args = os::args();
 422     if args.len() > 1 {
 423         let mv_args = args.slice(2,args.len()).iter()
 424             .map(|a| string(a.to_string()))
 425             .collect::<Vec<MalVal>>();
 426         env_set(&repl_env, "*ARGV*".to_string(), list(mv_args));
 427         match rep("(load-file \"".to_string() + args[1] + "\")".to_string(),
 428                   repl_env.clone()) {
 429             Ok(_) => {
 430                 os::set_exit_status(0);
 431                 return;
 432             },
 433             Err(str) => {
 434                 println!("Error: {}", str);
 435                 os::set_exit_status(1);
 436                 return;
 437             },
 438         }
 439     }
 440
 441     loop {
 442         let line = readline::mal_readline("user> ");
 443         match line { None => break, _ => () }
 444         match rep(line.unwrap(), repl_env.clone()) {
 445             Ok(str)  => println!("{}", str),
 446             Err(str) => println!("Error: {}", str),
 447         }
 448     }
 449 }