Renamed InputEvaluator to LambdaExpression.

Added the possibility to use the variable several times in operations that do not have operators, such as function calls, getitem, etc.
Added checks everywhere to make sure that two different variables can not be combined in the same expression

Author: smarie

code_generation/mini_lambda_template.mako

@@ -1,6 +1,8 @@
 # ----
 # This file is generated by mini_lambda_methods_generation.py - do not modify it !
 # ----
+from typing import Any
+
 from mini_lambda.base import StackableFunctionEvaluator, evaluate, get_repr
 from mini_lambda.base import PRECEDENCE_ADD_SUB, PRECEDENCE_MUL_DIV_ETC, PRECEDENCE_COMPARISON, \
     PRECEDENCE_EXPONENTIATION, PRECEDENCE_SHIFTS, PRECEDENCE_POS_NEG_BITWISE_NOT, \
@@ -12,11 +14,11 @@ class FunctionDefinitionError(Exception):
     """ An exception thrown when defining a function incorrectly """
 
 
-class _InputEvaluatorGenerated(StackableFunctionEvaluator):
+class _LambdaExpressionGenerated(StackableFunctionEvaluator):
     """
     This generated class implements a bunch of magic methods, so that calling these magic methods on an object will
     result in adding that magic method to the StackableFunctionEvaluator's stack.
-    This allows for example x[1] to return a new _InputEvaluatorGenerated whose stack is able to call [1] (getitem(1))
+    This allows for example x[1] to return a new _LambdaExpressionGenerated whose stack is able to call [1] (getitem(1))
     on the result of the current stack's evaluation
 
     The methods added below belong to two categories
@@ -28,14 +30,26 @@ class _InputEvaluatorGenerated(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
     % for o in to_override:
         % if o.uni_operator:
     ## ----------unitary operator such as '-'-------------------
     def ${o.method_name}(self):
-        """ Returns a new _InputEvaluator performing '${o.uni_operator}<r>' on the result <r> of this evaluator's evaluation """
+        """ Returns a new _LambdaExpression performing '${o.uni_operator}<r>' on the result <r> of this evaluator's evaluation """
         ## def _${o.method_name}(r, input):
         ##     return ${o.uni_operator}r
         ## return self.add_unbound_method_to_stack(_${o.method_name})
@@ -45,7 +59,7 @@ class _InputEvaluatorGenerated(StackableFunctionEvaluator):
             # then call the method
             return ${o.uni_operator}res
 
-        # return a new InputEvaluator of the same type than self, with the new function as inner function
+        # return a new LambdaExpression of the same type than self, with the new function as inner function
         string_expr = '${o.uni_operator}' + get_repr(self, ${o.precedence_level})
         return type(self)(fun=_${o.method_name}, precedence_level=${o.precedence_level}, str_expr=string_expr, root_var=self._root_var)
 
@@ -54,35 +68,37 @@ class _InputEvaluatorGenerated(StackableFunctionEvaluator):
             % if o.is_operator_left:
     ## --------pairwise operator - left---------------------
     def ${o.method_name}(self, other):
-        """ Returns a new _InputEvaluator performing '<r> ${o.pair_operator} other' on the result <r> of this evaluator's evaluation """
+        """ Returns a new _LambdaExpression performing '<r> ${o.pair_operator} other' on the result <r> of this evaluator's evaluation """
         ## def _${o.method_name}(r, input):
         ##    return r ${o.pair_operator} evaluate(other, input)
         ## return self.add_unbound_method_to_stack(_${o.method_name})
+        self.assert_has_same_root_var(other)
         def _${o.method_name}(input):
             # first evaluate the inner function
             r = self.evaluate(input)
             # then call the method
             return r ${o.pair_operator} evaluate(other, input)
 
-        # return a new InputEvaluator of the same type than self, with the new function as inner function
+        # return a new LambdaExpression of the same type than self, with the new function as inner function
         string_expr = get_repr(self, ${o.precedence_level}) + ' ${o.pair_operator} ' + get_repr(other, ${o.precedence_level})
         return type(self)(fun=_${o.method_name}, precedence_level=${o.precedence_level}, str_expr=string_expr, root_var=self._root_var)
 
     ## -----------------------------
             % else:
     ## --------pairwise operator - left---------------------
     def ${o.method_name}(self, other):
-        """ Returns a new _InputEvaluator performing 'other ${o.pair_operator} <r>' on the result <r> of this evaluator's evaluation """
+        """ Returns a new _LambdaExpression performing 'other ${o.pair_operator} <r>' on the result <r> of this evaluator's evaluation """
         ## def _${o.method_name}(r, input):
         ##     return evaluate(other, input) ${o.pair_operator} r
         ## return self.add_unbound_method_to_stack(_${o.method_name})
+        self.assert_has_same_root_var(other)
         def _${o.method_name}(input):
             # first evaluate the inner function
             r = self.evaluate(input)
             # then call the method
             return evaluate(other, input) ${o.pair_operator} r
 
-        # return a new InputEvaluator of the same type than self, with the new function as inner function
+        # return a new LambdaExpression of the same type than self, with the new function as inner function
         string_expr = get_repr(other, ${o.precedence_level}) + ' ${o.pair_operator} ' + get_repr(self, ${o.precedence_level})
         return type(self)(fun=_${o.method_name}, precedence_level=${o.precedence_level}, str_expr=string_expr, root_var=self._root_var)
 
@@ -91,17 +107,19 @@ class _InputEvaluatorGenerated(StackableFunctionEvaluator):
         % elif o.unbound_method:
     ## --------unbound method---------------------
     def ${o.method_name}(self, *args):
-        """ Returns a new _InputEvaluator performing '${o.unbound_method.__name__}(<r>, *args)' on the result <r> of this evaluator's evaluation """
+        """ Returns a new _LambdaExpression performing '${o.unbound_method.__name__}(<r>, *args)' on the result <r> of this evaluator's evaluation """
         ## def _${o.method_name}(r, input, *args):
         ##     return ${o.unbound_method.__name__}(r, input, *args)
         ## return self.add_unbound_method_to_stack(_${o.method_name}, *args)
+        for other in args:
+            self.assert_has_same_root_var(other)
         def _${o.method_name}(input):
             # first evaluate the inner function
             r = self.evaluate(input)
             # then call the method
-            return ${o.unbound_method.__name__}(r, *args)
+            return ${o.unbound_method.__name__}(r, *[evaluate(other, input) for other in args])
 
-        # return a new InputEvaluator of the same type than self, with the new function as inner function
+        # return a new LambdaExpression 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
         string_expr = '${o.unbound_method.__name__}(' + get_repr(self, None) + ', ' + ', '.join([get_repr(arg, None) for arg in args]) + ')'
         return type(self)(fun=_${o.method_name}, precedence_level=PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF, 
@@ -111,15 +129,17 @@ class _InputEvaluatorGenerated(StackableFunctionEvaluator):
         % else:
     ## --------general case---------------------
     def ${o.method_name}(self, *args):
-        """ Returns a new _InputEvaluator performing '<r>.${o.method_name}(*args)' on the result <r> of this evaluator's evaluation """
+        """ Returns a new _LambdaExpression performing '<r>.${o.method_name}(*args)' on the result <r> of this evaluator's evaluation """
         # return self.add_bound_method_to_stack('${o.method_name}', *args)
+        for other in args:
+            self.assert_has_same_root_var(other)
         def _${o.method_name}(input):
             # first evaluate the inner function
             r = self.evaluate(input)
             # then call the method
-            return r.${o.method_name}(*args)
+            return r.${o.method_name}(*[evaluate(other, input) for other in args])
 
-        # return a new InputEvaluator of the same type than self, with the new function as inner function
+        # return a new LambdaExpression 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
         string_expr = get_repr(self, PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF) + '.${o.method_name}(' + ', '.join([get_repr(arg, None) for arg in args]) + ')'
         return type(self)(fun=_${o.method_name}, precedence_level=PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF, 
@@ -133,10 +153,10 @@ class _InputEvaluatorGenerated(StackableFunctionEvaluator):
     % for o in to_override_with_exception:
     def ${o.method_name}(self, *args):
         """
-        This magic method can not be used on an _InputEvaluator, because unfortunately python checks the
+        This magic method can not be used on an _LambdaExpression, because unfortunately python checks the
         result type and does not allow it to be a custom type.
         """
-        raise FunctionDefinitionError('${o.method_name} is not supported by _InputEvaluator, since python raises an'
+        raise FunctionDefinitionError('${o.method_name} is not supported by _LambdaExpression, since python raises an'
                                       ' error when its output is not directly an object of the type it expects.'
                                       'Please use the ${o.module_method_name}() method provided at mini_lambda package'
                                       ' level instead. If you did not use ${o.method_name} in your expression, you '
@@ -148,8 +168,8 @@ class _InputEvaluatorGenerated(StackableFunctionEvaluator):
 
 # ******* All replacement methods for the magic methods throwing exceptions ********
 % for o in to_override_with_exception:
-def ${o.module_method_name}(evaluator: _InputEvaluatorGenerated):
-    """ This is a replacement method for _InputEvaluator '${o.method_name}' magic method """
+def ${o.module_method_name}(evaluator: _LambdaExpressionGenerated):
+    """ This is a replacement method for _LambdaExpression '${o.method_name}' magic method """
     % if o.unbound_method:
     return evaluator.add_unbound_method_to_stack(${o.unbound_method.__name__})
     % else: