freywar/jlc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Comparison functions

Browse Source
This commit is contained in:
freywar
2024-08-05 21:39:52 +03:00
parent 881f3af710
commit bbaa58a0b8
14 changed files with 1197 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/bool.ts
+20 -4
View File
@@ -1,4 +1,5 @@
import { toNative as $n, L, P, _, fromNative as _n } from './core';
import { toNative as $$, L, P, _, fromNative as __ } from './core';
import { EQ, GT, LT, Ord } from './ord';
export type Bool = L<<T extends P>(t: T) => L<(f: T) => T>>;
@@ -11,11 +12,26 @@ 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 not: L<(b: Bool) => Bool>
= _(b => b._(False)._(True));
export const cmp: L<(l: Bool) => L<(r: Bool) => Ord>>
= _(l => _(r => l._(r._(EQ)._(GT))._(r._(LT)._(EQ))));
export const lt: L<(l: Bool) => L<(r: Bool) => Bool>>
= _(l => _(r => l._(False)._(r)));
export const le: L<(l: Bool) => L<(r: Bool) => Bool>>
= _(l => _(r => l._(r)._(True)));
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));
export const ge: L<(l: Bool) => L<(r: Bool) => Bool>>
= _(l => _(r => l._(True)._(not._(r))));
export const gt: L<(l: Bool) => L<(r: Bool) => Bool>>
= _(l => _(r => l._(not._(r))._(False)));
export const and: L<(l: Bool) => L<(r: Bool) => Bool>>
= _(l => _(r => l._(r)._(False)));
@@ -30,4 +46,4 @@ export const fromBoolean: (b: boolean) => Bool
= b => b ? True : False;
export const toBoolean: (b: Bool) => boolean
= b => $n(b._(_n(true))._(_n(false)));
= b => $$(b._(__(true))._(__(false)));
src/char.ts
+17 -1
View File
@@ -1,15 +1,31 @@
import { L, _ } from './core';
import { Bool } from './bool';
import { toNumber as $n, Num, Zero, fromNumber as _n, eq as eqn } from './num';
import { toNumber as $n, Num, Zero, fromNumber as _n, cmp as cmpn, eq as eqn, ge as gen, gt as gtn, le as len, lt as ltn } from './num';
import { Ord } from 'src/ord';
export type Char = Num;
export const Null: Char
= Zero;
export const cmp: L<(l: Char) => L<(r: Char) => Ord>>
= cmpn;
export const lt: L<(l: Char) => L<(r: Char) => Bool>>
= ltn;
export const le: L<(l: Char) => L<(r: Char) => Bool>>
= len;
export const eq: L<(l: Char) => L<(r: Char) => Bool>>
= eqn;
export const ge: L<(l: Char) => L<(r: Char) => Bool>>
= gen;
export const gt: L<(l: Char) => L<(r: Char) => Bool>>
= gtn;
export const fromChar: (c: string) => Char
= c => _n(c.charCodeAt(0));
src/list.ts
+40 -12
View File
@@ -1,6 +1,6 @@
import { toNative as $n, L, P, _, fromNative as _n, undef } from './core';
import { toNative as $$, L, P, _, fromNative as __, undef } from './core';
import { EQ, GT, LT, Ord, eq as eqc } from './ord';
import { Bool, False, True, and, iif, or } from './bool';
import { toNumber as $nn, Num, fromNumber as _nn } from './num';
export type List<T extends P> = L<<R extends P>(z: R) => L<(f: L<(x: T) => L<(xs: List<T>) => R>>) => R>>;
@@ -42,12 +42,46 @@ 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>>) =>
export const cmp: L<<T extends P>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Ord>>>
= _(<T extends P>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
_((l: List<T>) =>
_((r: List<T>) => l
._(r._(EQ)._(_(_x => _(_xs => LT))))
._(_(lx => _(lxs => r._(GT)._(_(rx => _(rxs => iif
._(eqc._(EQ)._(ecmp._(lx)._(rx)))
._(cmp._(ecmp)._(lxs)._(rxs))
._(ecmp._(lx)._(rx)))))))))));
export const lt: L<<T extends P>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
= _(<T extends P>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
_((l: List<T>) =>
_((r: List<T>) =>
r._(False)._(_(rx => _(rxs => l._(True)._(_(lx => _(lxs => ecmp._(lx)._(rx)._(True)._(lt._(ecmp)._(lxs)._(rxs))._(False))))))))));
export const le: L<<T extends P>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
= _(<T extends P>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
_((l: List<T>) =>
_((r: List<T>) =>
l._(True)._(_(lx => _(lxs => r._(False)._(_(rx => _(rxs => ecmp._(lx)._(rx)._(True)._(le._(ecmp)._(lxs)._(rxs))._(False))))))))));
export const eq: L<<T extends P>(eeq: L<(l: T) => L <(r: T) => Bool>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
= _(<T extends P>(eeq: 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)))))))))));
._(_(lx => _(lxs => r._(False)._(_(rx => _(rxs => and._(eeq._(lx)._(rx))._(eq._(eeq)._(lxs)._(rxs)))))))))));
export const ge: L<<T extends P>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
= _(<T extends P>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
_((l: List<T>) =>
_((r: List<T>) =>
r._(True)._(_(rx => _(rxs => l._(False)._(_(lx => _(lxs => ecmp._(lx)._(rx)._(False)._(ge._(ecmp)._(lxs)._(rxs))._(True))))))))));
export const gt: L<<T extends P>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
= _(<T extends P>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
_((l: List<T>) =>
_((r: List<T>) =>
l._(False)._(_(lx => _(lxs => r._(True)._(_(rx => _(rxs => ecmp._(lx)._(rx)._(False)._(gt._(ecmp)._(lxs)._(rxs))._(True))))))))));
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>) =>
@@ -68,11 +102,5 @@ export const all: L<<T extends P>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bo
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));
export const fromNumberArray: (xs: number[]) => List<Num>
= xs => xs.length === 0 ? Nil : Cons._(_nn(xs[0]))._(new L(() => fromNumberArray(xs.slice(1)).value));
export const toArray: <T extends P>(xs: List<T>) => P[]
= xs => $n(xs._(_n([]))._(_(x => _(xs => _n([x, ...toArray(xs)])))));
export const toNumberArray: (xs: List<Num>) => number[]
= xs => $n(xs._(_n([]))._(_(x => _(xs => _n([$nn(x), ...toNumberArray(xs)])))));
= xs => $$(xs._(__([]))._(_(x => _(xs => __([x, ...toArray(xs)])))));
src/num.ts
+19 -5
View File
@@ -1,4 +1,5 @@
import { toNative as $n, L, P, _, fromNative as _n, id } from './core';
import { toNative as $$, L, P, _, fromNative as __, id } from './core';
import { EQ, GT, LT, Ord } from './ord';
import { Bool, False, True } from './bool';
export type Num = L<<T extends P>(z: T) => L<(n: L<(p: Num) => T>) => T>>;
@@ -18,10 +19,23 @@ export const succ: L<(n: Num) => Num>
export const pred: L<(n: Num) => Num>
= _(n => n._(Zero)._(id));
export const cmp: L<(l: Num) => L<(r: Num) => Ord>>
= _(l => _(r => l._(r._(EQ)._(_(_ => LT)))._(_(pl => r._(GT)._(_(pr => cmp._(pl)._(pr)))))));
export const lt: L<(l: Num) => L<(r: Num) => Bool>>
= _(l => _(r => r._(False)._(_(pr => l._(True)._(_(pl => lt._(pl)._(pr)))))));
export const le: L<(l: Num) => L<(r: Num) => Bool>>
= _(l => _(r => l._(True)._(_(pl => r._(False)._(_(pr => le._(pl)._(pr)))))));
export const eq: L<(l: Num) => L<(r: Num) => Bool>>
= _(l => _(r => l
._(r._(True)._(_(_ => False)))
._(_(pl => r._(False)._(_(pr => eq._(pl)._(pr)))))));
= _(l => _(r => l._(r._(True)._(_(_ => False)))._(_(pl => r._(False)._(_(pr => eq._(pl)._(pr)))))));
export const ge: L<(l: Num) => L<(r: Num) => Bool>>
= _(l => _(r => r._(True)._(_(pr => l._(False)._(_(pl => ge._(pl)._(pr)))))));
export const gt: L<(l: Num) => L<(r: Num) => Bool>>
= _(l => _(r => l._(False)._(_(pl => r._(True)._(_(pr => gt._(pl)._(pr)))))));
export const even: L<(n: Num) => Bool>
= _(n => n._(True)._(odd));
@@ -42,4 +56,4 @@ export const fromNumber: (n: number) => Num
= n => !n ? Zero : Succ._(new L(() => fromNumber(n - 1).value));
export const toNumber: (n: Num) => number
= n => $n(n._(_n(0))._(_(p => _n(1 + toNumber(p)))));
= n => $$(n._(__(0))._(_(p => __(1 + toNumber(p)))));
src/ord.ts
+31
View File
@@ -0,0 +1,31 @@
import { toNative as $$, L, P, _, fromNative as __ } from './core';
import { Bool, False, True } from './bool';
export type Ord = L<<T extends P>(lt: T) => L<(eq: T) => L<(gt: T) => T>>>;
export const enum NOrd {
LT,
EQ,
GT,
};
export const LT: Ord
= _(lt => _(_eq => _(_gt => lt))) as Ord;
export const EQ: Ord
= _(_lt => _(eq => _(_gt => eq)));
export const GT: Ord
= _(_lt => _(_eq => _(gt => gt)));
export const eq: L<(l: Ord) => L<(r: Ord) => Bool>>
= _(l => _(r => l
._(r._(True)._(False)._(False))
._(r._(False)._(True)._(False))
._(r._(False)._(False)._(True))));
export const fromNOrd: (b: NOrd) => Ord
= o => o === NOrd.LT ? LT : o === NOrd.EQ ? EQ : GT;
export const toNOrd: (b: Ord) => NOrd
= o => $$(o._(__(NOrd.LT))._(__(NOrd.EQ))._(__(NOrd.GT)));
src/pair.ts
+48
View File
@@ -1,4 +1,6 @@
import { L, P, _ } from './core';
import { GT, LT, Ord } from './ord';
import { Bool, False, True, and } from './bool';
export type Pair<F extends P, S extends P> = L<<R extends P>(f: L<(f: F) => L<(s: S) => R>>) => R>;
@@ -25,3 +27,49 @@ export const both: L<<F extends P, FR extends P, S extends P, SR extends P>(tf:
= _(<F extends P, FR extends P>(tf: L<(f: F) => FR>) =>
_(<S extends P, SR extends P>(ts: L<(s: S) => SR>) =>
_((p: Pair<F, S>) => p._(_(f => _(s => Pair._(tf._(f))._(ts._(s))))))));
export const uncurry: L<<F extends P, S extends P, R extends P>(t: L<(f: F) => L<(s: S) => R>>) => L<(p: Pair<F, S>) => R>>
= _(<F extends P, S extends P, R extends P>(t: L<(f: F) => L<(s: S) => R>>) =>
_((p: Pair<F, S>) => p._(t)));
export const cmp: L<<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Ord>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Ord>>>>
= _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
_((l: Pair<F, S>) =>
_((r: Pair<F, S>) =>
fcmp._(fst._(l))._(fst._(r))._(LT)._(scmp._(snd._(l))._(snd._(r)))._(GT)))));
export const lt: L<<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
= _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
_((l: Pair<F, S>) =>
_((r: Pair<F, S>) =>
fcmp._(fst._(l))._(fst._(r))._(True)._(scmp._(snd._(l))._(snd._(r))._(True)._(False)._(False))._(False)))));
export const le: L<<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
= _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
_((l: Pair<F, S>) =>
_((r: Pair<F, S>) =>
fcmp._(fst._(l))._(fst._(r))._(True)._(scmp._(snd._(l))._(snd._(r))._(True)._(True)._(False))._(False)))));
export const eq: L<<F extends P, S extends P>(feq: L<(l: F) => L<(r: F) => Bool>>) => L<(seq: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
= _(<F extends P, S extends P>(feq: L<(l: F) => L<(r: F) => Bool>>) =>
_((seq: L<(l: S) => L<(r: S) => Bool>>) =>
_((l: Pair<F, S>) =>
_((r: Pair<F, S>) =>
and._(feq._(fst._(l))._(fst._(r)))._(seq._(snd._(l))._(snd._(r)))))));
export const ge: L<<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
= _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
_((l: Pair<F, S>) =>
_((r: Pair<F, S>) =>
fcmp._(fst._(l))._(fst._(r))._(False)._(scmp._(snd._(l))._(snd._(r))._(False)._(True)._(True))._(True)))));
export const gt: L<<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
= _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
_((l: Pair<F, S>) =>
_((r: Pair<F, S>) =>
fcmp._(fst._(l))._(fst._(r))._(False)._(scmp._(snd._(l))._(snd._(r))._(False)._(False)._(True))._(True)))));
src/string.ts
+20 -4
View File
@@ -1,8 +1,9 @@
import { toNative as $n, L, _, fromNative as _n } from './core';
import { toNative as $$, L, _, fromNative as __ } from './core';
import { Ord } from './ord';
import { Bool } from './bool';
import { fromNumber as _nn } from './num';
import { toChar as $c, Char, fromChar as _c, eq as eqc } from './char';
import { Cons as ConsL, List, Nil, concat as concatl, eq as eql } from './list';
import { toChar as $c, Char, fromChar as _c, cmp as cmpc, eq as eqc } from './char';
import { Cons as ConsL, List, Nil, cmp as cmpl, concat as concatl, eq as eql, ge as gel, gt as gtl, le as lel, lt as ltl } from './list';
export type String = List<Char>;
@@ -18,11 +19,26 @@ export const cons: L<(c: Char) => L<(s: String) => String>>
export const concat: L<(l: String) => L<(r: String) => String>>
= concatl;
export const cmp: L<(l: String) => L<(r: String) => Ord>>
= cmpl._(cmpc);
export const lt: L<(l: String) => L<(r: String) => Bool>>
= ltl._(cmpc);
export const le: L<(l: String) => L<(r: String) => Bool>>
= lel._(cmpc);
export const eq: L<(l: String) => L<(r: String) => Bool>>
= eql._(eqc);
export const ge: L<(l: String) => L<(r: String) => Bool>>
= gel._(cmpc);
export const gt: L<(l: String) => L<(r: String) => Bool>>
= gtl._(cmpc);
export const fromString: (xs: string) => String
= xs => xs.length === 0 ? Nil : Cons._(_c(xs[0]))._(new L(() => fromString(xs.slice(1)).value));
export const toString: (xs: String) => string
= xs => $n(xs._(_n(''))._(_(x => _(xs => _n($c(x) + toString(xs))))));
= xs => $$(xs._(__(''))._(_(x => _(xs => __($c(x) + toString(xs))))));