Fixed add_unbound_method_to_stack and add_bound_method_to_stack so that if any argument is a lamba expression they will correctly be evaluated.

Author: smarie

code_generation/mini_lambda_template.mako

@@ -3,17 +3,13 @@
 # ----
 from typing import Any
 
-from mini_lambda.base import StackableFunctionEvaluator, evaluate, get_repr
+from mini_lambda.base import StackableFunctionEvaluator, evaluate, get_repr, FunctionDefinitionError
 from mini_lambda.base import PRECEDENCE_ADD_SUB, PRECEDENCE_MUL_DIV_ETC, PRECEDENCE_COMPARISON, \
     PRECEDENCE_EXPONENTIATION, PRECEDENCE_SHIFTS, PRECEDENCE_POS_NEG_BITWISE_NOT, \
     PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF
 from sys import getsizeof
 
 
-class FunctionDefinitionError(Exception):
-    """ An exception thrown when defining a function incorrectly """
-
-
 class _LambdaExpressionGenerated(StackableFunctionEvaluator):
     """
     This generated class implements a bunch of magic methods, so that calling these magic methods on an object will
@@ -30,18 +26,6 @@ class _LambdaExpressionGenerated(StackableFunctionEvaluator):
      package-level to provide a replacement (The exception message provides the replacement method name).
     """
 
-    def assert_has_same_root_var(self, other: Any):
-        """
-        Asserts that if other is also a StackableFunctionEvaluator, then it has the same root variable
-        :param other:
-        :return:
-        """
-        if isinstance(other, StackableFunctionEvaluator):
-            # check that both work on the same variable
-            if self._root_var != other._root_var:
-                raise FunctionDefinitionError('It is not allowed to combine several variables (x, s, l...) in the same '
-                                              'expression')
-
     # ******* All magic methods that need to be implemented ********
 
     ## For each method to override

mini_lambda/base.py

@@ -21,6 +21,10 @@
 PRECEDENCE_MAX = 17
 
 
+class FunctionDefinitionError(Exception):
+    """ An exception thrown when defining a function incorrectly """
+
+
 class StackableFunctionEvaluator:
     """
     A StackableFunctionEvaluator is a wrapper for a function (self._fun) with a SINGLE argument.
@@ -88,6 +92,18 @@ def to_string(self):
         """
         return self._str_expr
 
+    def assert_has_same_root_var(self, other: Any):
+        """
+        Asserts that if other is also a StackableFunctionEvaluator, then it has the same root variable
+        :param other:
+        :return:
+        """
+        if isinstance(other, StackableFunctionEvaluator):
+            # check that both work on the same variable
+            if self._root_var != other._root_var:
+                raise FunctionDefinitionError('It is not allowed to combine several variables (x, s, l...) in the same '
+                                              'expression')
+
     def add_unbound_method_to_stack(self, method, *m_args):
         """
         Returns a new StackableFunctionEvaluator whose inner function will be
@@ -98,12 +114,14 @@ def add_unbound_method_to_stack(self, method, *m_args):
         :param m_args: optional args to apply in method calls
         :return:
         """
+        for other in m_args:
+            self.assert_has_same_root_var(other)
 
         def evaluate_inner_function_and_apply_method(input):
             # first evaluate the inner function
             res = self.evaluate(input)
             # then call the method
-            return method(res, *m_args)
+            return method(res, *[evaluate(arg, input) for arg in m_args])
 
         # return a new InputEvaluator of the same type than self, with the new function as inner function
         # Note: we use precedence=None for coma-separated items inside the parenthesis
@@ -124,14 +142,16 @@ def add_bound_method_to_stack(self, method_name, *m_args):
         :param m_args: optional args to apply in method calls
         :return:
         """
+        for other in m_args:
+            self.assert_has_same_root_var(other)
 
         def evaluate_inner_function_and_apply_object_method(raw_input):
             # first evaluate the inner function
             res = self.evaluate(raw_input)
             # then retrieve the (bound) method on the result object, from its name
             object_method = getattr(res, method_name)
             # finally call the method
-            return object_method(*m_args)
+            return object_method(*[evaluate(other, input) for other in m_args])
 
         # return a new InputEvaluator of the same type than self, with the new function as inner function
         # Note: we use precedence=None for coma-separated items inside the parenthesis