20220629 typed language

Cargo.toml

@@ -33,6 +33,8 @@ serde_json = "1.0"
 sha2 = "0.9.5"
 tempfile = "3.3.0"
 clvmr = { version = "0.2.6", features = ["pre-eval"] }
+env_logger = "0.9.0"
+log = "0.4.17"
 binascii = "0.1.4"
 yaml-rust = "0.4"
 linked-hash-map = "0.5.6"
@@ -98,3 +100,7 @@ path = "src/classic/bins/clisp_to_json.rs"
 [[bin]]
 name = "repl"
 path = "src/classic/bins/repl.rs"
+
+[[bin]]
+name = "typetest"
+path = "src/classic/bins/typetest.rs"

src/classic/bins/repl.rs

@@ -1,7 +1,6 @@
 extern crate clvmr as clvm_rs;
 
 use std::io::{self, BufRead, Write};
-
 use std::rc::Rc;
 
 use clvm_rs::allocator::Allocator;
@@ -12,6 +11,8 @@ use clvm_tools_rs::compiler::repl::Repl;
 use clvm_tools_rs::classic::clvm_tools::stages::stage_0::DefaultProgramRunner;
 
 fn main() {
+    env_logger::init();
+
     let mut allocator = Allocator::new();
     let runner = Rc::new(DefaultProgramRunner::new());
     let opts = Rc::new(DefaultCompilerOpts::new("*program*"));

src/classic/bins/typetest.rs

@@ -0,0 +1,66 @@
+extern crate clvmr as clvm_rs;
+
+use std::env;
+
+use clvm_tools_rs::compiler::comptypes::CompileErr;
+use clvm_tools_rs::compiler::sexp::parse_sexp;
+use clvm_tools_rs::compiler::srcloc::Srcloc;
+use clvm_tools_rs::compiler::typecheck::{parse_expr_sexp, TheoryToSExp};
+use clvm_tools_rs::compiler::typechia::standard_type_context;
+use clvm_tools_rs::compiler::types::ast::{ContextElim, Var};
+use clvm_tools_rs::compiler::types::theory::TypeTheory;
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    if args.len() < 2 {
+        println!("give type theory expressions");
+        return;
+    }
+
+    env_logger::init();
+
+    let loc = Srcloc::start("*program*");
+    let mut context = standard_type_context();
+
+    let mut takename = true;
+    let mut name = "".to_string();
+    for arg in args.iter().take(args.len() - 1).skip(1) {
+        if takename {
+            name = arg.to_string();
+        } else {
+            match parse_sexp(loc.clone(), arg.bytes())
+                .map_err(|e| CompileErr(e.0.clone(), e.1))
+                .and_then(|parsed_program| parse_expr_sexp(parsed_program[0].clone()))
+                .and_then(|result| context.typesynth(&result))
+            {
+                Ok((ty, _)) => {
+                    context = context.snoc(ContextElim::CVar(Var(name.clone(), loc.clone()), ty));
+                }
+                Err(e) => {
+                    println!("error in helper {name}: {e:?}");
+                    return;
+                }
+            }
+        }
+
+        takename = !takename;
+    }
+
+    println!("starting context {}", context.to_sexp());
+
+    parse_sexp(loc, args[args.len() - 1].bytes())
+        .map_err(|e| CompileErr(e.0.clone(), e.1))
+        .and_then(|parsed_program| parse_expr_sexp(parsed_program[0].clone()))
+        .and_then(|result| {
+            println!("parsed: {}", result.to_sexp());
+            context.typesynth(&result)
+        })
+        .map(|(ty, ctx)| {
+            println!("typed: {}", ctx.reify(&ty, None).to_sexp());
+            println!("context: {}", ctx.to_sexp());
+        })
+        .map_err(|e| {
+            println!("failed: {e:?}");
+        })
+        .ok();
+}

src/classic/clvm_tools/clvmc.rs

@@ -25,6 +25,8 @@ use crate::compiler::compiler::{run_optimizer, DefaultCompilerOpts};
 use crate::compiler::comptypes::{CompileErr, CompilerOpts};
 use crate::compiler::dialect::detect_modern;
 use crate::compiler::runtypes::RunFailure;
+use crate::compiler::srcloc::Srcloc;
+use crate::compiler::untype::untype_code;
 
 pub fn write_sym_output(
     compiled_lookup: &HashMap<String, String>,
@@ -48,6 +50,7 @@ pub fn compile_clvm_text(
 ) -> Result<NodePtr, EvalErr> {
     let ir_src = read_ir(text).map_err(|s| EvalErr(allocator.null(), s.to_string()))?;
     let assembled_sexp = assemble_from_ir(allocator, Rc::new(ir_src))?;
+    let untyped_sexp = untype_code(allocator, Srcloc::start(input_path), assembled_sexp)?;
 
     let dialect = detect_modern(allocator, assembled_sexp);
     // Now the stepping is optional (None for classic) but we may communicate
@@ -68,7 +71,7 @@ pub fn compile_clvm_text(
         .map_err(|s| EvalErr(allocator.null(), s.1))
     } else {
         let compile_invoke_code = run(allocator);
-        let input_sexp = allocator.new_pair(assembled_sexp, allocator.null())?;
+        let input_sexp = allocator.new_pair(untyped_sexp, allocator.null())?;
         let run_program = run_program_for_search_paths(input_path, &opts.get_search_paths(), false);
         if classic_with_opts {
             run_program.set_compiler_opts(Some(opts));