1  use std::{fs::File, io::Read, path::PathBuf, rc::Rc};
 2  
 3  use hlambda::{
 4      ast::*,
 5      eval::{DefaultIOImpl, Globals, Term, Val},
 6  };
 7  
 8  use clap::Parser;
 9  #[derive(Parser)]
10  #[command(version, about, long_about = None)]
11  struct Cli {
12      #[arg()]
13      file: PathBuf,
14  }
15  
16  fn main() {
17      let Cli { file } = Cli::parse();
18      let mut content = String::new();
19      File::open(file)
20          .unwrap()
21          .read_to_string(&mut content)
22          .unwrap();
23      let (rest, ast) = parse_expr(&content).unwrap();
24      println!("{ast:#?}");
25      if !rest.trim().is_empty() {
26          println!("Did not parse:\n{rest}");
27      }
28      println!("Evaluating...");
29  
30      let globals = Globals::new_with_io();
31  
32      let term = Term::from_ast_with_globals(ast, &globals).unwrap();
33      println!("{term:#?}");
34      let res = term.eval(&globals).unwrap();
35      let res = Rc::unwrap_or_clone(res);
36      println!("{res:#?}");
37      if let Val::IO(io) = res {
38          io.exec(&DefaultIOImpl).unwrap();
39      }
40      // let mut ctx = Context::default();
41  
42      // ctx.register("print", |_ctx, v| match v {
43      //     Value::Str(s) => {
44      //         print!("{s}");
45      //         Ok(Value::IO(Box::new(Value::Unit)))
46      //     }
47      //     Value::Int(i) => {
48      //         print!("{i}");
49      //         Ok(Value::IO(Box::new(Value::Unit)))
50      //     }
51      //     _ => Err(EvalError::InvalidArgument),
52      // })
53      // .unwrap();
54      // ctx.register("println", |_ctx, v| match v {
55      //     Value::Str(s) => {
56      //         println!("{s}");
57      //         Ok(Value::IO(Box::new(Value::Unit)))
58      //     }
59      //     Value::Int(i) => {
60      //         println!("{i}");
61      //         Ok(Value::IO(Box::new(Value::Unit)))
62      //     }
63      //     _ => Err(EvalError::InvalidArgument),
64      // })
65      // .unwrap();
66      // ctx.register("input", |_ctx, v| match v {
67      //     Value::Unit => {
68      //         let mut res = String::new();
69      //         stdin().read_line(&mut res)?;
70      //         while res.ends_with("\n") {
71      //             res.pop();
72      //         }
73      //         Ok(Value::IO(Box::new(Value::Str(res.into()))))
74      //     }
75      //     _ => Err(EvalError::InvalidArgument),
76      // })
77      // .unwrap();
78      // ctx.register("bind", |_ctx, v| match v {
79      //     Value::IO(lhs) => {
80      //         // eprintln!("Binding {lhs:?}");
81      //         Ok(Value::Internal(Some(lhs), |lhs, f| {
82      //             let lhs = lhs.ok_or(EvalError::InvalidState)?;
83      //             match f {
84      //                 Value::Function(ctx, var, expr) => eval(expr, ctx.with_value(var, *lhs)),
85      //                 Value::Internal(ctx, f) => f(ctx, *lhs),
86      //                 _ => Err(EvalError::InvalidArgument),
87      //             }
88      //         }))
89      //     }
90      //     _ => Err(EvalError::InvalidArgument),
91      // })
92      // .unwrap();
93  
94      // let val = eval(&ast, Rc::new(ctx));
95      // println!("{val:?}");
96  }