More library functions

src/bool.ts

@@ -11,6 +11,9 @@ export const False: Bool
 export const iif: L<<T extends P>(b: Bool) => L<(t: T) => L<(f: T) => T>>>
   = _(b => _(t => _(f => b._(t)._(f))));
 
+export const eq: L<(l: Bool) => L<(r: Bool) => Bool>>
+  = _(l => _(r => l._(r)._(not._(r))))
+
 export const not: L<(b: Bool) => Bool>
   = _(b => b._(False)._(True));
 

src/list.ts

@@ -1,6 +1,6 @@
 import { L, P, _, fromNative, toNative, undef } from './core';
 import { Num, fromNumber, toNumber } from './num';
-import { Bool, iif } from './bool';
+import { Bool, False, True, and, iif, or } from './bool';
 
 export type List<T extends P> = L<<R extends P>(z: R) => L<(f: L<(x: T) => L<(xs: List<T>) => R>>) => R>>;
 
@@ -42,6 +42,14 @@ export const foldr: L<<T extends P, R extends P>(f: L<(x: T) => L<(a: R) => R>>)
 export const foldrz: L<<T extends P>(f: L<(x: T) => L<(a: T) => T>>) => L<(xs: List<T>) => T>>
   = _(_f => _(_z => undef));
 
+export const eq: L<<T extends P>(e: L<(l: T) =>L <(r: T) => Bool>>) => L<(l: List<T>)=> L<(r: List<T>) => Bool>>>
+  =
+  _(<T extends P>(e: L<(l: T) => L<(r: T) => Bool>>) =>
+    _((l: List<T>) =>
+      _((r: List<T>) => l
+        ._(r._(True)._(_(_x => _(_xs => False))))
+        ._(_(lx => _(lxs => r._(False)._(_(rx => _(rxs => and._(e._(lx)._(rx))._(eq._(e)._(lxs)._(rxs)))))))))));
+
 export const map: L<<T extends P, R extends P>(f: L<(x: T) => R>) => L<(xs: List<T>) => List<R>>>
   =
   _(<T extends P, R extends P>(f: L<(x: T) => R>) =>
@@ -52,6 +60,16 @@ export const filter: L<<T extends P>(f: L<(x: T) => Bool>) => L<(xs: List<T>) =>
   _(<T extends P>(f: L<(x: T) => Bool>)  =>
     _((xs: List<T>) => xs._(Nil)._(_(x => _(xs => iif._(f._(x))._(Cons._(x)._(filter._(f)._(xs)))._(filter._(f)._(xs)))))));
 
+export const any: L<<T extends P>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>>
+  =
+  _(<T extends P>(f: L<(x: T) => Bool>) =>
+    _((xs: List<T>) => xs._(False)._(_(x => _(xs => or._(f._(x))._(any._(f)._(xs)))))));
+
+export const all: L<<T extends P>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>>
+  =
+  _(<T extends P>(f: L<(x: T) => Bool>) =>
+    _((xs: List<T>) => xs._(True)._(_(x => _(xs => and._(f._(x))._(all._(f)._(xs)))))));
+
 export const fromArray: <T extends P>(xs: T[]) => List<T>
   = xs => xs.length === 0 ? Nil : Cons._(xs[0])._(new L(() => fromArray(xs.slice(1)).value));
 

src/num.ts

@@ -18,6 +18,11 @@ export const succ: L<(n: Num) => Num>
 export const pred: L<(n: Num) => Num>
   = _(n => n._(Zero)._(id));
 
+export const eq: L<(l: Num) => L<(r: Num) => Bool>>
+  = _(l => _(r => l
+    ._(r._(True)._(_(_ => False)))
+    ._(_(pl => r._(False)._(_(pr => eq._(pl)._(pr)))))));
+
 export const even: L<(n: Num) => Bool>
   = _(n => n._(True)._(odd));