Implementation of lists and convenient lambda functions

exec.txt

$ python report-s2-3.py
First(Tuple(true, false)): true
Second(Tuple(true, false)): false
(Cons 4 nil): [4]
x = (Cons 3 (Cons 2 (Cons 1 nil))): [3, 2, 1]
Head x: 3
Tail x: [2, 1]
Head(Tail x): 2
At(0 x): 3
At(1 x): 2
At(2 x): 1
EqNil(Nil): true
EqNil(Cons 1 Nil): false
Sum x: 6
AltSum x = Reduce(Plus 0 x): 6
Reduce(Mult 1 x): 6
Map (Mult 2) x: [6, 4, 2]

list.py

true = lambda t: lambda f: t
false = lambda t: lambda f: f

Not = lambda b: b(false)(true)
And = lambda a: lambda b: a(b)(false)
Or = lambda a: lambda b: Not(And(Not(a))(Not(b)))

Tuple = lambda m, n: lambda f: f(m)(n)
First = lambda tup: tup(lambda m: lambda n: m)
Second = lambda tup: tup(lambda m: lambda n: n)

Zero = lambda s: lambda z: z
One = lambda s: lambda z: s(z)
Two = lambda s: lambda z: s(s(z))

Succ = lambda n: lambda s: lambda z: s(n(s)(z))
Pred = lambda n: lambda s: lambda z: n(lambda m: lambda sd: sd(m(s)))(lambda sd: z)(lambda x: x)

Plus = lambda m: lambda n: lambda s: lambda z: m(s)(n(s)(z))
Mult = lambda m: lambda n: lambda s: n(m(s))
Minus = lambda m: lambda n: n(Pred)(m)
Exp = lambda m: lambda n: n(m)
EqZero = lambda n: n(lambda x: false)(true)

Head = First
Tail = Second
Nil = false # == Zero
EqNil = lambda s: s(lambda a: lambda b: lambda c: false)(true)
at_head = lambda i: lambda s: Head(s)
at_tail = lambda i: lambda s: At(Pred(i))(Tail(s))
At = lambda i: lambda s: EqZero(i)(at_head)(at_tail)(i)(s)

Cons = lambda x: lambda s: Tuple(x, s)
map_nil = lambda f: lambda s: Nil
map_not_nil = lambda f: lambda s: Cons(f(Head(s)))(Map(f)(Tail(s)))
Map = lambda f: lambda s: EqNil(s)(map_nil)(map_not_nil)(f)(s)

sum_nil = lambda s: Zero
sum_not_nil = lambda s: Plus(Head(s))(Sum(Tail(s)))
Sum = lambda s: EqNil(s)(sum_nil)(sum_not_nil)(s)

reduce_nil = lambda f: lambda init: lambda s: init
reduce_not_nil = lambda f: lambda init: lambda s: Reduce(f)(f(init)(Head(s)))(Tail(s))
Reduce = lambda f: lambda init: lambda s: EqNil(s)(reduce_nil)(reduce_not_nil)(f)(init)(s)

# sum using Reduce
AltSum = lambda s: Reduce(Plus)(Zero)(s)

def n(x):
    if x == 0:
        return Zero
    return Succ(n(x-1))

def to_str(lmb):
    return lmb("true")("false")

def to_int(lmb):
    if EqZero(lmb)(True)(False):
        return 0
    return 1 + to_int(Pred(lmb))

def to_list(s):
    return "[" + ", ".join(to_list_internal(s, [])) + "]"

def to_list_internal(s, l):
    try:
        if s(False)(True):
            return l
    except Exception:
        pass
    return to_list_internal(Second(s), l + [str(to_int(First(s)))])

x = Cons(n(3))(Cons(n(2))(Cons(n(1))(Nil)))
print("(Cons 4 nil): " + to_list(Cons(n(4))(Nil)))
print("x = (Cons 3 (Cons 2 (Cons 1 nil))): " + to_list(x))
print("Head x: " + str(to_int(Head(x))))
print("Tail x: " + to_list(Tail(x)))
print("Head(Tail x): " + str(to_int(Head(Tail(x)))))
print("At(0 x): " + str(to_int(At(Zero)(x))))
print("At(1 x): " + str(to_int(At(One)(x))))
print("At(2 x): " + str(to_int(At(Two)(x))))
print("EqNil(Nil): " + to_str(EqNil(Nil)))
print("EqNil(Cons 1 Nil): " + to_str(EqNil(Cons(One)(Nil))))
print("Sum x: " + str(to_int(Sum(x))))
print("AltSum x = Reduce(Plus 0 x): " + str(to_int(AltSum(x))))
print("Reduce(Mult 1 x): " + str(to_int(Reduce(Mult)(One)(x))))
print("Map (Mult 2) x: " + to_list(Map(Mult(n(2)))(x)))