Two helper functions is_mini_lambda_expr and as_function. Fixes #13

Author: Sylvain MARIE

mini_lambda/__init__.py

@@ -1,18 +1,18 @@
 from mini_lambda.base import FunctionDefinitionError, evaluate, get_repr
 
 # this one only exports one private class, no need
-# from mini_lambda.generated import *
+# from mini_lambda.generated_magic import *
 
 from mini_lambda.main import _, L, F, C, Not, And, Or, Format, Get, In, Slice, InputVar, Constant, \
-    make_lambda_friendly, make_lambda_friendly_method, make_lambda_friendly_class
+    make_lambda_friendly, make_lambda_friendly_method, make_lambda_friendly_class, as_function, is_mini_lambda_expr
 
 __all__ = [
     # submodules
-    'base', 'generated_magic', 'generated_magic_replacements', 'main', 'symbols', 'vars',
+    'base', 'generated_magic_replacements', 'main', 'symbols', 'vars',  # generated_magic
     # symbols
     'FunctionDefinitionError', 'evaluate', 'get_repr',
     '_', 'L', 'F', 'C', 'InputVar', 'Constant', 'make_lambda_friendly', 'make_lambda_friendly_method',
-    'make_lambda_friendly_class',
+    'make_lambda_friendly_class', 'as_function', 'is_mini_lambda_expr',
     'Not', 'And', 'Or', 'Format', 'Get', 'In', 'Slice',
 ]
 

mini_lambda/main.py

@@ -2,7 +2,11 @@
 import sys
 
 try:  # python 3.5+
-    from typing import TypeVar, Union, Tuple, Callable, Type
+    from typing import TypeVar, Union, Tuple, Callable, Any
+    try: # old python 3.5
+        from typing import Type
+    except ImportError:
+        pass
     T = TypeVar('T')
 except ImportError:
     pass
@@ -705,3 +709,31 @@ def bar2(cls, times, num, den):
     :return:
     """
     return Constant(method, name)
+
+
+def is_mini_lambda_expr(f  # type: Union[LambdaExpression, Any]
+                        ):
+    """
+    Returns `True` if f is a mini-lambda expression, False otherwise
+
+    :param f:
+    :return:
+    """
+    try:
+        return issubclass(f.__class__, LambdaExpression)
+    except (AttributeError, TypeError):
+        return False
+
+
+def as_function(f  # type: Union[LambdaExpression, Any]
+                ):
+    """
+    Returns `f.as_function()` if f is a mini-lambda expression, returns f otherwise.
+
+    :param f:
+    :return:
+    """
+    if is_mini_lambda_expr(f):
+        return f.as_function()
+    else:
+        return f

mini_lambda/tests/test_mini_lambda.py

@@ -2,7 +2,7 @@
 import sys
 
 from mini_lambda import InputVar, Len, Str, Int, Repr, Bytes, Sizeof, Hash, Bool, Complex, Float, Oct, Iter, \
-    Any, All, _, Slice, Get, Not, FunctionDefinitionError, Format, C, And, Or, Round
+    Any, All, _, Slice, Get, Not, FunctionDefinitionError, Format, C, And, Or, Round, as_function, is_mini_lambda_expr
 from math import cos
 from numbers import Real
 
@@ -799,3 +799,38 @@ def test_constants_methods_can_be_combined():
 
     f = _(a(0) + a(0))
     assert f(None) == 2.
+
+
+def test_is_mini_lambda_expr():
+    """Tests that `is_mini_lambda_expr` works"""
+
+    from mini_lambda import x
+
+    # mini lambda: true
+    assert is_mini_lambda_expr(x ** 2)
+
+    # standard lambda: false
+    assert not is_mini_lambda_expr(lambda x: x)
+
+    # standard function: false
+    def foo():
+        pass
+    assert not is_mini_lambda_expr(foo)
+
+    # mini lambda as function: false
+    f = as_function(x ** 2)
+    assert not is_mini_lambda_expr(f)
+
+
+def test_as_function():
+    """Tests that `as_function` works"""
+
+    # it transforms mini-lambda exprs...
+    from mini_lambda import x
+    f = as_function(x ** 2)
+    assert f(2) == 4
+
+    # but supports normal functions too
+    def foo(x):
+        pass
+    assert as_function(foo) is foo