Don't generate expressions with app(lambda, _) since they are equivalent to the reduced expression

Author: MichaelGoodale

src/language/enumerator.rs

@@ -142,7 +142,7 @@ impl<'src> PossibleExpressions<'src, Expr<'src>> {
         let mut stack: Vec<HashedExpr<_>> = self
             .terms(
                 t,
-                false,
+                true,
                 std::iter::empty(),
                 possible_applications(t, std::iter::empty()),
             )
@@ -305,7 +305,9 @@ impl<'src> ExprWrapper<'src, Expr<'src>> {
         {
             let mut terms = possibles.terms(
                 typ,
-                false,
+                //the function of a application shouldn't have lambdas, since otherwise we could just
+                //apply the argument there.
+                i != 0 || !matches!(this.h.expr, LambdaExpr::Application { .. }),
                 this.variables
                     .iter()
                     .rev()
@@ -554,6 +556,8 @@ impl<'src, T: LambdaLanguageOfThought + Clone> From<FinishedExpr<'src, T>>
 
 #[cfg(test)]
 mod test {
+    use ahash::HashSetExt;
+
     use super::*;
 
     #[test]
@@ -582,11 +586,24 @@ mod test {
             LambdaType::from_string("<<a,t>,t>").unwrap(),
         ];
         for t in t {
-            for x in possibles.enumerator(&t, 4) {
+            println!("{t}");
+            let mut count = 0;
+            let mut pool_set = HashSet::new();
+            let mut reduced_pool_set = HashSet::new();
+
+            for mut x in possibles.enumerator(&t, 6) {
                 println!("{x}");
                 let o = x.get_type()?;
                 assert_eq!(o, t);
+                count += 1;
+                pool_set.insert(x.clone());
+                x.reduce()?;
+                x.cleanup();
+                reduced_pool_set.insert(x);
             }
+            assert!(count > 0);
+            assert_eq!(pool_set.len(), count);
+            assert_eq!(pool_set.len(), reduced_pool_set.len());
         }
         Ok(())
     }

src/language/mutations/samplers.rs

@@ -157,23 +157,20 @@ impl<'src, T: LambdaLanguageOfThought + Clone> PossibleExpressions<'src, T> {
     pub(crate) fn terms<'a>(
         &'a self,
         lambda_type: &LambdaType,
-        is_subformula: bool,
+        include_lambdas: bool,
         variables: impl Iterator<Item = LambdaExpr<'src, T>>,
         applications: impl Iterator<Item = (LambdaType, LambdaType)>,
     ) -> Vec<PossibleExpr<'a, 'src, T>> {
         let mut possibilities = vec![];
-        if !is_subformula {
-            if let Some(x) = self.expressions.get(lambda_type).map(|x| {
-                x.iter()
-                    .flat_map(|(_, v)| v.iter().map(PossibleExpr::new_borrowed))
-            }) {
-                possibilities.extend(x);
-            }
-
-            if let Ok((lhs, _)) = lambda_type.split() {
-                let e = PossibleExpr::new_owned(LambdaExpr::Lambda(LambdaExprRef(0), lhs.clone()));
-                possibilities.push(e);
-            }
+        if let Some(x) = self.expressions.get(lambda_type).map(|x| {
+            x.iter()
+                .flat_map(|(_, v)| v.iter().map(PossibleExpr::new_borrowed))
+        }) {
+            possibilities.extend(x);
+        }
+        if include_lambdas && let Ok((lhs, _)) = lambda_type.split() {
+            let e = PossibleExpr::new_owned(LambdaExpr::Lambda(LambdaExprRef(0), lhs.clone()));
+            possibilities.push(e);
         }
         possibilities.extend(variables.map(PossibleExpr::new_owned));
         possibilities.extend(