Lambda expressions now have a normal repr by default, and this can be disabled by using a flag. Fixes #12

Sylvain MARIE · Sylvain MARIE · commit 4e5c76ea8ec3 · 2019-04-12T14:39:18.000+02:00
diff --git a/code_generation/mini_lambda_methods_generation.py b/code_generation/mini_lambda_methods_generation.py
@@ -259,7 +259,7 @@ def define_what_needs_to_be_written():
     # .__repr__, .__str__, .__bytes__, .__format__,
     # __sizeof__
     to_override_with_exception.add(OverExc('__str__', unbound_method=str))
-    to_override_with_exception.add(OverExc('__repr__', unbound_method=repr))
+    # to_override_with_exception.add(OverExc('__repr__', unbound_method=repr))
     to_override_with_exception.add(OverExc('__bytes__', unbound_method=bytes))
     # this is a special case
     to_override_with_exception.add(OverExc('__format__', unbound_method=format))
diff --git a/code_generation/tpl_magic_methods.mako b/code_generation/tpl_magic_methods.mako
@@ -69,7 +69,8 @@ class _LambdaExpressionGenerated(_LambdaExpressionBase):
 
         # 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=root_var)
+        return type(self)(fun=_${o.method_name}, precedence_level=${o.precedence_level}, str_expr=string_expr,
+                          root_var=root_var, repr_on=self.repr_on)
 
     ## -----------------------------
             % else:
@@ -88,7 +89,8 @@ class _LambdaExpressionGenerated(_LambdaExpressionBase):
 
         # 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=root_var)
+        return type(self)(fun=_${o.method_name}, precedence_level=${o.precedence_level}, str_expr=string_expr,
+                          root_var=root_var, repr_on=self.repr_on)
 
     ## -----------------------------
             % endif
@@ -115,7 +117,7 @@ class _LambdaExpressionGenerated(_LambdaExpressionBase):
                        + ', '.join([arg_name + '=' + get_repr(arg, None) for arg_name, arg in kwargs.items()])
                        + ')')
         return type(self)(fun=_${o.method_name}, precedence_level=_PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF,
-                          str_expr=string_expr, root_var=root_var)
+                          str_expr=string_expr, root_var=root_var, repr_on=self.repr_on)
 
     ## -----------------------------
         % else:
@@ -139,7 +141,7 @@ class _LambdaExpressionGenerated(_LambdaExpressionBase):
                       + ', '.join([arg_name + '=' + get_repr(arg, None) for arg_name, arg in kwargs.items()]) \
                       + ')'
         return type(self)(fun=_${o.method_name}, precedence_level=_PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF,
-                          str_expr=string_expr, root_var=root_var)
+                          str_expr=string_expr, root_var=root_var, repr_on=self.repr_on)
 
     ## -----------------------------
         % endif
diff --git a/mini_lambda/base.py b/mini_lambda/base.py
@@ -48,15 +48,16 @@ class _LambdaExpressionBase(object):
      self._fun (res) by doing res.meth(*other_args)
     """
 
-    __slots__ = ['_fun', '_str_expr', '_root_var', '_precedence_level']
+    __slots__ = ['repr_on', '_fun', '_str_expr', '_root_var', '_precedence_level']
 
     def __init__(self,
                  str_expr=None,          # type: str
                  is_constant=False,      # type: bool
                  constant_value=None,    # type: Any
                  precedence_level=None,  # type: int
                  fun=None,               # type: Callable
-                 root_var=None
+                 root_var=None,
+                 repr_on=True            # type: bool
                  ):
         """
         Constructor with an optional nested evaluation function. If no argument is provided, the nested evaluation
@@ -70,6 +71,8 @@ def __init__(self,
         :param fun:
         :param root_var:
         """
+        self.repr_on = repr_on
+
         # case 1: constant
         if is_constant:
             if precedence_level is not None or fun is not None or root_var is not None:
@@ -131,6 +134,15 @@ def evaluate(self, arg):
         """
         return self._fun(arg)
 
+    def __repr__(self):
+        if self.repr_on:
+            return "<_LambdaExpression: %s>" % self.to_string()
+        else:
+            raise FunctionDefinitionError('__repr__ is not supported by this Lambda Expression. If you wish to '
+                                          'use `repr` in the lambda expression, use the replacement method `Repr`.'
+                                          'If you wish to enable repr again to see the expression in your IDE,'
+                                          'set the `repr_on` attribute to True')
+
     def to_string(self):
         """
         Returns a string representation of this InputEvaluator (Since str() does not work, it would return a new
diff --git a/mini_lambda/tests/test_mini_lambda.py b/mini_lambda/tests/test_mini_lambda.py
@@ -123,6 +123,8 @@ def test_evaluator_repr():
     s = InputVar('s', str)
 
     # the repr operator cannot be overloaded
+    assert repr(s) == '<_LambdaExpression: s>'
+    s.repr_on = False
     with pytest.raises(FunctionDefinitionError):
         repr(s)
 
