From 8bf4b3c368779708ad6a6982335973a3ec149694 Mon Sep 17 00:00:00 2001 From: Ava Hahn Date: Tue, 7 Mar 2023 22:16:57 -0800 Subject: [PATCH] finished inc and dec, and tests --- Readme.org | 15 --- src/stl.rs | 22 +++++ src/stl/math.rs | 76 ++++++++++++++- tests/test_lib_math.rs | 208 ++++++++++++++++++++++++++++++++++++++++- 4 files changed, 304 insertions(+), 17 deletions(-) diff --git a/Readme.org b/Readme.org index c3af010..6e1f587 100644 --- a/Readme.org +++ b/Readme.org @@ -201,21 +201,6 @@ Optionally return a list of new variables and/or functions? Will need a concatenate function for tables *** TODO Main shell calls Load function on arg and exits *** TODO Can enter multiple lines of text, with formatting in repl -*** TODO arithmetic operations -**** DONE typecast (int) -**** DONE typecast (float) -**** DONE add -**** DONE sub -**** DONE div -**** DONE mul -**** DONE exp -**** DONE mod -***** DONE Test for Let Destructuring -**** TODO inc -**** TODO dec -**** DONE gt? -**** DONE lt? -**** DONE snippets for gte and lte *** TODO string operations **** TODO typecast (string) **** TODO contains diff --git a/src/stl.rs b/src/stl.rs index ccf6033..e092ca7 100644 --- a/src/stl.rs +++ b/src/stl.rs @@ -349,6 +349,28 @@ pub fn static_stdlib(syms: &mut SymTable) -> Result<(), String> { }, ); + syms.insert( + "inc".to_string(), + Symbol { + name: String::from("inc"), + args: Args::Lazy(1), + conditional_branches: true, + docs: math::INC_DOCSTRING.to_string(), + value: ValueType::Internal(Rc::new(math::inc_callback)), + }, + ); + + syms.insert( + "dec".to_string(), + Symbol { + name: String::from("dec"), + args: Args::Lazy(1), + conditional_branches: true, + docs: math::DEC_DOCSTRING.to_string(), + value: ValueType::Internal(Rc::new(math::dec_callback)), + }, + ); + Ok(()) } diff --git a/src/stl/math.rs b/src/stl/math.rs index 41a9953..fd93b38 100644 --- a/src/stl/math.rs +++ b/src/stl/math.rs @@ -15,7 +15,7 @@ */ use crate::segment::{Ctr, Seg}; -use crate::sym::SymTable; +use crate::sym::{SymTable, ValueType}; fn isnumeric(arg: &Ctr) -> bool { match arg { @@ -358,3 +358,77 @@ pub fn islte_callback(ast: &Seg, syms: &mut SymTable) -> Result { Err("impossible state: islt returned non-bool".to_string()) } } + +pub const INC_DOCSTRING: &str = "Accepts a single argument, expects it to be a symbol. +The symbol is fetched from the symbol table. +If the symbol is not an integer an error is returned. +The symbol is redefined as symbol + 1. + +This call is similar to the following: +(def counter '' (add counter 1)) +with the caveat that your docstring is preserved."; + +pub fn inc_callback(ast: &Seg, syms: &mut SymTable) -> Result { + let var_name: String; + if let Ctr::Symbol(ref s) = *ast.car { + var_name = s.clone(); + } else { + return Err("argument should be a symbol".to_string()); + } + + let mut sym = syms + .remove(&var_name) + .expect(&format!("symbol {var_name} is not defined")); + + if let ValueType::VarForm(ref var) = sym.value { + if let Ctr::Integer(ref b) = **var { + sym.value = ValueType::VarForm(Box::new(Ctr::Integer(b + 1))); + } else { + syms.insert(var_name, sym); + return Err("can only increment an integer".to_string()); + } + } else { + syms.insert(var_name, sym); + return Err("cannot increment a function".to_string()); + } + + syms.insert(var_name, sym); + Ok(Ctr::None) +} + +pub const DEC_DOCSTRING: &str = "Accepts a single argument, expects it to be a symbol. +The symbol is fetched from the symbol table. +If the symbol is not an integer an error is returned. +The symbol is redefined as symbol - 1. + +This call is similar to the following: +(def counter '' (sub counter 1)) +with the caveat that your docstring is preserved."; + +pub fn dec_callback(ast: &Seg, syms: &mut SymTable) -> Result { + let var_name: String; + if let Ctr::Symbol(ref s) = *ast.car { + var_name = s.clone(); + } else { + return Err("argument should be a symbol".to_string()); + } + + let mut sym = syms + .remove(&var_name) + .expect(&format!("symbol {var_name} is not defined")); + + if let ValueType::VarForm(ref var) = sym.value { + if let Ctr::Integer(ref b) = **var { + sym.value = ValueType::VarForm(Box::new(Ctr::Integer(b - 1))); + } else { + syms.insert(var_name, sym); + return Err("can only decrement an integer".to_string()); + } + } else { + syms.insert(var_name, sym); + return Err("cannot decrement a function".to_string()); + } + + syms.insert(var_name, sym); + Ok(Ctr::None) +} diff --git a/tests/test_lib_math.rs b/tests/test_lib_math.rs index deb656e..9c8d7dc 100644 --- a/tests/test_lib_math.rs +++ b/tests/test_lib_math.rs @@ -1,5 +1,5 @@ mod math_lib_tests { - use relish::ast::{eval, lex, SymTable}; + use relish::ast::{eval, lex, Ctr, SymTable}; use relish::stdlib::{dynamic_stdlib, static_stdlib}; #[test] @@ -608,4 +608,210 @@ mod math_lib_tests { result.to_string(), ); } + + #[test] + fn test_inc() { + let document = "(def tester '' 1)"; + let change = "(inc tester)"; + let check = "(tester)"; + + let mut syms = SymTable::new(); + static_stdlib(&mut syms).unwrap(); + dynamic_stdlib(&mut syms).unwrap(); + + let doc_tree = lex(&document.to_string()).unwrap(); + let change_tree = lex(&change.to_string()).unwrap(); + let check_tree = lex(&check.to_string()).unwrap(); + + eval(&doc_tree, &mut syms).unwrap(); + eval(&change_tree, &mut syms).unwrap(); + + if let Ctr::Seg(ref s) = *eval(&check_tree, &mut syms).unwrap() { + if let Ctr::Integer(ref b) = *s.car { + assert_eq!(2, *b) + } else { + panic!() + } + } else { + panic!() + } + + eval(&change_tree, &mut syms).unwrap(); + if let Ctr::Seg(ref s) = *eval(&check_tree, &mut syms).unwrap() { + if let Ctr::Integer(ref b) = *s.car { + assert_eq!(3, *b) + } else { + panic!() + } + } else { + panic!() + } + } + + #[test] + fn test_inc_errors_dont_lose_vars() { + let document = "(def tester '' 'oops')"; + let change = "(inc tester)"; + let check = "(tester)"; + + let mut syms = SymTable::new(); + static_stdlib(&mut syms).unwrap(); + dynamic_stdlib(&mut syms).unwrap(); + + let doc_tree = lex(&document.to_string()).unwrap(); + let change_tree = lex(&change.to_string()).unwrap(); + let check_tree = lex(&check.to_string()).unwrap(); + + eval(&doc_tree, &mut syms).unwrap(); + if let Err(s) = eval(&change_tree, &mut syms) { + assert_eq!( + s, + "error in call to inc: can only increment an integer".to_string() + ); + let intermediate = *eval(&check_tree, &mut syms).unwrap(); + if let Ctr::Seg(ref s) = intermediate { + assert_eq!(s.to_string(), "('oops')".to_string()); + } else { + eprintln!("did not expect: {}", intermediate); + panic!() + } + } else { + eprintln!("shouldn't have succeeded!"); + panic!() + } + } + + #[test] + fn test_inc_errors_dont_lose_funcs() { + let document = "(def tester '' (oops) oops)"; + let change = "(inc tester)"; + let check = "(tester '1')"; + + let mut syms = SymTable::new(); + static_stdlib(&mut syms).unwrap(); + dynamic_stdlib(&mut syms).unwrap(); + + let doc_tree = lex(&document.to_string()).unwrap(); + let change_tree = lex(&change.to_string()).unwrap(); + let check_tree = lex(&check.to_string()).unwrap(); + + eval(&doc_tree, &mut syms).unwrap(); + if let Err(s) = eval(&change_tree, &mut syms) { + assert_eq!( + s, + "error in call to inc: cannot increment a function".to_string() + ); + if let Ctr::String(ref s) = *eval(&check_tree, &mut syms).unwrap() { + assert_eq!(*s, "1".to_string()); + } else { + panic!() + } + } else { + eprintln!("shouldn't have succeeded!"); + panic!() + } + } + + #[test] + fn test_dec() { + let document = "(def tester '' 1)"; + let change = "(dec tester)"; + let check = "(tester)"; + + let mut syms = SymTable::new(); + static_stdlib(&mut syms).unwrap(); + dynamic_stdlib(&mut syms).unwrap(); + + let doc_tree = lex(&document.to_string()).unwrap(); + let change_tree = lex(&change.to_string()).unwrap(); + let check_tree = lex(&check.to_string()).unwrap(); + + eval(&doc_tree, &mut syms).unwrap(); + eval(&change_tree, &mut syms).unwrap(); + + if let Ctr::Seg(ref s) = *eval(&check_tree, &mut syms).unwrap() { + if let Ctr::Integer(ref b) = *s.car { + assert_eq!(0, *b) + } else { + panic!() + } + } else { + panic!() + } + + eval(&change_tree, &mut syms).unwrap(); + if let Ctr::Seg(ref s) = *eval(&check_tree, &mut syms).unwrap() { + if let Ctr::Integer(ref b) = *s.car { + assert_eq!(-1, *b) + } else { + panic!() + } + } else { + panic!() + } + } + + #[test] + fn test_dec_errors_dont_lose_vars() { + let document = "(def tester '' 'oops')"; + let change = "(dec tester)"; + let check = "(tester)"; + + let mut syms = SymTable::new(); + static_stdlib(&mut syms).unwrap(); + dynamic_stdlib(&mut syms).unwrap(); + + let doc_tree = lex(&document.to_string()).unwrap(); + let change_tree = lex(&change.to_string()).unwrap(); + let check_tree = lex(&check.to_string()).unwrap(); + + eval(&doc_tree, &mut syms).unwrap(); + if let Err(s) = eval(&change_tree, &mut syms) { + assert_eq!( + s, + "error in call to dec: can only decrement an integer".to_string() + ); + let intermediate = *eval(&check_tree, &mut syms).unwrap(); + if let Ctr::Seg(ref s) = intermediate { + assert_eq!(s.to_string(), "('oops')".to_string()); + } else { + eprintln!("did not expect: {}", intermediate); + panic!() + } + } else { + eprintln!("shouldn't have succeeded!"); + panic!() + } + } + + #[test] + fn test_dec_errors_dont_lose_funcs() { + let document = "(def tester '' (oops) oops)"; + let change = "(dec tester)"; + let check = "(tester '1')"; + + let mut syms = SymTable::new(); + static_stdlib(&mut syms).unwrap(); + dynamic_stdlib(&mut syms).unwrap(); + + let doc_tree = lex(&document.to_string()).unwrap(); + let change_tree = lex(&change.to_string()).unwrap(); + let check_tree = lex(&check.to_string()).unwrap(); + + eval(&doc_tree, &mut syms).unwrap(); + if let Err(s) = eval(&change_tree, &mut syms) { + assert_eq!( + s, + "error in call to dec: cannot decrement a function".to_string() + ); + if let Ctr::String(ref s) = *eval(&check_tree, &mut syms).unwrap() { + assert_eq!(*s, "1".to_string()); + } else { + panic!() + } + } else { + eprintln!("shouldn't have succeeded!"); + panic!() + } + } }