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

Cleanup

Browse Source
This commit is contained in:
freywar
2024-08-09 23:29:28 +03:00
parent b883515a5f
commit 114f32cdc7
13 changed files with 130 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files
eslint.config.mjs
+1
View File
@@ -34,6 +34,7 @@ export default [
'@stylistic/semi': ['error', 'always'], '@stylistic/semi': ['error', 'always'],
'@stylistic/indent': 'error', '@stylistic/indent': 'error',
'@stylistic/arrow-parens': ['error', 'as-needed', { requireForBlockBody: false }], '@stylistic/arrow-parens': ['error', 'as-needed', { requireForBlockBody: false }],
'@stylistic/max-statements-per-line': 'off',
'@typescript-eslint/no-unused-vars': [ '@typescript-eslint/no-unused-vars': [
'error', 'error',
{ {
src/bool.ts
+3 -3
View File
@@ -1,8 +1,8 @@
import { toNative as $$, L, P, _, fromNative as __, id, pipe } from './core'; import { toNative as $$, L, _, fromNative as __, id, pipe } from './core';
import { EQ, GT, LT, Ord } from './ord'; import { EQ, GT, LT, Ord } from './ord';
import { String, fromString as _s } from './string'; import { String, fromString as _s } from './string';
export type Bool = L<<T extends P>(t: T) => L<(f: T) => T>>; export type Bool = L<<T extends L>(t: T) => L<(f: T) => T>>;
export const True: Bool export const True: Bool
= _(t => _(_f => t)) as Bool; = _(t => _(_f => t)) as Bool;
@@ -10,7 +10,7 @@ export const True: Bool
export const False: Bool export const False: Bool
= _(_t => _(f => f)); = _(_t => _(f => f));
export const iif: L<<T extends P>(b: Bool) => L<(t: T) => L<(f: T) => T>>> export const iif: L<<T extends L>(b: Bool) => L<(t: T) => L<(f: T) => T>>>
= id; = id;
export const not: L<(b: Bool) => Bool> export const not: L<(b: Bool) => Bool>
src/core.ts
+17 -24
View File
@@ -1,36 +1,29 @@
export type L<T extends (v: P) => L<any>> = T & { run: () => T }; type F = (v: L) => L<any>;
export function ___<T extends (v: P) => L<any>>(run: () => T): L<T> { export type L<T extends F = F> = T & { run: () => T };
const r: T = ((p: Parameters<T>[0]) => {
let v: any;
return ___(() => run()(
___(() => v ??= p.run()),
).run());
}) as T;
(r as L<T>).run = run; const defer: <T extends F>(run: () => T) => L<T> = <T extends F>(run: () => T) =>
Object.assign(((p: Parameters<T>[0]): ReturnType<T> => {
let v: F;
return defer(() => run()(defer(() => v ??= p.run())).run());
}) as T, { run });
return r as L<T>; export const _ = <T extends F>(v: T): L<T> => defer(() => v);
}
export type P = L<(v: unknown) => L<any>>;
export const _ = <T extends ((v: unknown) => L<any>)>(v: T): L<T> => ___(() => v);
export const fromNative: <T>(v: T) => L<any> export const fromNative: <T>(v: T) => L<any>
= v => ___(() => v as any); = v => defer(() => v as any);
export const toNative: <T>(v: L<any>) => T export const toNative: <T>(v: L<any>) => T
= <T>(v: L<any>) => v.run() as T; = <T>(v: L<any>) => v.run() as T;
export const undef: any = ___(() => { export const y = (f: () => L<F>) => defer(() => f().run());
throw new Error('undefined');
});
export const id: L<<T extends P>(v: T) => T> export const undef: any = defer(() => { throw new Error('undefined'); });
export const id: L<<T extends L>(v: T) => T>
= _(v => v); = _(v => v);
export const cnst: L<<T extends P>(v: T) => L<(_: unknown) => T>> export const cnst: L<<T extends L>(v: T) => L<(_: unknown) => T>>
= _(v => _(_ => v)) as L<<T extends P>(v: T) => L<(_: unknown) => T>>; = _(v => _(_ => v)) as L<<T extends L>(v: T) => L<(_: unknown) => T>>;
export const pipe: L<<A extends P, B extends P, C extends P>(f: L<(v: B) => C>) => L<(g: L<(v: A) => B>) => L<(v: A) => C>>> export const pipe: L<<A extends L, B extends L, C extends L>(f: L<(v: B) => C>) => L<(g: L<(v: A) => B>) => L<(v: A) => C>>>
= _(<A extends P, B extends P, C extends P>(f: L<(v: B) => C>) => = _(<A extends L, B extends L, C extends L>(f: L<(v: B) => C>) =>
_((g: L<(v: A) => B>) => _((g: L<(v: A) => B>) =>
_((v: A) => f(g(v))))); _((v: A) => f(g(v)))));
src/debug.ts
+2 -2
View File
@@ -1,7 +1,7 @@
import { L, P, _ } from './core'; import { L, _ } from './core';
import { String, toString } from './string'; import { String, toString } from './string';
export const log: L<<T extends P>(s: String) => L<(p: T) => T>> export const log: L<<T extends L>(s: String) => L<(p: T) => T>>
= _(s => _(p => { = _(s => _(p => {
console.log(toString(s)); console.log(toString(s));
return p; return p;
src/index.ts
+6 -2
View File
@@ -1,3 +1,7 @@
import { toNative as $$, _, fromNative as __, id } from './core'; import { _, fromNative as __ } from './core';
import { toString as $s, fromString as _s } from './string';
import { run } from './bf';
console.log($$(id(__('first')))); console.log($s(run
(_s('++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.'))
(_s(''))));
src/list.ts
+53 -53
View File
@@ -1,69 +1,69 @@
import { toNative as $$, L, P, _, fromNative as __, ___, cnst, id, pipe, undef } from './core'; import { toNative as $$, L, _, fromNative as __, cnst, id, pipe, undef, y } from './core';
import { EQ, GT, LT, Ord, eq as eqc } from './ord'; import { EQ, GT, LT, Ord, eq as eqc } from './ord';
import { Bool, False, True, and, iif, or } from './bool'; import { Bool, False, True, and, iif, or } from './bool';
import { Num, Zero, succ } from './num'; import { Num, Zero, succ } from './num';
import { String, fromString as _s } from './string'; import { String, fromString as _s } from './string';
export type List<T extends P> = L<<R extends P>(z: R) => L<(f: L<(x: T) => L<(xs: List<T>) => R>>) => R>>; export type List<T extends L> = L<<R extends L>(z: R) => L<(f: L<(x: T) => L<(xs: List<T>) => R>>) => R>>;
export const Nil: List<any> export const Nil: List<any>
= _(z => _(_f => z)) as List<any>; = _(z => _(_f => z)) as List<any>;
export const Cons: L<<T extends P>(x: T) => L<(xs: List<T>) => List<T>>> export const Cons: L<<T extends L>(x: T) => L<(xs: List<T>) => List<T>>>
= _(<T extends P>(x: T) => _((xs: List<T>) => _(_z => _(f => f(x)(xs))) as List<T>)); = _(<T extends L>(x: T) => _((xs: List<T>) => _(_z => _(f => f(x)(xs))) as List<T>));
export const cons: L<<T extends P>(x: T) => L<(xs: List<T>) => List<T>>> export const cons: L<<T extends L>(x: T) => L<(xs: List<T>) => List<T>>>
= Cons; = Cons;
export const snoc: L<<T extends P>(xs: List<T>) => L<(x: T) => List<T>>> export const snoc: L<<T extends L>(xs: List<T>) => L<(x: T) => List<T>>>
= _(<T extends P>(xs: List<T>) => = _(<T extends L>(xs: List<T>) =>
_((x: T) => xs(cons(x)(Nil))(_(y => _(ys => cons(y)(snoc(ys)(x))))))); _((x: T) => xs(cons(x)(Nil))(_(y => _(ys => cons(y)(snoc(ys)(x)))))));
export const nul: L<<T extends P>(xs: List<T>) => Bool> export const nul: L<<T extends L>(xs: List<T>) => Bool>
= _(xs => xs(True)(cnst(cnst(False)))); = _(xs => xs(True)(cnst(cnst(False))));
export const len: L<<T extends P>(xs: List<T>) => Num> export const len: L<<T extends L>(xs: List<T>) => Num>
= _(xs => xs(Zero)(cnst(pipe(succ)(len)))); = _(xs => xs(Zero)(cnst(pipe(succ)(len))));
export const singleton: L<<T extends P>(v: T) => List<T>> export const singleton: L<<T extends L>(v: T) => List<T>>
= _(x => cons(x)(Nil)); = _(x => cons(x)(Nil));
export const append: L<<T extends P>(l: List<T>) => L<(r: List<T>) => List<T>>> export const append: L<<T extends L>(l: List<T>) => L<(r: List<T>) => List<T>>>
= _(l => _(r => l(r)(_(x => _(xs => cons(x)(append(xs)(r))))))); = _(l => _(r => l(r)(_(x => _(xs => cons(x)(append(xs)(r)))))));
export const concat: L<<T extends P>(ls: List<List<T>>) => List<T>> export const concat: L<<T extends L>(ls: List<List<T>>) => List<T>>
= _(ls => ls(Nil)(_(x => pipe(append(x))(concat)))); = _(ls => ls(Nil)(_(x => pipe(append(x))(concat))));
export const repeat: L<<T extends P>(x: T) => List<T>> export const repeat: L<<T extends L>(x: T) => List<T>>
= _(x => cons(x)(repeat(x))); = _(x => cons(x)(repeat(x)));
export const iterate: L<<T extends P>(f: L<(x: T) => T>) => L<(x: T) => List<T>>> export const iterate: L<<T extends L>(f: L<(x: T) => T>) => L<(x: T) => List<T>>>
= _(<T extends P>(f: L<(x: T) => T>) => _((x: T) => cons(x)(iterate(f)(f(x))))); = _(<T extends L>(f: L<(x: T) => T>) => _((x: T) => cons(x)(iterate(f)(f(x)))));
export const head: L<<T extends P>(xs: List<T>) => T> export const head: L<<T extends L>(xs: List<T>) => T>
= _(xs => xs(undef)(cnst)); = _(xs => xs(undef)(cnst));
export const tail: L<<T extends P>(xs: List<T>) => List<T>> export const tail: L<<T extends L>(xs: List<T>) => List<T>>
= _(xs => xs(undef)(cnst(id))); = _(xs => xs(undef)(cnst(id)));
export const foldl: L<<T extends P, R extends P>(f: L<(a: R) => L<(x: T) => R>>) => L<(z: R) => L<(xs: List<T>) => R>>> export const foldl: L<<T extends L, R extends L>(f: L<(a: R) => L<(x: T) => R>>) => L<(z: R) => L<(xs: List<T>) => R>>>
= _(<T extends P, R extends P>(f: L<(a: R) => L<(x: T) => R>>) => = _(<T extends L, R extends L>(f: L<(a: R) => L<(x: T) => R>>) =>
_((z: R) => _((z: R) =>
_((xs: List<T>) => xs(z)(pipe(foldl(f))(f(z)))))); _((xs: List<T>) => xs(z)(pipe(foldl(f))(f(z))))));
export const foldlz: L<<T extends P>(f: L<(a: T) => L<(x: T) => T>>) => L<(xs: List<T>) => T>> export const foldlz: L<<T extends L>(f: L<(a: T) => L<(x: T) => T>>) => L<(xs: List<T>) => T>>
= _(<T extends P>(f: L<(a: T) => L<(x: T) => T>>) => _((xs: List<T>) => xs(undef)(foldl(f)))); = _(<T extends L>(f: L<(a: T) => L<(x: T) => T>>) => _((xs: List<T>) => xs(undef)(foldl(f))));
export const foldr: L<<T extends P, R extends P>(f: L<(x: T) => L<(a: R) => R>>) => L<(z: R) => L<(xs: List<T>) => R>>> export const foldr: L<<T extends L, R extends L>(f: L<(x: T) => L<(a: R) => R>>) => L<(z: R) => L<(xs: List<T>) => R>>>
= _(<T extends P, R extends P>(f: L<(x: T) => L<(a: R) => R>>) => = _(<T extends L, R extends L>(f: L<(x: T) => L<(a: R) => R>>) =>
_((z: R) => _((z: R) =>
_((xs: List<T>) => xs(z)(_(x => pipe(f(x))(foldr(f)(z))))))); _((xs: List<T>) => xs(z)(_(x => pipe(f(x))(foldr(f)(z)))))));
export const foldrz: L<<T extends P>(f: L<(x: T) => L<(a: T) => T>>) => L<(xs: List<T>) => T>> export const foldrz: L<<T extends L>(f: L<(x: T) => L<(a: T) => T>>) => L<(xs: List<T>) => T>>
= undef; = undef;
export const cmp: L<<T extends P>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Ord>>> export const cmp: L<<T extends L>(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>>) => = _(<T extends L>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
_((l: List<T>) => _((l: List<T>) =>
_((r: List<T>) => l _((r: List<T>) => l
(r(EQ)(cnst(cnst(LT)))) (r(EQ)(cnst(cnst(LT))))
@@ -72,73 +72,73 @@ export const cmp: L<<T extends P>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l:
(cmp(ecmp)(lxs)(rxs)) (cmp(ecmp)(lxs)(rxs))
(ecmp(lx)(rx))))))))))); (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>>> export const lt: L<<T extends L>(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>>) => = _(<T extends L>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
_((l: List<T>) => _((l: List<T>) =>
_((r: List<T>) => _((r: List<T>) =>
r(False)(_(rx => _(rxs => l(True)(_(lx => _(lxs => ecmp(lx)(rx)(True)(lt(ecmp)(lxs)(rxs))(False)))))))))); 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>>> export const le: L<<T extends L>(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>>) => = _(<T extends L>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
_((l: List<T>) => _((l: List<T>) =>
_((r: List<T>) => _((r: List<T>) =>
l(True)(_(lx => _(lxs => r(False)(_(rx => _(rxs => ecmp(lx)(rx)(True)(le(ecmp)(lxs)(rxs))(False)))))))))); 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>>> export const eq: L<<T extends L>(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>>) => = _(<T extends L>(eeq: L<(l: T) => L<(r: T) => Bool>>) =>
_((l: List<T>) => _((l: List<T>) =>
_((r: List<T>) => l _((r: List<T>) => l
(r(True)(cnst(cnst(False)))) (r(True)(cnst(cnst(False))))
(_(lx => _(lxs => r(False)(_(rx => _(rxs => and(eeq(lx)(rx))(eq(eeq)(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>>> export const ge: L<<T extends L>(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>>) => = _(<T extends L>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
_((l: List<T>) => _((l: List<T>) =>
_((r: List<T>) => _((r: List<T>) =>
r(True)(_(rx => _(rxs => l(False)(_(lx => _(lxs => ecmp(lx)(rx)(False)(ge(ecmp)(lxs)(rxs))(True)))))))))); 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>>> export const gt: L<<T extends L>(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>>) => = _(<T extends L>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
_((l: List<T>) => _((l: List<T>) =>
_((r: List<T>) => _((r: List<T>) =>
l(False)(_(lx => _(lxs => r(True)(_(rx => _(rxs => ecmp(lx)(rx)(False)(gt(ecmp)(lxs)(rxs))(True)))))))))); 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>>> export const map: L<<T extends L, R extends L>(f: L<(x: T) => R>) => L<(xs: List<T>) => List<R>>>
= _(<T extends P, R extends P>(f: L<(x: T) => R>) => = _(<T extends L, R extends L>(f: L<(x: T) => R>) =>
_((xs: List<T>) => xs(Nil)(_(x => pipe(cons(f(x)))(map(f)))))); _((xs: List<T>) => xs(Nil)(_(x => pipe(cons(f(x)))(map(f))))));
export const filter: L<<T extends P>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => List<T>>> export const filter: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => List<T>>>
= _(<T extends P>(f: L<(x: T) => Bool>) => = _(<T extends L>(f: L<(x: T) => Bool>) =>
_((xs: List<T>) => xs(Nil)(_(x => pipe(iif(f(x))(cons(x))(id))(filter(f)))))); _((xs: List<T>) => xs(Nil)(_(x => pipe(iif(f(x))(cons(x))(id))(filter(f))))));
export const any: L<<T extends P>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>> export const any: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>>
= _(<T extends P>(f: L<(x: T) => Bool>) => = _(<T extends L>(f: L<(x: T) => Bool>) =>
_((xs: List<T>) => xs(False)(_(x => pipe(or(f(x)))(any(f)))))); _((xs: List<T>) => xs(False)(_(x => pipe(or(f(x)))(any(f))))));
export const all: L<<T extends P>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>> export const all: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>>
= _(<T extends P>(f: L<(x: T) => Bool>) => = _(<T extends L>(f: L<(x: T) => Bool>) =>
_((xs: List<T>) => xs(True)(_(x => pipe(and(f(x)))(all(f)))))); _((xs: List<T>) => xs(True)(_(x => pipe(and(f(x)))(all(f))))));
export const get: L<<T extends P>(i: Num) => L<(xs: List<T>) => T>> export const get: L<<T extends L>(i: Num) => L<(xs: List<T>) => T>>
= _(i => _(xs => xs(undef)(_(x => i(cnst(x))(get))))); = _(i => _(xs => xs(undef)(_(x => i(cnst(x))(get)))));
export const update: L<<T extends P>(f: L< (p: T) => T>) => L<(i: Num) => L<(xs: List<T>) => List<T>>>> export const update: L<<T extends L>(f: L< (p: T) => T>) => L<(i: Num) => L<(xs: List<T>) => List<T>>>>
= _(<T extends P>(f: L< (p: T) => T>) => = _(<T extends L>(f: L< (p: T) => T>) =>
_((i: Num) => _((i: Num) =>
_((xs: List<T>) => _((xs: List<T>) =>
xs(undef)(_(x => _(xs => i(cons(f(x))(xs))(_(pi => cons(x)(update(f)(pi)(xs)))))))))); xs(undef)(_(x => _(xs => i(cons(f(x))(xs))(_(pi => cons(x)(update(f)(pi)(xs))))))))));
export const set: L<<T extends P>(v: T) => L<(i: Num) => L<(xs: List<T>) => List<T>>>> export const set: L<<T extends L>(v: T) => L<(i: Num) => L<(xs: List<T>) => List<T>>>>
= pipe(update)(cnst); = pipe(update)(cnst);
export const intersperse: L<<T extends P>(v: T) => L<(xs: List<T>) => List<T>>> export const intersperse: L<<T extends L>(v: T) => L<(xs: List<T>) => List<T>>>
= _(v => _(xs => xs(xs)(_(x => _(rxs => rxs(xs)(cnst(cnst(cons(x)(cons(v)(intersperse(v)(rxs))))))))))); = _(v => _(xs => xs(xs)(_(x => _(rxs => rxs(xs)(cnst(cnst(cons(x)(cons(v)(intersperse(v)(rxs)))))))))));
export const show: L<<T extends P>(eshow: L<(e: T) => String>) => L<(xs: List<T>) => String>> export const show: L<<T extends L>(eshow: L<(e: T) => String>) => L<(xs: List<T>) => String>>
= _(eshow => _(xs => concat(snoc(cons(_s('['))(intersperse(_s(', '))(map(eshow)(xs))))(_s(']'))))); = _(eshow => _(xs => concat(snoc(cons(_s('['))(intersperse(_s(', '))(map(eshow)(xs))))(_s(']')))));
export const fromArray: <T extends P>(xs: T[]) => List<T> export const fromArray: <T extends L>(xs: T[]) => List<T>
= xs => xs.length === 0 ? Nil : cons(xs[0])(___(() => fromArray(xs.slice(1)).run())); = xs => xs.length === 0 ? Nil : cons(xs[0])(y(() => fromArray(xs.slice(1))));
export const toArray: <T extends P>(xs: List<T>) => P[] export const toArray: <T extends L>(xs: List<T>) => L[]
= xs => $$(xs(__([]))(_(x => _(xs => __([x, ...toArray(xs)]))))); = xs => $$(xs(__([]))(_(x => _(xs => __([x, ...toArray(xs)])))));
src/num.ts
+4 -4
View File
@@ -1,9 +1,9 @@
import { toNative as $$, L, P, _, fromNative as __, ___, cnst, id, pipe } from './core'; import { toNative as $$, L, _, fromNative as __, cnst, id, pipe, y } from './core';
import { EQ, GT, LT, Ord } from './ord'; import { EQ, GT, LT, Ord } from './ord';
import { Bool, False, True, iif } from './bool'; import { Bool, False, True, iif } from './bool';
import { Empty, String, append, cons } from './string'; import { Empty, String, append, cons } from './string';
export type Num = L<<T extends P>(z: T) => L<(n: L<(p: Num) => T>) => T>>; export type Num = L<<T extends L>(z: T) => L<(n: L<(p: Num) => T>) => T>>;
export const Zero: Num export const Zero: Num
= _(z => _(_n => z)) as Num; = _(z => _(_n => z)) as Num;
@@ -11,7 +11,7 @@ export const Zero: Num
export const Succ: L<(p: Num) => Num> export const Succ: L<(p: Num) => Num>
= _(p => _(_z => _(n => n(p)))); = _(p => _(_z => _(n => n(p))));
export const ifz: L<<T extends P>(n: Num) => L<(t: T) => L<(f: T) => T>>> export const ifz: L<<T extends L>(n: Num) => L<(t: T) => L<(f: T) => T>>>
= _(n => _(t => _(f => n(t)(cnst(f))))); = _(n => _(t => _(f => n(t)(cnst(f)))));
export const succ: L<(n: Num) => Num> export const succ: L<(n: Num) => Num>
@@ -65,7 +65,7 @@ export const show: L<(n: Num) => String>
(append(show(div(n)(fromNumber(10))))(show(mod(n)(fromNumber(10)))))); (append(show(div(n)(fromNumber(10))))(show(mod(n)(fromNumber(10))))));
export const fromNumber: (n: number) => Num export const fromNumber: (n: number) => Num
= n => !n ? Zero : Succ(___(() => fromNumber(n - 1).run())); = n => !n ? Zero : Succ(y(() => fromNumber(n - 1)));
export const toNumber: (n: Num) => number export const toNumber: (n: Num) => number
= n => $$(n(__(0))(_(p => __(1 + toNumber(p))))); = n => $$(n(__(0))(_(p => __(1 + toNumber(p)))));
src/ord.ts
+2 -2
View File
@@ -1,8 +1,8 @@
import { toNative as $$, L, P, _, fromNative as __ } from './core'; import { toNative as $$, L, _, fromNative as __ } from './core';
import { Bool, False, True } from './bool'; import { Bool, False, True } from './bool';
import { String, fromString as _s } from './string'; import { String, fromString as _s } from './string';
export type Ord = L<<T extends P>(lt: T) => L<(eq: T) => L<(gt: T) => T>>>; export type Ord = L<<T extends L>(lt: T) => L<(eq: T) => L<(gt: T) => T>>>;
export const enum NOrd { export const enum NOrd {
LT, LT,
src/pair.ts
+33 -33
View File
@@ -1,82 +1,82 @@
import { L, P, _ } from './core'; import { L, _ } from './core';
import { GT, LT, Ord } from './ord'; import { GT, LT, Ord } from './ord';
import { Bool, False, True, and } from './bool'; import { Bool, False, True, and } from './bool';
import { Nil, concat, cons } from './list'; import { Nil, concat, cons } from './list';
import { String, fromString as _s } from './string'; import { String, fromString as _s } from './string';
export type Pair<F extends P, S extends P> = L<<R extends P>(f: L<(f: F) => L<(s: S) => R>>) => R>; export type Pair<F extends L, S extends L> = L<<R extends L>(f: L<(f: F) => L<(s: S) => R>>) => R>;
export const Pair: L<<F extends P, S extends P>(f: F) => L<(s: S) => Pair<F, S>>> export const Pair: L<<F extends L, S extends L>(f: F) => L<(s: S) => Pair<F, S>>>
= _(<F extends P, S extends P>(f: F) => = _(<F extends L, S extends L>(f: F) =>
_((s: S) => _((s: S) =>
_(<R extends P>(p: L<(f: F) => L<(s: S) => R>>) => p(f)(s)))); _(<R extends L>(p: L<(f: F) => L<(s: S) => R>>) => p(f)(s))));
export const fst: L<<F extends P, S extends P>(p: Pair<F, S>) => F> export const fst: L<<F extends L, S extends L>(p: Pair<F, S>) => F>
= _(p => p(_(f => _(_s => f)))); = _(p => p(_(f => _(_s => f))));
export const snd: L<<F extends P, S extends P>(p: Pair<F, S>) => S> export const snd: L<<F extends L, S extends L>(p: Pair<F, S>) => S>
= _(p => p(_(_f => _(s => s)))); = _(p => p(_(_f => _(s => s))));
export const first: L<<F extends P, FR extends P, S extends P>(t: L<(f: F) => FR>) => L<(p: Pair<F, S>) => Pair<FR, S>>> export const first: L<<F extends L, FR extends L, S extends L>(t: L<(f: F) => FR>) => L<(p: Pair<F, S>) => Pair<FR, S>>>
= _(<F extends P, FR extends P>(t: L<(f: F) => FR>) => = _(<F extends L, FR extends L>(t: L<(f: F) => FR>) =>
_(<S extends P>(p: Pair<F, S>) => p(_(f => _(s => Pair(t(f))(s)))))); _(<S extends L>(p: Pair<F, S>) => p(_(f => _(s => Pair(t(f))(s))))));
export const second: L<<F extends P, S extends P, SR extends P>(t: L<(s: S) => SR>) => L<(p: Pair<F, S>) => Pair<F, SR>>> export const second: L<<F extends L, S extends L, SR extends L>(t: L<(s: S) => SR>) => L<(p: Pair<F, S>) => Pair<F, SR>>>
= _(<S extends P, SR extends P>(t: L<(s: S) => SR>) => = _(<S extends L, SR extends L>(t: L<(s: S) => SR>) =>
_(<F extends P>(p: Pair<F, S>) => p(_(f => _(s => Pair(f)(t(s))))))); _(<F extends L>(p: Pair<F, S>) => p(_(f => _(s => Pair(f)(t(s)))))));
export const both: L<<F extends P, FR extends P, S extends P, SR extends P>(tf: L<(f: F) => FR>) => L<(ts: L<(s: S) => SR>) => L<(p: Pair<F, S>) => Pair<FR, SR>>>> export const both: L<<F extends L, FR extends L, S extends L, SR extends L>(tf: L<(f: F) => FR>) => L<(ts: L<(s: S) => SR>) => L<(p: Pair<F, S>) => Pair<FR, SR>>>>
= _(<F extends P, FR extends P>(tf: L<(f: F) => FR>) => = _(<F extends L, FR extends L>(tf: L<(f: F) => FR>) =>
_(<S extends P, SR extends P>(ts: L<(s: S) => SR>) => _(<S extends L, SR extends L>(ts: L<(s: S) => SR>) =>
_((p: Pair<F, S>) => p(_(f => _(s => Pair(tf(f))(ts(s)))))))); _((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>> export const uncurry: L<<F extends L, S extends L, R extends L>(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>>) => = _(<F extends L, S extends L, R extends L>(t: L<(f: F) => L<(s: S) => R>>) =>
_((p: Pair<F, S>) => p(t))); _((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>>>> export const cmp: L<<F extends L, S extends L>(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>>) => = _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) => _((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) => uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) => uncurry(_((rf: F) => _((rs: S) =>
fcmp(lf)(rf)(LT)(scmp(ls)(rs))(GT))))))))); fcmp(lf)(rf)(LT)(scmp(ls)(rs))(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>>>> export const lt: L<<F extends L, S extends L>(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>>) => = _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) => _((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) => uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) => uncurry(_((rf: F) => _((rs: S) =>
fcmp(lf)(rf)(True)(scmp(ls)(rs)(True)(False)(False))(False))))))))); fcmp(lf)(rf)(True)(scmp(ls)(rs)(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>>>> export const le: L<<F extends L, S extends L>(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>>) => = _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) => _((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) => uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) => uncurry(_((rf: F) => _((rs: S) =>
fcmp(lf)(rf)(True)(scmp(ls)(rs)(True)(True)(False))(False))))))))); fcmp(lf)(rf)(True)(scmp(ls)(rs)(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>>>> export const eq: L<<F extends L, S extends L>(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>>) => = _(<F extends L, S extends L>(feq: L<(l: F) => L<(r: F) => Bool>>) =>
_((seq: L<(l: S) => L<(r: S) => Bool>>) => _((seq: L<(l: S) => L<(r: S) => Bool>>) =>
uncurry(_((lf: F) => _((ls: S) => uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) => uncurry(_((rf: F) => _((rs: S) =>
and(feq(lf)(rf))(seq(ls)(rs)))))))))); and(feq(lf)(rf))(seq(ls)(rs))))))))));
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>>>> export const ge: L<<F extends L, S extends L>(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>>) => = _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) => _((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) => uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) => uncurry(_((rf: F) => _((rs: S) =>
fcmp(lf)(rf)(False)(scmp(ls)(rs)(False)(True)(True))(True))))))))); fcmp(lf)(rf)(False)(scmp(ls)(rs)(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>>>> export const gt: L<<F extends L, S extends L>(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>>) => = _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) => _((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) => uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) => uncurry(_((rf: F) => _((rs: S) =>
fcmp(lf)(rf)(False)(scmp(ls)(rs)(False)(False)(True))(True))))))))); fcmp(lf)(rf)(False)(scmp(ls)(rs)(False)(False)(True))(True)))))))));
export const show: L<<F extends P, S extends P>(fshow: L<(f: F) => String>) => L<(sshow: L<(s: S) => String>) => L<(p: Pair<F, S>) => String>>> export const show: L<<F extends L, S extends L>(fshow: L<(f: F) => String>) => L<(sshow: L<(s: S) => String>) => L<(p: Pair<F, S>) => String>>>
= _(<F extends P>(fshow: L<(f: F) => String>) => = _(<F extends L>(fshow: L<(f: F) => String>) =>
_(<S extends P>(sshow: L<(s: S) => String>) => _(<S extends L>(sshow: L<(s: S) => String>) =>
uncurry(_((f: F) => _((s: S) => concat(cons(_s('('))(cons(fshow(f))(cons(_s(', '))(cons(sshow(s))(cons(_s(')'))(Nil))))))))))); uncurry(_((f: F) => _((s: S) => concat(cons(_s('('))(cons(fshow(f))(cons(_s(', '))(cons(sshow(s))(cons(_s(')'))(Nil)))))))))));
src/string.ts
+2 -2
View File
@@ -1,4 +1,4 @@
import { toNative as $$, L, _, fromNative as __, ___ } from './core'; import { toNative as $$, L, _, fromNative as __, y } from './core';
import { Ord } from './ord'; import { Ord } from './ord';
import { Bool } from './bool'; import { Bool } from './bool';
import { fromNumber as _nn } from './num'; import { fromNumber as _nn } from './num';
@@ -31,7 +31,7 @@ export const wrap: L<(w: String) => L<(c: String) => String>>
= _(w => _(c => append(w)(append(c)(w)))); = _(w => _(c => append(w)(append(c)(w))));
export const fromString: (xs: string) => String export const fromString: (xs: string) => String
= xs => xs.length === 0 ? Nil : Cons(_c(xs[0]))(___(() => fromString(xs.slice(1)).run())); = xs => xs.length === 0 ? Nil : Cons(_c(xs[0]))(y(() => fromString(xs.slice(1))));
export const toString: (xs: String) => string export const toString: (xs: String) => string
= xs => $$(xs(__(''))(_(x => _(xs => __($c(x) + toString(xs)))))); = xs => $$(xs(__(''))(_(x => _(xs => __($c(x) + toString(xs))))));
test/list.spec.ts
+3 -3
View File
@@ -1,5 +1,5 @@
import { describe, expect, it } from '@jest/globals'; import { describe, expect, it } from '@jest/globals';
import { toNative as $$, _, fromNative as __, ___, undef } from '../src/core'; import { toNative as $$, _, fromNative as __, undef, y } from '../src/core';
import { toNOrd as $o, NOrd } from '../src/ord'; import { toNOrd as $o, NOrd } from '../src/ord';
import { toBoolean as $b, iif } from '../src/bool'; import { toBoolean as $b, iif } from '../src/bool';
import { toNumber as $n, toNumber as $nn, Num, Succ, Zero, fromNumber as _n, fromNumber as _nn, cmp as cmpn, eq as eqn, even, gt as ngt, show as nshow, odd, succ, sum } from '../src/num'; import { toNumber as $n, toNumber as $nn, Num, Succ, Zero, fromNumber as _n, fromNumber as _nn, cmp as cmpn, eq as eqn, even, gt as ngt, show as nshow, odd, succ, sum } from '../src/num';
@@ -11,7 +11,7 @@ describe('List', () => {
const infinite: List<Num> = iterate(Succ)(Zero); const infinite: List<Num> = iterate(Succ)(Zero);
const _na: (xs: number[]) => List<Num> const _na: (xs: number[]) => List<Num>
= xs => xs.length === 0 ? Nil : Cons(_nn(xs[0]))(___(() => _na(xs.slice(1)).run())); = xs => xs.length === 0 ? Nil : Cons(_nn(xs[0]))(y(() => _na(xs.slice(1))));
const $na: (xs: List<Num>) => number[] const $na: (xs: List<Num>) => number[]
= xs => $$(xs(__([]))(_(x => _(xs => __([$nn(x), ...$na(xs)]))))); = xs => $$(xs(__([]))(_(x => _(xs => __([$nn(x), ...$na(xs)])))));
@@ -158,7 +158,7 @@ describe('List', () => {
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
const dinfinite: List<Num> = cons(infinite)(___(() => dinfinite.run())); const dinfinite: List<Num> = cons(infinite)(y(() => dinfinite));
expect($n(concat(dinfinite)(undef)(_(x => _(_xs => x))))).toBe(0); expect($n(concat(dinfinite)(undef)(_(x => _(_xs => x))))).toBe(0);
}); });
}); });
test/num.spec.ts
+2 -2
View File
@@ -1,12 +1,12 @@
import { describe, expect, it } from '@jest/globals'; import { describe, expect, it } from '@jest/globals';
import { ___, undef } from '../src/core'; import { undef, y } from '../src/core';
import { toNOrd as $o, NOrd } from '../src/ord'; import { toNOrd as $o, NOrd } from '../src/ord';
import { toBoolean as $b, fromBoolean as _b } from '../src/bool'; import { toBoolean as $b, fromBoolean as _b } from '../src/bool';
import { toNumber as $n, Num, Succ, Zero, fromNumber as _n, cmp, div, eq, ge, gt, ifz, le, lt, mod, mul, pred, show, sub, succ, sum } from '../src/num'; import { toNumber as $n, Num, Succ, Zero, fromNumber as _n, cmp, div, eq, ge, gt, ifz, le, lt, mod, mul, pred, show, sub, succ, sum } from '../src/num';
import { toString as $s } from '../src/string'; import { toString as $s } from '../src/string';
describe('Num', () => { describe('Num', () => {
const infinity: Num = ___(() => Succ(infinity).run()); const infinity: Num = y(() => Succ(infinity));
describe('toNumber', () => { describe('toNumber', () => {
it('converts 0', () => { it('converts 0', () => {
test/string.spec.ts
+2 -2
View File
@@ -1,5 +1,5 @@
import { describe, expect, it } from '@jest/globals'; import { describe, expect, it } from '@jest/globals';
import { _, ___, undef } from '../src/core'; import { _, undef, y } from '../src/core';
import { NOrd, toNOrd } from '../src/ord'; import { NOrd, toNOrd } from '../src/ord';
import { toBoolean as $b } from '../src/bool'; import { toBoolean as $b } from '../src/bool';
import { toNumber as $n, Zero, gt as ngt } from '../src/num'; import { toNumber as $n, Zero, gt as ngt } from '../src/num';
@@ -7,7 +7,7 @@ import { toChar as $c, fromChar as _c } from '../src/char';
import { toString as $s, Cons, Empty, String, fromString as _s, append, cmp, empty, eq, ge, gt, le, len, lt, show, wrap } from '../src/string'; import { toString as $s, Cons, Empty, String, fromString as _s, append, cmp, empty, eq, ge, gt, le, len, lt, show, wrap } from '../src/string';
describe('String', () => { describe('String', () => {
const infinite: String = Cons(_c('a'))(___(() => infinite.run())); const infinite: String = Cons(_c('a'))(y(() => infinite));
describe('toString', () => { describe('toString', () => {
it('converts ""', () => { it('converts ""', () => {