Further simplified: got rid of the useless inner make_lambda_friendly_method. Now Constant() is used all over the place, even for methods.

Author: smarie

mini_lambda/base.py

@@ -219,127 +219,18 @@ def constant(cls, value: T, name: str = None) -> Union[T, Any]:  # Any really me
 
         elif callable(value):
             # a function
-            return cls.make_lambda_friendly_method(value, name=name)
+            # If the provided method does not have a name then name is mandatory
+            if (not hasattr(value, '__name__') or value.__name__ == '<lambda>') and name is None:
+                raise ValueError('This method does not have a name (it is either a partial or a lambda) so you have to '
+                                 'provide one: the \'name\' argument is mandatory')
+
+            # return cls.make_lambda_friendly_method(value, name=name)
+            return cls(str_expr=name or value.__name__, is_constant=True, constant_value=value)
 
         else:
             # a true 'constant'
             return cls(str_expr=name or str(value), is_constant=True, constant_value=value)
 
-    @classmethod
-    def make_lambda_friendly_method(cls, method: Callable, name: str = None):
-        """
-        Utility method to transform any method whatever their signature (positional and/or keyword arguments,
-        variable-length included) into a method usable inside lambda expressions, even if some of the arguments are
-        expressions themselves.
-
-        In particular you may wish to convert:
-
-        * standard or user-defined functions. Note that by default the name appearing in the expression is func.__name__
-
-            ```python
-            from mini_lambda import x, _, make_lambda_friendly_method
-            from math import log
-
-            # transform standard function `log` into lambda-friendly function `Log`
-            Log = make_lambda_friendly_method(log)
-
-            # now you can use it in your lambda expressions
-            complex_identity = _( Log(10 ** x, 10) )
-            complex_identity(3.5)    # returns 3.5
-            print(complex_identity)  # "log(10 ** x, 10)"
-            ```
-
-        * anonymous functions such as lambdas and partial. In which case you HAVE to provide a name
-
-            ```python
-            from mini_lambda import x, _, make_lambda_friendly_method
-            from math import log
-
-            # ** partial function (to fix leftmost positional arguments and/or keyword arguments)
-            from functools import partial
-            is_superclass_of_bool = make_lambda_friendly_method(partial(issubclass, bool), name='is_superclass_of_bool')
-
-            # now you can use it in your lambda expressions
-            expr = _(is_superclass_of_bool(x))
-            expr(int)    # True
-            expr(str)    # False
-            print(expr)  # "is_superclass_of_bool(x)"
-
-            # ** lambda function
-            Log10 = make_lambda_friendly_method(lambda x: log(x, 10), name='log10')
-
-            # now you can use it in your lambda expressions
-            complex_identity = _(Log10(10 ** x))
-            complex_identity(3.5)    # 3.5
-            print(complex_identity)  # "log10(10 ** x)"
-            ```
-
-        * class functions. Note that by default the name appearing in the expression is func.__name__
-
-            ```python
-            from mini_lambda import x, _, make_lambda_friendly_method
-
-            # ** standard class function
-            StartsWith = make_lambda_friendly_method(str.startswith)
-
-            # now you can use it in your lambda expressions
-            str_tester = _(StartsWith('hello', 'el', x))
-            str_tester(0)      # False
-            str_tester(1)      # True
-            print(str_tester)  # "startswith('hello', 'el', x)"
-
-            # ** static and class functions
-            class Foo:
-                @staticmethod
-                def bar1(times, num, den):
-                    return times * num / den
-
-                @classmethod
-                def bar2(cls, times, num, den):
-                    return times * num / den
-
-            FooBar1 = make_lambda_friendly_method(Foo.bar1)
-            fun1 = _( FooBar1(x, den=x, num=1) )
-
-            FooBar2a = make_lambda_friendly_method(Foo.bar2)  # the `cls` argument is `Foo` and cant be changed
-            fun2a = _( FooBar2a(x, den=x, num=1) )
-
-            FooBar2b = make_lambda_friendly_method(Foo.bar2.__func__)  # the `cls` argument can be changed
-            fun2b = _( FooBar2b(Foo, x, den=x, num=1) )
-            ```
-
-            Note: although the above is valid, it is much more recommended to convert the whole class
-
-
-        :param method:
-        :param name: an optional name for the method when used to display the expressions. It is mandatory if the method
-        does not have a name, otherwise the default name is method.__name__
-        :return:
-        """
-
-        # If the provided method does not have a name then name is mandatory
-        if (not hasattr(method, '__name__') or method.__name__ == '<lambda>') and name is None:
-            raise ValueError('This method does not have a name (it is either a partial or a lambda) so you have to '
-                             'provide one: the \'name\' argument is mandatory')
-
-        # create a named method if a new name is provided
-        if name is not None:
-            # work on a copy to rename it
-            def new_method(*args, **kwargs):
-                return method(*args, **kwargs)
-
-            new_method.__name__ = name
-        else:
-            new_method = method
-
-        # construct the lambda-friendly method
-        def lambda_friendly_method(*args, **kwargs):
-            """ A replacement method for `method`, that returns a new expression corresponding to executing the inner
-            method with the provided arguments """
-            return cls._get_expression_for_method_with_args(new_method, *args, **kwargs)
-
-        return lambda_friendly_method
-
     @classmethod
     def _get_expression_for_method_with_args(cls, method, *args, **kwargs):
         """