Renamed _LambdaExpression into LambdaExpression

Author: Sylvain MARIE

README.md

@@ -25,14 +25,14 @@ The generated code contains functions that generate functions when called, such
 
 ```python
 def __gt__(self, other):
-    """ Returns a new _LambdaExpression performing '<r> > other' on the result <r> of this evaluator's evaluation """
+    """ Returns a new LambdaExpression performing '<r> > other' on the result <r> of this evaluator's evaluation """
     def ___gt__(input):
         # first evaluate the inner function
         r = self.evaluate(input)
         # then call the method
         return r > evaluate(other, input)
 
-    # return a new _LambdaExpression 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
     return type(self)(___gt__)
 ```
 

code_generation/tpl_magic_methods.mako

@@ -37,7 +37,7 @@ class _LambdaExpressionGenerated(_LambdaExpressionBase):
         % if o.uni_operator:
     ## ----------unitary operator such as '-'-------------------
     def ${o.method_name}(self):
-        """ Returns a new _LambdaExpression 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})
@@ -56,7 +56,7 @@ class _LambdaExpressionGenerated(_LambdaExpressionBase):
             % if o.is_operator_left:
     ## --------pairwise operator - left---------------------
     def ${o.method_name}(self, other):
-        """ Returns a new _LambdaExpression 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})
@@ -76,7 +76,7 @@ class _LambdaExpressionGenerated(_LambdaExpressionBase):
             % else:
     ## --------pairwise operator - right ---------------------
     def ${o.method_name}(self, other):
-        """ Returns a new _LambdaExpression 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})
@@ -97,7 +97,7 @@ class _LambdaExpressionGenerated(_LambdaExpressionBase):
         % elif o.unbound_method:
     ## --------unbound method---------------------
     def ${o.method_name}(self, *args, **kwargs):
-        """ Returns a new _LambdaExpression performing '${o.unbound_method.__name__}(<r>, *args, **kwargs)' on the result <r> of this evaluator's evaluation """
+        """ Returns a new LambdaExpression performing '${o.unbound_method.__name__}(<r>, *args, **kwargs)' on the result <r> of this evaluator's evaluation """
         ## def _${o.method_name}(r, input, *args, **kwargs):
         ##     return ${o.unbound_method.__name__}(r, input, *args, **kwargs)
         ## return self.add_unbound_method_to_stack(_${o.method_name}, *args, **kwargs)
@@ -123,7 +123,7 @@ class _LambdaExpressionGenerated(_LambdaExpressionBase):
         % else:
     ## --------general case---------------------
     def ${o.method_name}(self, *args, **kwargs):
-        """ Returns a new _LambdaExpression performing '<r>.${o.method_name}(*args, **kwargs)' on the result <r> of this evaluator's evaluation """
+        """ Returns a new LambdaExpression performing '<r>.${o.method_name}(*args, **kwargs)' on the result <r> of this evaluator's evaluation """
         # return self.add_bound_method_to_stack('${o.method_name}', *args, **kwargs)
         root_var, _ = _get_root_var(self, *args, **kwargs)
         def _${o.method_name}(input):
@@ -151,7 +151,7 @@ class _LambdaExpressionGenerated(_LambdaExpressionBase):
     % for o in to_override_with_exception:
     def ${o.method_name}(self, *args, **kwargs):
         """
-        This magic method can not be used on an _LambdaExpression, 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 mini-lambda expressions, since python '

code_generation/tpl_magic_methods_replacements.mako

@@ -1,7 +1,7 @@
 # ----
 # This file is generated by mini_lambda_methods_generation.py - do not modify it !
 # ----
-from mini_lambda.main import _LambdaExpression
+from mini_lambda.main import LambdaExpression
 from sys import getsizeof
 
 % if generate_all:
@@ -22,12 +22,12 @@ __all__ = [
 
     % elif o.unbound_method:
 def ${o.module_method_name}(*args, **kwargs):
-    """ This is a replacement method for _LambdaExpression '${o.method_name}' magic method """
+    """ This is a replacement method for LambdaExpression '${o.method_name}' magic method """
     ## return evaluator.add_unbound_method_to_stack(${o.unbound_method.__name__})
-    return _LambdaExpression._get_expression_for_method_with_args(${o.unbound_method.__name__}, *args, **kwargs)
+    return LambdaExpression._get_expression_for_method_with_args(${o.unbound_method.__name__}, *args, **kwargs)
     % else:
-def ${o.module_method_name}(expr: _LambdaExpression, *args, **kwargs):
-    """ This is a replacement method for _LambdaExpression '${o.method_name}' magic method """
+def ${o.module_method_name}(expr: LambdaExpression, *args, **kwargs):
+    """ This is a replacement method for LambdaExpression '${o.method_name}' magic method """
     return expr.add_bound_method_to_stack('${o.method_name}', *args, **kwargs)
     % endif
 

docs/index.md

@@ -98,7 +98,7 @@ So now
 ```python
 >>> from mini_lambda import x
 >>> x ** 2
-<_LambdaExpression: x ** 2>
+<LambdaExpression: x ** 2>
 ```
 
 If you wish to bring back the old exception-raising behaviour, simply set the `repr_on` attribute of your expressions to `False`:
@@ -114,7 +114,7 @@ mini_lambda.base.FunctionDefinitionError: __repr__ is not supported by this Lamb
 ## Main features
 
  * More compact lambda expressions for single-variable functions
- * As close to python syntax as technically possible: the base type for lambda expressions in `mini_lambda`, `_LambdaExpression`, overrides all operators that can be overriden as of today in [python](https://docs.python.org/3/reference/datamodel.html). The remaining limits come from the language itself, for example chained comparisons and `and/or` are not supported as python casts the partial results to boolean to enable short-circuits. Details [here](./usage#lambda-expression-syntax).
+ * As close to python syntax as technically possible: the base type for lambda expressions in `mini_lambda`, `LambdaExpression`, overrides all operators that can be overriden as of today in [python](https://docs.python.org/3/reference/datamodel.html). The remaining limits come from the language itself, for example chained comparisons and `and/or` are not supported as python casts the partial results to boolean to enable short-circuits. Details [here](./usage#lambda-expression-syntax).
  * Printability: expressions can be turned to string representation in order to (hopefully) get interpretable messages more easily, for example when the expression is used in a [validation context](https://github.com/smarie/python-valid8)
 
 

docs/usage.md

@@ -41,7 +41,7 @@ The simplest lambda expression is the variable itself. It is implemented with th
 from mini_lambda import x
 
 # A variable is a lambda expression
-type(x)           # <class 'mini_lambda.main._LambdaExpression'>
+type(x)           # <class 'mini_lambda.main.LambdaExpression'>
 
 # Evaluating the lambda expression applies the identity function
 x.evaluate(1234)  # 1234
@@ -85,7 +85,7 @@ Indeed, `<expr>(input)` would create a new expression instead of evaluating it:
 result = my_first_expr(-1/2)
 
 # still an expression !
-type(result)        # <class 'mini_lambda.main._LambdaExpression'>
+type(result)        # <class 'mini_lambda.main.LambdaExpression'>
 result.to_string()  # "(2 * x + 1 > 0)(-0.5)"
 ```
 
@@ -176,7 +176,7 @@ expr = 'hello'[0:i]                   # fails
 expr = Get('hello', Slice(0, i))      # OK
 # representing: Repr/Str/Bytes/Sizeof/Hash
 # -- by default repr show the to_string()
-assert repr(l) == '<_LambdaExpression: l>'
+assert repr(l) == '<LambdaExpression: l>'
 # -- but you can disable it
 l.repr_on = False
 expr = repr(l)                        # fails

mini_lambda/base.py

@@ -136,7 +136,7 @@ def evaluate(self, arg):
 
     def __repr__(self):
         if self.repr_on:
-            return "<_LambdaExpression: %s>" % self.to_string()
+            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`.'