feat(integers): add more operations (#6)

* feat(integers): add more operations

* test(decode): separate test file

* test(integer): increase coverage to 100%

* test(natural-number): add missing tests

* test(decode): modify description

* test(list-operations): separate file for tests

* feat(integer): more operations

* test(integer): fix tests

Author: f0rr0

lib/integer.js

@@ -1,4 +1,4 @@
-import { NOT, IF, OR } from './boolean';
+import { NOT, IF, OR, AND, T, F } from './boolean';
 import {
   zeroNat,
   isZeroNat,
@@ -8,7 +8,8 @@ import {
   isEqualNat,
   mulNat,
   modNat,
-  expNat
+  expNat,
+  isLessThanNat
 } from './natural-number';
 
 export const pair = (a, b) => selector => selector(a, b);
@@ -52,7 +53,22 @@ export const mul = (a, b) =>
   );
 export const exp = (pow, int) =>
   IF(
-    isZeroNat(modNat(pow, inc(inc(zero)))),
-    () => pair(expNat(pow, abs(int)), zeroNat),
-    () => pair(zeroNat, expNat(pow, abs(int)))
+    isZeroNat(modNat(abs(pow), incNat(incNat(zeroNat)))),
+    () => pair(expNat(abs(pow), abs(int)), zeroNat),
+    () => pair(zeroNat, expNat(abs(pow), abs(int)))
   )();
+export const isNegative = a => NOT(isZeroNat(second(normalize(a))));
+export const isLessThan = (a, b) =>
+  IF(
+    OR(AND(isNegative(a), isNegative(b)), AND(NOT(isNegative(a)), NOT(isNegative(b)))),
+    () =>
+      IF(
+        AND(isNegative(a), isNegative(b)),
+        () => NOT(isLessThanNat(abs(a), abs(b))),
+        () => isLessThanNat(abs(a), abs(b))
+      )(),
+    () => IF(isNegative(a), () => T, () => F)()
+  )();
+export const isLessThanEqual = (a, b) => OR(isLessThan(a, b), isEqual(a, b));
+export const isGreaterThan = (a, b) => isLessThan(b, a);
+export const isGreaterThanEqual = (a, b) => isLessThanEqual(b, a);

lib/natural-number.js

@@ -16,7 +16,7 @@ export const isEqualNat = (a, b) =>
 export const mulNat = (a, b) =>
   IF(isZeroNat(b), () => zeroNat, () => addNat(a, mulNat(a, decNat(b))))();
 export const expNat = (pow, num) =>
-  IF(isZeroNat(pow), () => incNat(zeroNat), () => mulNat(num, expNat(decNat(num), num)));
+  IF(isZeroNat(pow), () => incNat(zeroNat), () => mulNat(num, expNat(decNat(pow), num)))();
 export const isLessThanNat = (a, b) =>
   IF(
     AND(isZeroNat(a), isZeroNat(b)),

test/boolean.test.js

@@ -0,0 +1,64 @@
+import { T, F, IF, AND, OR, NOT } from '../lib';
+
+describe('Church Encoding for Booleans', () => {
+  describe('T', () => {
+    it('is a function', () => {
+      expect(T).toBeFunction();
+    });
+    it('evaluates the left branch', () => {
+      expect(T(true, false)).toBeTrue();
+    });
+  });
+
+  describe('F', () => {
+    it('is a function', () => {
+      expect(F).toBeFunction();
+    });
+    it('evaluates the right branch', () => {
+      expect(F(true, false)).toBeFalse();
+    });
+  });
+
+  describe('IF', () => {
+    it('is a function', () => {
+      expect(IF).toBeFunction();
+    });
+    it('evalutes the predicate with the left and right branches', () => {
+      expect(IF(T, true, false)).toBeTrue();
+    });
+  });
+
+  describe('AND', () => {
+    it('is a function', () => {
+      expect(AND).toBeFunction();
+    });
+    it('returns true if both values are true, false otherwise', () => {
+      expect(IF(AND(T, F), true, false)).toBeFalse();
+      expect(IF(AND(F, T), true, false)).toBeFalse();
+      expect(IF(AND(T, T), true, false)).toBeTrue();
+    });
+  });
+
+  describe('OR', () => {
+    it('is a function', () => {
+      expect(OR).toBeFunction();
+    });
+    it('returns true if either value is true, false otherwise', () => {
+      expect(IF(OR(T, F), true, false)).toBeTrue();
+      expect(IF(OR(F, T), true, false)).toBeTrue();
+      expect(IF(OR(T, T), true, false)).toBeTrue();
+      expect(IF(OR(F, F), true, false)).toBeFalse();
+    });
+  });
+
+  describe('NOT', () => {
+    it('is a function', () => {
+      expect(NOT).toBeFunction();
+    });
+    it('negates the value', () => {
+      expect(IF(NOT(T), true, false)).toBeFalse();
+      expect(IF(NOT(F), true, false)).toBeTrue();
+      expect(IF(NOT(AND(T, F)), true, false)).toBeTrue();
+    });
+  });
+});