Lambda Calculus via C# (12) Church Numeral Comparison Operators

With the predicates defined in previous part, operators can be defined in _Numeral class. Once again, class does not exist in lambda calculus, but C# class provides a place to define operators, which greatly improve the readability.

1
public partial class _Numeral
2
{
3
    public static Boolean operator <=
4
        (_Numeral a, _Numeral b) => a.IsLessOrEqual(b);
5

6
    public static Boolean operator >=
7
        (_Numeral a, _Numeral b) => a.IsGreaterOrEqual(b);
8

9
    public static Boolean operator <
10
        (_Numeral a, _Numeral b) => a.IsLess(b);
11

12
    public static Boolean operator >
13
        (_Numeral a, _Numeral b) => a.IsGreater(b);
14

15
    public static Boolean operator ==
16
        (_Numeral a, _Numeral b) => a.AreEqual(b);
17

18
    public static Boolean operator !=
19
        (_Numeral a, _Numeral b) => a.AreNotEqual(b);
20
}

C# object equality#

This has nothing to do with lambda calculus and Church encoding. In C#, since == and != are customized, Object.Equals and Object.GetHashCode are required to be overridden too:

1
public partial class _Numeral
2
{
3
    public override int GetHashCode
4
        () => this._Unchurch().GetHashCode();
5

6
    public override bool Equals(object obj)
7
    {
8
        if (obj == null)
9
        {
10
            return false;
11
        }
12

13
        _Numeral numeral = obj as _Numeral;
14
        if ((object)numeral == null)
15
        {
16
            return false;
17
        }
18

19
        return this.AreEqual(numeral)._Unchurch();
20
    }
21
}

These code are all C# specific requirement:

GetHashCode just returns current Church Numeral’s corresponding System.UInt32’s hash code
Equals just applies the AreEqual predicate, and coverts the returned Church Boolean into System.Boolean.

Unit tests#

In the same (tedious) way as arithmetic operators:

1
[TestClass()]
2
public class ChurchPredicatesTests
3
{
4
    private static readonly _Numeral Zero = _Numeral.Zero;
5

6
    [TestMethod()]
7
    public void IsZeroTest()
8
    {
9
        Assert.AreEqual(0U == 0U, Zero.IsZero()._Unchurch());
10
        Assert.AreEqual(1U == 0U, 1U._Church().IsZero()._Unchurch());
11
        Assert.AreEqual(2U == 0U, 2U._Church().IsZero()._Unchurch());
12
        Assert.AreEqual(123U == 0U, 123U._Church().IsZero()._Unchurch());
13
    }
14

15
    [TestMethod()]
16
    public void IsLessOrEqualTest()
17
    {
18
        Assert.AreEqual(0U <= 0U, (Zero <= Zero)._Unchurch());
19
        Assert.AreEqual(1U <= 0U, (1U._Church() <= Zero)._Unchurch());
20
        Assert.AreEqual(2U <= 0U, (2U._Church() <= Zero)._Unchurch());
21
        Assert.AreEqual(123U <= 0U, (123U._Church() <= Zero)._Unchurch());
22
        Assert.AreEqual(0U <= 2U, (Zero <= 2U._Church())._Unchurch());
23
        Assert.AreEqual(1U <= 2U, (1U._Church() <= 2U._Church())._Unchurch());
24
        Assert.AreEqual(2U <= 2U, (2U._Church() <= 2U._Church())._Unchurch());
25
        Assert.AreEqual(123U <= 2U, (123U._Church() <= 2U._Church())._Unchurch());
26
        Assert.AreEqual(0U <= 124U, (Zero <= 124U._Church())._Unchurch());
27
        Assert.AreEqual(1U <= 124U, (1U._Church() <= 124U._Church())._Unchurch());
28
        Assert.AreEqual(2U <= 124U, (2U._Church() <= 124U._Church())._Unchurch());
29
        Assert.AreEqual(123U <= 124U, (123U._Church() <= 124U._Church())._Unchurch());
30
    }
31

32
    [TestMethod()]
33
    public void IsGreaterOrEqualTest()
34
    {
35
        Assert.AreEqual(0U >= 0U, (Zero >= Zero)._Unchurch());
36
        Assert.AreEqual(1U >= 0U, (1U._Church() >= Zero)._Unchurch());
37
        Assert.AreEqual(2U >= 0U, (2U._Church() >= Zero)._Unchurch());
38
        Assert.AreEqual(123U >= 0U, (123U._Church() >= Zero)._Unchurch());
39
        Assert.AreEqual(0U >= 2U, (Zero >= 2U._Church())._Unchurch());
40
        Assert.AreEqual(1U >= 2U, (1U._Church() >= 2U._Church())._Unchurch());
41
        Assert.AreEqual(2U >= 2U, (2U._Church() >= 2U._Church())._Unchurch());
42
        Assert.AreEqual(123U >= 2U, (123U._Church() >= 2U._Church())._Unchurch());
43
        Assert.AreEqual(0U >= 124U, (Zero >= 124U._Church())._Unchurch());
44
        Assert.AreEqual(1U >= 124U, (1U._Church() >= 124U._Church())._Unchurch());
45
        Assert.AreEqual(2U >= 124U, (2U._Church() >= 124U._Church())._Unchurch());
46
        Assert.AreEqual(123U >= 124U, (123U._Church() >= 124U._Church())._Unchurch());
47
    }
48

49
    [TestMethod()]
50
    public void IsLessTest()
51
    {
52
        Assert.AreEqual(0U < 0U, (Zero < Zero)._Unchurch());
53
        Assert.AreEqual(1U < 0U, (1U._Church() < Zero)._Unchurch());
54
        Assert.AreEqual(2U < 0U, (2U._Church() < Zero)._Unchurch());
55
        Assert.AreEqual(123U < 0U, (123U._Church() < Zero)._Unchurch());
56
        Assert.AreEqual(0U < 2U, (Zero < 2U._Church())._Unchurch());
57
        Assert.AreEqual(1U < 2U, (1U._Church() < 2U._Church())._Unchurch());
58
        Assert.AreEqual(2U < 2U, (2U._Church() < 2U._Church())._Unchurch());
59
        Assert.AreEqual(123U < 2U, (123U._Church() < 2U._Church())._Unchurch());
60
        Assert.AreEqual(0U < 124U, (Zero < 124U._Church())._Unchurch());
61
        Assert.AreEqual(1U < 124U, (1U._Church() < 124U._Church())._Unchurch());
62
        Assert.AreEqual(2U < 124U, (2U._Church() < 124U._Church())._Unchurch());
63
        Assert.AreEqual(123U < 124U, (123U._Church() < 124U._Church())._Unchurch());
64
    }
65

66
    [TestMethod()]
67
    public void IsGreaterTest()
68
    {
69
        Assert.AreEqual(0U > 0U, (Zero > Zero)._Unchurch());
70
        Assert.AreEqual(1U > 0U, (1U._Church() > Zero)._Unchurch());
71
        Assert.AreEqual(2U > 0U, (2U._Church() > Zero)._Unchurch());
72
        Assert.AreEqual(123U > 0U, (123U._Church() > Zero)._Unchurch());
73
        Assert.AreEqual(0U > 2U, (Zero > 2U._Church())._Unchurch());
74
        Assert.AreEqual(1U > 2U, (1U._Church() > 2U._Church())._Unchurch());
75
        Assert.AreEqual(2U > 2U, (2U._Church() > 2U._Church())._Unchurch());
76
        Assert.AreEqual(123U > 2U, (123U._Church() > 2U._Church())._Unchurch());
77
        Assert.AreEqual(0U > 124U, (Zero > 124U._Church())._Unchurch());
78
        Assert.AreEqual(1U > 124U, (1U._Church() > 124U._Church())._Unchurch());
79
        Assert.AreEqual(2U > 124U, (2U._Church() > 124U._Church())._Unchurch());
80
        Assert.AreEqual(123U > 124U, (123U._Church() > 124U._Church())._Unchurch());
81
    }
82

83
    [TestMethod()]
84
    public void IsEqualTest()
85
    {
86
        Assert.AreEqual(0U == 0U, (Zero == Zero)._Unchurch());
87
        Assert.AreEqual(1U == 0U, (1U._Church() == Zero)._Unchurch());
88
        Assert.AreEqual(2U == 0U, (2U._Church() == Zero)._Unchurch());
89
        Assert.AreEqual(123U == 0U, (123U._Church() == Zero)._Unchurch());
90
        Assert.AreEqual(0U == 2U, (Zero == 2U._Church())._Unchurch());
91
        Assert.AreEqual(1U == 2U, (1U._Church() == 2U._Church())._Unchurch());
92
        Assert.AreEqual(2U == 2U, (2U._Church() == 2U._Church())._Unchurch());
93
        Assert.AreEqual(123U == 2U, (123U._Church() == 2U._Church())._Unchurch());
94
        Assert.AreEqual(0U == 124U, (Zero == 124U._Church())._Unchurch());
95
        Assert.AreEqual(1U == 124U, (1U._Church() == 124U._Church())._Unchurch());
96
        Assert.AreEqual(2U == 124U, (2U._Church() == 124U._Church())._Unchurch());
97
        Assert.AreEqual(123U == 124U, (123U._Church() == 124U._Church())._Unchurch());
98
    }
99

100
    [TestMethod()]
101
    public void IsNotEqualTest()
102
    {
103
        Assert.AreEqual(0U != 0U, (Zero != Zero)._Unchurch());
104
        Assert.AreEqual(1U != 0U, (1U._Church() != Zero)._Unchurch());
105
        Assert.AreEqual(2U != 0U, (2U._Church() != Zero)._Unchurch());
106
        Assert.AreEqual(123U != 0U, (123U._Church() != Zero)._Unchurch());
107
        Assert.AreEqual(0U != 2U, (Zero != 2U._Church())._Unchurch());
108
        Assert.AreEqual(1U != 2U, (1U._Church() != 2U._Church())._Unchurch());
109
        Assert.AreEqual(2U != 2U, (2U._Church() != 2U._Church())._Unchurch());
110
        Assert.AreEqual(123U != 2U, (123U._Church() != 2U._Church())._Unchurch());
111
        Assert.AreEqual(0U != 124U, (Zero != 124U._Church())._Unchurch());
112
        Assert.AreEqual(1U != 124U, (1U._Church() != 124U._Church())._Unchurch());
113
        Assert.AreEqual(2U != 124U, (2U._Church() != 124U._Church())._Unchurch());
114
        Assert.AreEqual(123U != 124U, (123U._Church() != 124U._Church())._Unchurch());
115
    }
116
}