Generate multiple expressions

2 files changed, 48 insertions, 6 deletions

diff --git a/rust/src/lambda.rs b/rust/src/lambda.rs
index 8ac3e46..4027a62 100644
--- a/rust/src/lambda.rs
+++ b/rust/src/lambda.rs
@@ -117,15 +117,23 @@ pub fn generate_expr(size: u32, runner: &mut TestRunner) -> Value {
         6 => simple_lambda().new_tree(runner).unwrap().current(),
         7 => app_to_lambda().new_tree(runner).unwrap().current(),
         8 => multi_app().new_tree(runner).unwrap().current(),
-        9 => any::<u32>()
+        _ => any::<u32>()
             .prop_flat_map(gen_terms)
             .new_tree(runner)
             .unwrap()
             .current(),
-        _ => todo!(),
     }
 }
 
+pub fn generate_exprs(size: u32, runner: &mut TestRunner) -> Vec<Value> {
+    let sz = (0..size).new_tree(runner).unwrap().current();
+    (0..sz)
+        .collect::<Vec<_>>()
+        .into_iter()
+        .map(|_| generate_expr(size, runner))
+        .collect()
+}
+
 fn simple_app() -> impl Strategy<Value = Value> {
     let leaf = prop_oneof![any_num(), any_sym()];
     (leaf.clone(), leaf.clone()).prop_map(|(l, r)| Value::App(Box::new(l), Box::new(r)))
diff --git a/rust/src/web.rs b/rust/src/web.rs
index 6bba34e..3b9fc9e 100644
--- a/rust/src/web.rs
+++ b/rust/src/web.rs
@@ -10,7 +10,7 @@ use std::{collections::HashMap, sync::Arc};
 use tokio::task;
 use uuid::Uuid;
 
-use lambda::lambda::{eval_all, eval_whnf, generate_expr, Environment};
+use lambda::lambda::{eval_all, eval_whnf, generate_expr, generate_exprs, Environment};
 use lambda::parser::parse;
 
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
@@ -67,9 +67,31 @@ impl Client {
     }
 
     fn generate_expr(&mut self) -> (String, String) {
-        let input = generate_expr(self.grade.into(), &mut self.runner);
-        let expected = eval_whnf(&input, &mut Environment::new());
-        (input.to_string(), expected.to_string())
+        if self.grade >= 10 {
+            self.generate_exprs()
+        } else {
+            let input = generate_expr(self.grade.into(), &mut self.runner);
+            let expected = eval_whnf(&input, &mut Environment::new());
+            (input.to_string(), expected.to_string())
+        }
+    }
+
+    fn generate_exprs(&mut self) -> (String, String) {
+        let exprs = generate_exprs(self.grade.into(), &mut self.runner);
+        let input = exprs
+            .iter()
+            .map(|v| format!("{}", v))
+            .collect::<Vec<_>>()
+            .join("\n");
+        let expected = eval_all(&exprs);
+        (
+            input,
+            expected
+                .iter()
+                .map(|v| format!("{}", v))
+                .collect::<Vec<_>>()
+                .join("\n"),
+        )
     }
 
     fn check_result(
@@ -505,6 +527,18 @@ mod app_tests {
     }
 
     #[test]
+    async fn client_generates_multiple_terms_at_level_10() {
+        let mut client = client();
+        client.grade = 10;
+
+        let (input, _) = client.generate_expr();
+
+        let parsed = parse(&input);
+
+        assert!(parsed.len() > 1);
+    }
+
+    #[test]
     async fn client_increases_grade_on_successful_test() {
         let mut client = client();
         let expected = "1".to_string();