added And and Or function

Author: semiversus

docs/usage.md

@@ -148,14 +148,15 @@ or through provided workarounds :
 
 ```python
 from mini_lambda import b, i, s, l, x
-from mini_lambda import Slice, Get, Not, In
+from mini_lambda import Slice, Get, Not, In, And
 from mini_lambda import Iter, Repr, Format, Len, Int, Any, Log, DDecimal
 from math import log
 from decimal import Decimal
 
 # boolean logic
 expr = (x > 1) and (x < 5)            # fails
 expr = (x > 1) & (x < 5)              # OK
+expr = And(x > 1, x < 5)              # OK
 # iterating
 expr = next(iter(s))                  # fails
 expr = next(Iter(s))                  # OK
@@ -207,7 +208,7 @@ As seen above, there are several types of defective behaviours:
 
  * built-in behaviours with special syntax (`not b`, `{'a': 1}[s]`, `x in y`, `any_(x)`). In which case an equivalent explicit method is provided: `Not`, `Get`, `Slice`, `In`, `Any`, `All`. In addition, equivalent methods `<expr>.contains()`, `<expr>.is_in()`, `<expr>.not_()`, `<expr>.any_()`, and `<expr>.all_()` are provided.
 
- * the shortcircuit boolean operators `and/or` can not be overriden and check the return type, so you should use `&` or `|` instead
+ * the shortcircuit boolean operators `and/or` can not be overridden and check the return type, so you should use either bitwise combination (`&` or `|`) or logical (`And` or `Or`) instead.
 
  * any other 'standard' methods, whether they are object constructors `Decimal()` or functions such as `log()`. We will see in the next section how you can convert any existing class or method to a lambda-friendly one. `mini_lambda` comes bundled with a few of them, namely all constants, functions and classes defined in `math` and `decimal` modules.
 

mini_lambda/main.py

@@ -428,6 +428,37 @@ def Not(expression: _LambdaExpression):
     return expression.not_()
 
 
+# Logical combinations 'and' and 'or'
+def _and(a, b):
+    return a and b
+
+
+def And(a, b):
+    """
+    Equivalent of 'a and b'.
+
+    :param a: left operand
+    :param b: right operand
+    :return:
+    """
+    return _LambdaExpression._get_expression_for_method_with_args(_and, a, b)
+
+
+def _or(a, b):
+    return a or b
+
+
+def Or(a, b):
+    """
+    Equivalent of 'a or b'.
+
+    :param a: left operand
+    :param b: right operand
+    :return:
+    """
+    return _LambdaExpression._get_expression_for_method_with_args(_or, a, b)
+
+
 # Special case: we do not want to use format() but type(value).format. So we override the generated method
 def Format(value, *args, **kwargs):
     """

mini_lambda/tests/test_mini_lambda.py

@@ -5,7 +5,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
+    Any, All, _, Slice, Get, Not, FunctionDefinitionError, Format, C, And, Or
 from math import cos, isfinite
 from numbers import Real
 
@@ -305,6 +305,41 @@ def test_evaluator_truth_testable_not():
     assert h(0)
     assert not h(5.2)
 
+
+def test_evaluator_logical_and():
+    """ Object: Tests that And function works """
+
+    x = InputVar('x', int)
+
+    with pytest.raises(FunctionDefinitionError):
+        x > 5 and x < 10
+    
+    r = And(x > 5, x < 10)
+    r = r.as_function()
+
+    assert not r(5)
+    assert r(6)
+    assert r(9)
+    assert not r(10)
+
+
+def test_evaluator_logical_or():
+    """ Object: Tests that Or function works """
+
+    x = InputVar('x', int)
+
+    with pytest.raises(FunctionDefinitionError):
+        x < 5 or x > 10
+    
+    r = Or(x < 5, x > 10)
+    r = r.as_function()
+
+    assert r(4)
+    assert not r(5)
+    assert not r(10)
+    assert r(11)
+
+
 # Object: .__getattr__
 def test_evaluator_attribute():
     """ Object: Tests that obj.foo_field works """