lambda_calculus 1.3.0

A simple implementation of the untyped lambda calculus
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344

#![cfg(not(feature = "no_church"))]

#[macro_use]
extern crate lambda_calculus as lambda;

use lambda::*;
use lambda::church::numerals::*;
use lambda::combinators::c;

#[test]
fn church_successor() {
    assert_eq!(beta(app!(succ(), 0.into()), NOR, 0, false), 1.into());
    assert_eq!(beta(app!(succ(), 1.into()), NOR, 0, false), 2.into());
    assert_eq!(beta(app!(succ(), 2.into()), NOR, 0, false), 3.into());

    assert_eq!(beta(app!(succ(), 0.into()), HNO, 0, false), 1.into());
    assert_eq!(beta(app!(succ(), 1.into()), HNO, 0, false), 2.into());
    assert_eq!(beta(app!(succ(), 2.into()), HNO, 0, false), 3.into());

    assert_eq!(beta(app!(succ(), 0.into()), APP, 0, false), 1.into());
    assert_eq!(beta(app!(succ(), 1.into()), APP, 0, false), 2.into());
    assert_eq!(beta(app!(succ(), 2.into()), APP, 0, false), 3.into());

    assert_eq!(beta(app!(succ(), 0.into()), HAP, 0, false), 1.into());
    assert_eq!(beta(app!(succ(), 1.into()), HAP, 0, false), 2.into());
    assert_eq!(beta(app!(succ(), 2.into()), HAP, 0, false), 3.into());
}

#[test]
fn church_predecessor() {
    assert_eq!(beta(app!(pred(), 0.into()), NOR, 0, false), 0.into());
    assert_eq!(beta(app!(pred(), 1.into()), NOR, 0, false), 0.into());
    assert_eq!(beta(app!(pred(), 5.into()), NOR, 0, false), 4.into());

    assert_eq!(beta(app!(pred(), 0.into()), HNO, 0, false), 0.into());
    assert_eq!(beta(app!(pred(), 1.into()), HNO, 0, false), 0.into());
    assert_eq!(beta(app!(pred(), 5.into()), HNO, 0, false), 4.into());

    assert_eq!(beta(app!(pred(), 0.into()), APP, 0, false), 0.into());
    assert_eq!(beta(app!(pred(), 1.into()), APP, 0, false), 0.into());
    assert_eq!(beta(app!(pred(), 5.into()), APP, 0, false), 4.into());

    assert_eq!(beta(app!(pred(), 0.into()), HAP, 0, false), 0.into());
    assert_eq!(beta(app!(pred(), 1.into()), HAP, 0, false), 0.into());
    assert_eq!(beta(app!(pred(), 5.into()), HAP, 0, false), 4.into());
}

#[test]
fn church_plus_sub_equivalents() {
    /* PLUS 1 → SUCC & C SUB 1 → PRED */
    assert_eq!(beta(app!(    plus(), 1.into()), NOR, 0, false), succ());
    assert_eq!(beta(app!(c(), sub(), 1.into()), NOR, 0, false), pred());

    assert_eq!(beta(app!(    plus(), 1.into()), HNO, 0, false), succ());
    assert_eq!(beta(app!(c(), sub(), 1.into()), HNO, 0, false), pred());

    assert_eq!(beta(app!(    plus(), 1.into()), APP, 0, false), succ());
    assert_eq!(beta(app!(c(), sub(), 1.into()), APP, 0, false), pred());

    assert_eq!(beta(app!(    plus(), 1.into()), HAP, 0, false), succ());
    assert_eq!(beta(app!(c(), sub(), 1.into()), HAP, 0, false), pred());
}

#[test]
fn church_multiplication() {
    assert_eq!(beta(app!(mult(), 3.into(), 4.into()), NOR, 0, false), 12.into());
    assert_eq!(beta(app!(mult(), 1.into(), 3.into()), NOR, 0, false),  3.into());
    assert_eq!(beta(app!(mult(), 3.into(), 1.into()), NOR, 0, false),  3.into());
    assert_eq!(beta(app!(mult(), 5.into(), 0.into()), NOR, 0, false),  0.into());
    assert_eq!(beta(app!(mult(), 0.into(), 5.into()), NOR, 0, false),  0.into());

    assert_eq!(beta(app!(mult(), 3.into(), 4.into()), HNO, 0, false), 12.into());
    assert_eq!(beta(app!(mult(), 1.into(), 3.into()), HNO, 0, false),  3.into());
    assert_eq!(beta(app!(mult(), 3.into(), 1.into()), HNO, 0, false),  3.into());
    assert_eq!(beta(app!(mult(), 5.into(), 0.into()), HNO, 0, false),  0.into());
    assert_eq!(beta(app!(mult(), 0.into(), 5.into()), HNO, 0, false),  0.into());

    assert_eq!(beta(app!(mult(), 3.into(), 4.into()), APP, 0, false), 12.into());
    assert_eq!(beta(app!(mult(), 1.into(), 3.into()), APP, 0, false),  3.into());
    assert_eq!(beta(app!(mult(), 3.into(), 1.into()), APP, 0, false),  3.into());
    assert_eq!(beta(app!(mult(), 5.into(), 0.into()), APP, 0, false),  0.into());
    assert_eq!(beta(app!(mult(), 0.into(), 5.into()), APP, 0, false),  0.into());

    assert_eq!(beta(app!(mult(), 3.into(), 4.into()), HAP, 0, false), 12.into());
    assert_eq!(beta(app!(mult(), 1.into(), 3.into()), HAP, 0, false),  3.into());
    assert_eq!(beta(app!(mult(), 3.into(), 1.into()), HAP, 0, false),  3.into());
    assert_eq!(beta(app!(mult(), 5.into(), 0.into()), HAP, 0, false),  0.into());
    assert_eq!(beta(app!(mult(), 0.into(), 5.into()), HAP, 0, false),  0.into());
}

#[test]
fn church_exponentiation() {
    assert_eq!(beta(app!(pow(), 2.into(), 4.into()), NOR, 0, false), 16.into());
    assert_eq!(beta(app!(pow(), 1.into(), 3.into()), NOR, 0, false),  1.into());
    assert_eq!(beta(app!(pow(), 3.into(), 1.into()), NOR, 0, false),  3.into());
    assert_eq!(beta(app!(pow(), 5.into(), 0.into()), NOR, 0, false),  1.into());
    assert_eq!(beta(app!(pow(), 0.into(), 5.into()), NOR, 0, false),  0.into());

    assert_eq!(beta(app!(pow(), 2.into(), 4.into()), HNO, 0, false), 16.into());
    assert_eq!(beta(app!(pow(), 1.into(), 3.into()), HNO, 0, false),  1.into());
    assert_eq!(beta(app!(pow(), 3.into(), 1.into()), HNO, 0, false),  3.into());
    assert_eq!(beta(app!(pow(), 5.into(), 0.into()), HNO, 0, false),  1.into());
    assert_eq!(beta(app!(pow(), 0.into(), 5.into()), HNO, 0, false),  0.into());

    assert_eq!(beta(app!(pow(), 2.into(), 4.into()), APP, 0, false), 16.into());
    assert_eq!(beta(app!(pow(), 1.into(), 3.into()), APP, 0, false),  1.into());
    assert_eq!(beta(app!(pow(), 3.into(), 1.into()), APP, 0, false),  3.into());
    assert_eq!(beta(app!(pow(), 5.into(), 0.into()), APP, 0, false),  1.into());
    assert_eq!(beta(app!(pow(), 0.into(), 5.into()), APP, 0, false),  0.into());

    assert_eq!(beta(app!(pow(), 2.into(), 4.into()), HAP, 0, false), 16.into());
    assert_eq!(beta(app!(pow(), 1.into(), 3.into()), HAP, 0, false),  1.into());
    assert_eq!(beta(app!(pow(), 3.into(), 1.into()), HAP, 0, false),  3.into());
    assert_eq!(beta(app!(pow(), 5.into(), 0.into()), HAP, 0, false),  1.into());
    assert_eq!(beta(app!(pow(), 0.into(), 5.into()), HAP, 0, false),  0.into());
}

#[test]
fn church_division() {
    assert_eq!(beta(app!(div(), 2.into(), 2.into()), NOR, 0, false), (1.into(), 0.into()).into());
    assert_eq!(beta(app!(div(), 3.into(), 2.into()), NOR, 0, false), (1.into(), 1.into()).into());
    assert_eq!(beta(app!(div(), 5.into(), 2.into()), NOR, 0, false), (2.into(), 1.into()).into());
    assert_eq!(beta(app!(div(), 2.into(), 1.into()), NOR, 0, false), (2.into(), 0.into()).into());
    assert_eq!(beta(app!(div(), 0.into(), 3.into()), NOR, 0, false), (0.into(), 0.into()).into());
 // assert_eq!(beta(app!(div(), 1.into(), 0.into()), NOR, 0, false), ); division by 0 hangs

    assert_eq!(beta(app!(div(), 2.into(), 2.into()), HNO, 0, false), (1.into(), 0.into()).into());
    assert_eq!(beta(app!(div(), 3.into(), 2.into()), HNO, 0, false), (1.into(), 1.into()).into());
    assert_eq!(beta(app!(div(), 5.into(), 2.into()), HNO, 0, false), (2.into(), 1.into()).into());
    assert_eq!(beta(app!(div(), 2.into(), 1.into()), HNO, 0, false), (2.into(), 0.into()).into());
    assert_eq!(beta(app!(div(), 0.into(), 3.into()), HNO, 0, false), (0.into(), 0.into()).into());

    assert_eq!(beta(app!(div(), 2.into(), 2.into()), HAP, 0, false), (1.into(), 0.into()).into());
    assert_eq!(beta(app!(div(), 3.into(), 2.into()), HAP, 0, false), (1.into(), 1.into()).into());
    assert_eq!(beta(app!(div(), 5.into(), 2.into()), HAP, 0, false), (2.into(), 1.into()).into());
    assert_eq!(beta(app!(div(), 2.into(), 1.into()), HAP, 0, false), (2.into(), 0.into()).into());
    assert_eq!(beta(app!(div(), 0.into(), 3.into()), HAP, 0, false), (0.into(), 0.into()).into());
}

#[test]
fn church_quotient() {
    assert_eq!(beta(app!(quot(), 2.into(), 2.into()), NOR, 0, false), 1.into());
    assert_eq!(beta(app!(quot(), 3.into(), 2.into()), NOR, 0, false), 1.into());
    assert_eq!(beta(app!(quot(), 5.into(), 2.into()), NOR, 0, false), 2.into());
    assert_eq!(beta(app!(quot(), 2.into(), 1.into()), NOR, 0, false), 2.into());
    assert_eq!(beta(app!(quot(), 0.into(), 3.into()), NOR, 0, false), 0.into());
//  assert_eq!(beta(app!(quot(), 1.into(), 0.into()), NOR, 0, false), ); division by 0 hangs

    assert_eq!(beta(app!(quot(), 2.into(), 2.into()), HNO, 0, false), 1.into());
    assert_eq!(beta(app!(quot(), 3.into(), 2.into()), HNO, 0, false), 1.into());
    assert_eq!(beta(app!(quot(), 5.into(), 2.into()), HNO, 0, false), 2.into());
    assert_eq!(beta(app!(quot(), 2.into(), 1.into()), HNO, 0, false), 2.into());
    assert_eq!(beta(app!(quot(), 0.into(), 3.into()), HNO, 0, false), 0.into());

    assert_eq!(beta(app!(quot(), 2.into(), 2.into()), HAP, 0, false), 1.into());
    assert_eq!(beta(app!(quot(), 3.into(), 2.into()), HAP, 0, false), 1.into());
    assert_eq!(beta(app!(quot(), 5.into(), 2.into()), HAP, 0, false), 2.into());
    assert_eq!(beta(app!(quot(), 2.into(), 1.into()), HAP, 0, false), 2.into());
    assert_eq!(beta(app!(quot(), 0.into(), 3.into()), HAP, 0, false), 0.into());
}

#[test]
fn church_remainder() {
    assert_eq!(beta(app!(rem(), 2.into(), 2.into()), NOR, 0, false), 0.into());
    assert_eq!(beta(app!(rem(), 3.into(), 2.into()), NOR, 0, false), 1.into());
    assert_eq!(beta(app!(rem(), 2.into(), 5.into()), NOR, 0, false), 2.into());
    assert_eq!(beta(app!(rem(), 2.into(), 1.into()), NOR, 0, false), 0.into());
    assert_eq!(beta(app!(rem(), 0.into(), 3.into()), NOR, 0, false), 0.into());
 // assert_eq!(beta(app!(rem(), 1.into(), 0.into()), NOR, 0, false), ); division by 0 hangs

    assert_eq!(beta(app!(rem(), 2.into(), 2.into()), HNO, 0, false), 0.into());
    assert_eq!(beta(app!(rem(), 3.into(), 2.into()), HNO, 0, false), 1.into());
    assert_eq!(beta(app!(rem(), 2.into(), 5.into()), HNO, 0, false), 2.into());
    assert_eq!(beta(app!(rem(), 2.into(), 1.into()), HNO, 0, false), 0.into());
    assert_eq!(beta(app!(rem(), 0.into(), 3.into()), HNO, 0, false), 0.into());

    assert_eq!(beta(app!(rem(), 2.into(), 2.into()), HAP, 0, false), 0.into());
    assert_eq!(beta(app!(rem(), 3.into(), 2.into()), HAP, 0, false), 1.into());
    assert_eq!(beta(app!(rem(), 2.into(), 5.into()), HAP, 0, false), 2.into());
    assert_eq!(beta(app!(rem(), 2.into(), 1.into()), HAP, 0, false), 0.into());
    assert_eq!(beta(app!(rem(), 0.into(), 3.into()), HAP, 0, false), 0.into());
}

#[test]
fn church_factorial() {
    assert_eq!(beta(app!(fac(), 0.into()), NOR, 0, false), 1.into());
    assert_eq!(beta(app!(fac(), 1.into()), NOR, 0, false), 1.into());
    assert_eq!(beta(app!(fac(), 2.into()), NOR, 0, false), 2.into());
    assert_eq!(beta(app!(fac(), 3.into()), NOR, 0, false), 6.into());

    assert_eq!(beta(app!(fac(), 0.into()), HNO, 0, false), 1.into());
    assert_eq!(beta(app!(fac(), 1.into()), HNO, 0, false), 1.into());
    assert_eq!(beta(app!(fac(), 2.into()), HNO, 0, false), 2.into());
    assert_eq!(beta(app!(fac(), 3.into()), HNO, 0, false), 6.into());

    assert_eq!(beta(app!(fac(), 0.into()), HAP, 0, false), 1.into());
    assert_eq!(beta(app!(fac(), 1.into()), HAP, 0, false), 1.into());
    assert_eq!(beta(app!(fac(), 2.into()), HAP, 0, false), 2.into());
    assert_eq!(beta(app!(fac(), 3.into()), HAP, 0, false), 6.into());
}

#[test]
fn church_min() {
    assert_eq!(beta(app!(min(), 0.into(), 0.into()), NOR, 0, false), 0.into());
    assert_eq!(beta(app!(min(), 4.into(), 4.into()), NOR, 0, false), 4.into());
    assert_eq!(beta(app!(min(), 2.into(), 3.into()), NOR, 0, false), 2.into());
    assert_eq!(beta(app!(min(), 5.into(), 3.into()), NOR, 0, false), 3.into());
    assert_eq!(beta(app!(min(), 0.into(), 1.into()), NOR, 0, false), 0.into());

    assert_eq!(beta(app!(min(), 0.into(), 0.into()), HNO, 0, false), 0.into());
    assert_eq!(beta(app!(min(), 4.into(), 4.into()), HNO, 0, false), 4.into());
    assert_eq!(beta(app!(min(), 2.into(), 3.into()), HNO, 0, false), 2.into());
    assert_eq!(beta(app!(min(), 5.into(), 3.into()), HNO, 0, false), 3.into());
    assert_eq!(beta(app!(min(), 0.into(), 1.into()), HNO, 0, false), 0.into());

    assert_eq!(beta(app!(min(), 0.into(), 0.into()), HAP, 0, false), 0.into());
    assert_eq!(beta(app!(min(), 4.into(), 4.into()), HAP, 0, false), 4.into());
    assert_eq!(beta(app!(min(), 2.into(), 3.into()), HAP, 0, false), 2.into());
    assert_eq!(beta(app!(min(), 5.into(), 3.into()), HAP, 0, false), 3.into());
    assert_eq!(beta(app!(min(), 0.into(), 1.into()), HAP, 0, false), 0.into());
}

#[test]
fn church_max() {
    assert_eq!(beta(app!(max(), 0.into(), 0.into()), NOR, 0, false), 0.into());
    assert_eq!(beta(app!(max(), 4.into(), 4.into()), NOR, 0, false), 4.into());
    assert_eq!(beta(app!(max(), 2.into(), 3.into()), NOR, 0, false), 3.into());
    assert_eq!(beta(app!(max(), 5.into(), 3.into()), NOR, 0, false), 5.into());
    assert_eq!(beta(app!(max(), 0.into(), 1.into()), NOR, 0, false), 1.into());

    assert_eq!(beta(app!(max(), 0.into(), 0.into()), HNO, 0, false), 0.into());
    assert_eq!(beta(app!(max(), 4.into(), 4.into()), HNO, 0, false), 4.into());
    assert_eq!(beta(app!(max(), 2.into(), 3.into()), HNO, 0, false), 3.into());
    assert_eq!(beta(app!(max(), 5.into(), 3.into()), HNO, 0, false), 5.into());
    assert_eq!(beta(app!(max(), 0.into(), 1.into()), HNO, 0, false), 1.into());

    assert_eq!(beta(app!(max(), 0.into(), 0.into()), HAP, 0, false), 0.into());
    assert_eq!(beta(app!(max(), 4.into(), 4.into()), HAP, 0, false), 4.into());
    assert_eq!(beta(app!(max(), 2.into(), 3.into()), HAP, 0, false), 3.into());
    assert_eq!(beta(app!(max(), 5.into(), 3.into()), HAP, 0, false), 5.into());
    assert_eq!(beta(app!(max(), 0.into(), 1.into()), HAP, 0, false), 1.into());
}

#[test]
fn church_lshift() {
     assert_eq!(beta(app!(lshift(), 0.into(), 2.into()), NOR, 0, false), 0.into());
     assert_eq!(beta(app!(lshift(), 1.into(), 0.into()), NOR, 0, false), 1.into());
     assert_eq!(beta(app!(lshift(), 2.into(), 0.into()), NOR, 0, false), 2.into());
     assert_eq!(beta(app!(lshift(), 2.into(), 2.into()), NOR, 0, false), 8.into());
     assert_eq!(beta(app!(lshift(), 3.into(), 2.into()), NOR, 0, false), 12.into());
     assert_eq!(beta(app!(lshift(), 2.into(), 3.into()), NOR, 0, false), 16.into());
     assert_eq!(beta(app!(lshift(), 5.into(), 1.into()), NOR, 0, false), 10.into());

     assert_eq!(beta(app!(lshift(), 0.into(), 2.into()), HNO, 0, false), 0.into());
     assert_eq!(beta(app!(lshift(), 1.into(), 0.into()), HNO, 0, false), 1.into());
     assert_eq!(beta(app!(lshift(), 2.into(), 0.into()), HNO, 0, false), 2.into());
     assert_eq!(beta(app!(lshift(), 2.into(), 2.into()), HNO, 0, false), 8.into());
     assert_eq!(beta(app!(lshift(), 3.into(), 2.into()), HNO, 0, false), 12.into());
     assert_eq!(beta(app!(lshift(), 2.into(), 3.into()), HNO, 0, false), 16.into());
     assert_eq!(beta(app!(lshift(), 5.into(), 1.into()), HNO, 0, false), 10.into());

     assert_eq!(beta(app!(lshift(), 0.into(), 2.into()), HAP, 0, false), 0.into());
     assert_eq!(beta(app!(lshift(), 1.into(), 0.into()), HAP, 0, false), 1.into());
     assert_eq!(beta(app!(lshift(), 2.into(), 0.into()), HAP, 0, false), 2.into());
     assert_eq!(beta(app!(lshift(), 2.into(), 2.into()), HAP, 0, false), 8.into());
     assert_eq!(beta(app!(lshift(), 3.into(), 2.into()), HAP, 0, false), 12.into());
     assert_eq!(beta(app!(lshift(), 2.into(), 3.into()), HAP, 0, false), 16.into());
     assert_eq!(beta(app!(lshift(), 5.into(), 1.into()), HAP, 0, false), 10.into());
}

#[test]
fn church_rshift() {
     assert_eq!(beta(app!(rshift(), 1.into(), 0.into()), NOR, 0, false), 1.into());
     assert_eq!(beta(app!(rshift(), 2.into(), 0.into()), NOR, 0, false), 2.into());
     assert_eq!(beta(app!(rshift(), 0.into(), 2.into()), NOR, 0, false), 0.into());
     assert_eq!(beta(app!(rshift(), 2.into(), 1.into()), NOR, 0, false), 1.into());
     assert_eq!(beta(app!(rshift(), 2.into(), 2.into()), NOR, 0, false), 0.into());
     assert_eq!(beta(app!(rshift(), 5.into(), 1.into()), NOR, 0, false), 2.into());
     assert_eq!(beta(app!(rshift(), 9.into(), 1.into()), NOR, 0, false), 4.into());
     assert_eq!(beta(app!(rshift(), 9.into(), 2.into()), NOR, 0, false), 2.into());
     assert_eq!(beta(app!(rshift(), 7.into(), 1.into()), NOR, 0, false), 3.into());

     assert_eq!(beta(app!(rshift(), 1.into(), 0.into()), HNO, 0, false), 1.into());
     assert_eq!(beta(app!(rshift(), 2.into(), 0.into()), HNO, 0, false), 2.into());
     assert_eq!(beta(app!(rshift(), 0.into(), 2.into()), HNO, 0, false), 0.into());
     assert_eq!(beta(app!(rshift(), 2.into(), 1.into()), HNO, 0, false), 1.into());
     assert_eq!(beta(app!(rshift(), 2.into(), 2.into()), HNO, 0, false), 0.into());
     assert_eq!(beta(app!(rshift(), 5.into(), 1.into()), HNO, 0, false), 2.into());
     assert_eq!(beta(app!(rshift(), 9.into(), 1.into()), HNO, 0, false), 4.into());
     assert_eq!(beta(app!(rshift(), 9.into(), 2.into()), HNO, 0, false), 2.into());
     assert_eq!(beta(app!(rshift(), 7.into(), 1.into()), HNO, 0, false), 3.into());

     assert_eq!(beta(app!(rshift(), 1.into(), 0.into()), HAP, 0, false), 1.into());
     assert_eq!(beta(app!(rshift(), 2.into(), 0.into()), HAP, 0, false), 2.into());
     assert_eq!(beta(app!(rshift(), 0.into(), 2.into()), HAP, 0, false), 0.into());
     assert_eq!(beta(app!(rshift(), 2.into(), 1.into()), HAP, 0, false), 1.into());
     assert_eq!(beta(app!(rshift(), 2.into(), 2.into()), HAP, 0, false), 0.into());
     assert_eq!(beta(app!(rshift(), 5.into(), 1.into()), HAP, 0, false), 2.into());
     assert_eq!(beta(app!(rshift(), 9.into(), 1.into()), HAP, 0, false), 4.into());
     assert_eq!(beta(app!(rshift(), 9.into(), 2.into()), HAP, 0, false), 2.into());
     assert_eq!(beta(app!(rshift(), 7.into(), 1.into()), HAP, 0, false), 3.into());
}

#[test]
fn church_is_even() {
     assert_eq!(beta(app!(is_even(), 0.into()), NOR, 0, false), true.into());
     assert_eq!(beta(app!(is_even(), 1.into()), NOR, 0, false), false.into());
     assert_eq!(beta(app!(is_even(), 2.into()), NOR, 0, false), true.into());
     assert_eq!(beta(app!(is_even(), 8.into()), NOR, 0, false), true.into());
     assert_eq!(beta(app!(is_even(), 9.into()), NOR, 0, false), false.into());

     assert_eq!(beta(app!(is_even(), 0.into()), HNO, 0, false), true.into());
     assert_eq!(beta(app!(is_even(), 1.into()), HNO, 0, false), false.into());
     assert_eq!(beta(app!(is_even(), 2.into()), HNO, 0, false), true.into());
     assert_eq!(beta(app!(is_even(), 8.into()), HNO, 0, false), true.into());
     assert_eq!(beta(app!(is_even(), 9.into()), HNO, 0, false), false.into());

     assert_eq!(beta(app!(is_even(), 0.into()), HAP, 0, false), true.into());
     assert_eq!(beta(app!(is_even(), 1.into()), HAP, 0, false), false.into());
     assert_eq!(beta(app!(is_even(), 2.into()), HAP, 0, false), true.into());
     assert_eq!(beta(app!(is_even(), 8.into()), HAP, 0, false), true.into());
     assert_eq!(beta(app!(is_even(), 9.into()), HAP, 0, false), false.into());
}

#[test]
fn church_is_odd() {
     assert_eq!(beta(app!(is_odd(), 0.into()), NOR, 0, false), false.into());
     assert_eq!(beta(app!(is_odd(), 1.into()), NOR, 0, false), true.into());
     assert_eq!(beta(app!(is_odd(), 2.into()), NOR, 0, false), false.into());
     assert_eq!(beta(app!(is_odd(), 8.into()), NOR, 0, false), false.into());
     assert_eq!(beta(app!(is_odd(), 9.into()), NOR, 0, false), true.into());

     assert_eq!(beta(app!(is_odd(), 0.into()), HNO, 0, false), false.into());
     assert_eq!(beta(app!(is_odd(), 1.into()), HNO, 0, false), true.into());
     assert_eq!(beta(app!(is_odd(), 2.into()), HNO, 0, false), false.into());
     assert_eq!(beta(app!(is_odd(), 8.into()), HNO, 0, false), false.into());
     assert_eq!(beta(app!(is_odd(), 9.into()), HNO, 0, false), true.into());

     assert_eq!(beta(app!(is_odd(), 0.into()), HAP, 0, false), false.into());
     assert_eq!(beta(app!(is_odd(), 1.into()), HAP, 0, false), true.into());
     assert_eq!(beta(app!(is_odd(), 2.into()), HAP, 0, false), false.into());
     assert_eq!(beta(app!(is_odd(), 8.into()), HAP, 0, false), false.into());
     assert_eq!(beta(app!(is_odd(), 9.into()), HAP, 0, false), true.into());
}