def test_rpow():
my_lambda = 3 ** X
assert is_λ(my_lambda)
assert_value(my_lambda(2), 9)
def test_augment_abstraction():
add3 = X + 3
add7 = add3 + 4
assert is_λ(add3)
assert is_λ(add7)
assert_value(add3(10), 13)
assert_value(add7(10), 17)
assert_value(add3(20), 23)
assert_value(add7(20), 27)
add3 *= 2
assert_value(add3(30), 66) # damn!
assert_value(add7(30), 37) # that one remains unchanged
def test_instantiation():
# delay the instantiation of a class: here, instantiate ~= lambda x: x()
instantiate = X()
assert is_λ(instantiate)
assert_value(instantiate(int), 0)
assert_value(instantiate(str), "")
def test_two_variables():
my_lambda = x1 + x2
assert is_λ(my_lambda)
assert_value(my_lambda(1, 5), 6)
def test_many_variables():
my_lambda = x1**5 + x2**4 + x3**3 + x4**2 + x5
assert is_λ(my_lambda)
assert_value(my_lambda(1, 2, 3, 4, 5), 1 + 2**4 + 3**3 + 4**2 + 5)
def test_logic_or():
my_lambda = or_(X, 4)
assert is_λ(my_lambda)
assert_value(my_lambda(0), 4)
assert_value(my_lambda(1), 1)
assert_value(my_lambda(-3), -3)
assert_value(my_lambda(""), 4)
assert_value(my_lambda("abc"), "abc")
assert_value(my_lambda([]), 4)
assert_value(my_lambda([0]), [0])
def test_identity():
identity = X
assert is_λ(identity)
assert_value(identity(int), int)
assert_value(identity(42), 42)
def test_multiply():
# delay the application of a usual infix operator
my_lambda = X * 4
assert is_λ(my_lambda)
assert_value(my_lambda(3), 12)
def test_power():
# delay the application of another usual infix operator
my_lambda = X**3
assert is_λ(my_lambda)
assert_value(my_lambda(2), 8)
def test_ror():
my_lambda = 3 | X
assert is_λ(my_lambda)
assert_value(my_lambda(6), 7)
def test_rxor():
my_lambda = 3 ^ X
assert is_λ(my_lambda)
assert_value(my_lambda(6), 5)
def test_rand():
my_lambda = 3 & X
assert is_λ(my_lambda)
assert_value(my_lambda(2), 2)
def test_rrshift():
my_lambda = 12 >> X
assert is_λ(my_lambda)
assert_value(my_lambda(2), 3)
def test_rlshift():
my_lambda = 3 << X
assert is_λ(my_lambda)
assert_value(my_lambda(2), 12)
def test_getattr():
get_imag = λ(getattr)(X, 'imag')
assert is_λ(get_imag)
assert_value(get_imag(complex(14, 42)), 42)
with raises(AttributeError):
get_imag('foo')
get_attr = λ(getattr)(42, X)
assert is_λ(get_attr)
assert_value(get_attr('__str__')(), '42')
with raises(AttributeError):
get_attr('foo')
my_getattr = λ(getattr)(x1, x2)
assert is_λ(my_getattr)
assert_value(my_getattr(14, '__str__')(), '14')
with raises(AttributeError):
my_getattr(14, 'foo')
my_getattr_with_default = λ(getattr)(x1, x2, x3)
assert is_λ(my_getattr_with_default)
assert_value(my_getattr_with_default(15, '__str__', int)(), '15')
assert_value(my_getattr_with_default(16, 'foo', int)(), 0)
assert_value(my_getattr_with_default(17, 'foo', 1.4), 1.4)
def test_getitem():
my_lambda = X["abc"]
assert is_λ(my_lambda)
assert_value(my_lambda({"abc": "Foo"}), "Foo")
def test_logic_and():
my_lambda = and_(X, 4)
assert is_λ(my_lambda)
assert_value(my_lambda(0), 0)
assert_value(my_lambda(1), 4)
assert_value(my_lambda(-3), 4)
assert_value(my_lambda(""), "")
assert_value(my_lambda("abc"), 4)
assert_value(my_lambda([]), [])
assert_value(my_lambda([0]), 4)
def test_getslice():
# it's just a particular case of `getitem`, really (with a "slice" as argument)
my_lambda = X[1:3]
assert_value(my_lambda("abcdefg"), "bc")
def test_ternary_logic():
_bach = if_(X % 2 == 0, X / 2, X * 3 + 1)
assert_value(_bach(2), 1)
assert_value(_bach(42), 21)
assert_value(_bach(21), 64)
def test_still_functional_builtins():
assert_value(abs(-42), 42)
assert_value(pow(2, 3), 8)
def test_hard_use_case():
my_lambda = λ(len)(X["abc"][5:])
assert is_λ(my_lambda)
assert_value(my_lambda({"abc": "24-character-long-string"}), 24 - 5)
def test_abs():
my_lambda = abs(X)
assert is_λ(my_lambda)
assert_value(my_lambda(-12), 12)
assert_value(my_lambda(13), 13)
def test_two_variables_harder():
my_lambda = (x1 + 4) * x2 + 7
assert is_λ(my_lambda)
assert_value(my_lambda(3, 5), 42)
def test_bit_and():
my_lambda = X & 2
assert is_λ(my_lambda)
assert_value(my_lambda(0), 0)
assert_value(my_lambda(1), 0)
assert_value(my_lambda(2), 2)
assert_value(my_lambda(3), 2)
assert_value(my_lambda(4), 0)
assert_value(my_lambda(6), 2)
def test_multiple_var_usage():
my_lambda = x1**2 + x2 + x1 * 4
assert is_λ(my_lambda)
assert_value(my_lambda(3, 7), 28)
my_lambda += x2**3 # it really is the same `x2` than before
assert_value(my_lambda(-2, 3), 26)
def test_bit_shift():
my_lambda = X << 2
assert is_λ(my_lambda)
assert_value(my_lambda(0), 0)
assert_value(my_lambda(1), 4)
assert_value(my_lambda(3), 12)
def test_property():
# delay the read of an property: here, get_imaginary_part ~= lambda x: x.imag
get_imaginary_part = X.imag
assert is_λ(get_imaginary_part)
assert_value(get_imaginary_part(complex(42, 51)), 51)
def test_bit_flip():
my_lambda = ~X
assert is_λ(my_lambda)
assert_value(my_lambda(0), -1)
assert_value(my_lambda(1), -2)
assert_value(my_lambda(3), -4)
def assert_list(it, ref_list):
chal_list = list(it)
assert len(chal_list) == len(ref_list), "%s != %s" % (chal_list,
ref_list)
for a, b in zip(chal_list, ref_list):
assert_value(a, b)
def test_radd():
my_lambda = 3 + X
assert is_λ(my_lambda)
assert_value(my_lambda(2), 5)
