notes

NOTES:
* Implement Logo list as VecDeque.
* Code coverage for tests (cargo-llvm-cov?).
* Lexer
  * Implement Iter(able) on Lexer (? old comment).
  * Don't lex if line ends in LineCont, wait for next one.
  * TO \ BK defines the function " BK", ie. \ can escape a space making it a "letter", it can also escape other things (like arithmetic operators).
* Parser
  * Parser should have its own "Tokens", only Parser should depend on Lexer (currently Evaluator uses Lexer::Token).
* Turtle
  * Fix floating point comparison (https://stackoverflow.com/questions/4915462/how-should-i-do-floating-point-comparison/32334103#32334103).
* Evaluator
  * Turning `stack_expr` into a RefCell would probably solve problems.
  * Remove `eval_list`, have REPEAT/FOR take in a ExprBlock.
  * MakeListType! macro (old).
  * Implement (LIST arg1 arg2 arg3 ...) - functions that take N arguments (old).
  * Remove imports, create proper types for VecDeque & HashMap.
  * Tests. Capturing graphics, output (printed, running commands, functions), errors.
  * Test function return (eg. 1 + FUNC_RET_2 == 3).
  * Bug where stack_expr keeps growing on error (because ? operator jumps over the pop) - use scopeguard?
  * LOAD <file> - "Loading from file <file>", "KV defined", "KV redefined".
  * Implement REPEAT with FOR.
  * Get rid of the stack_expr remainder.
  * Get "STAZA" & "STAZA2" to work.
  * Replace "match self.eval(ast_node)?" with "if let AST::Num(num) ..." (overuse of match)
* Main
  * Convert point to Vec2 as well (would involve converting other pieces)?
  * Both Point type and Vec type (could be same underlying thing, but for semantical difference)?

Idea
  self.push_expr(expr).eval_with_pop()?

1)
  let list = evaluator.borrow_mut().get_next_list()?;
  evaluator.borrow_mut().stack_expr.push(list);
  let x = evaluator.borrow_mut().get_next_number()?;
  let y = evaluator.borrow_mut().get_next_number()?;
  evaluator.borrow_mut().turtle.setxy(x, y);

2) ? what do I need this for?
  fn eval_list(&mut self, list: &ListType) -> Result<(), String> {
    self.stack_expr.push(list.clone());
    let mut ret = Ok(());
    while let Some(expr) = self.current_expr_list().pop_front() {
      match self.eval(&expr) {

3) ? self.stack_vars ?
  fn eval_user_function(&mut self, name: &str) -> Result<AST, String> {
    // Setup the args as local vars.
    for arg in args {
      local_vars.insert(arg.clone(), self.eval_next_expr()?);
    }
    self.stack_vars.push(local_vars);
    // TODO: Probably don't need this push here?
    self.stack_expr.push(VecDeque::new());
    let mut ret = AST::None;
    // Run the lines.
    let mut err = None;
    for line in lines {
      match self.eval(&line) { ???????

4)
  fn eval(&mut self, ast_node: &AST) -> Result<AST, String> {
    match ast_node {
      // TODO: Type that pushes during construction, and pops during destruction.
      AST::ExprLine(expr_list) => {
        // self.stack_expr.push(expr_list.clone());
        // defer! {
        //   self.stack_expr.pop();
        // }
        while let Some(expr) = self.current_expr_list().pop_front() {
          ret = self.eval(&expr)?;
          if ret != AST::None {
            break;
          }
        }
        // self.stack_expr.pop();

5)
  fn eval(&mut self, ast_node: &AST) -> Result<AST, String> {
    match ast_node {
      // TODO: Builtin functions behave differently if they open Parens.
      AST::Parens(expr_list) => {
        // Evaluates only the first expr and returns result (if any).  If the expression list is
        // empty, returns the empty list.
        if expr_list.is_empty() {
          ret = AST::List(ListType::new());
        } else {
          // TODO: Can this be simplified to just (probably) - nope, needs recursive parsing with pushing onto stack:
          // ret = self.eval(&expr_list[0])?;
          self.stack_expr.push(expr_list.clone());
          let next_expr = self.current_expr_list().pop_front().unwrap();
          ret = self.eval(&next_expr)?;
          self.stack_expr.pop();
        }
      },

  add_builtin!(SETXY, (|E: &mut Evaluator| {
    let evaluator = RefCell::new(E);
    let list = evaluator.borrow_mut().get_next_list()?;
    evaluator.borrow_mut().stack_expr.push(list);
    defer ! {
      evaluator.borrow_mut().stack_expr.pop();
      println!("Hi From Deferred Block!")
    }
    let x = evaluator.borrow_mut().get_next_number()?;
    let y = evaluator.borrow_mut().get_next_number()?;
    evaluator.borrow_mut().turtle.setxy(x, y);
    // evaluator.stack_expr.pop();
    Ok(AST::None)
  }));