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

Cleanup

Browse Source
master
Freywar Ulvnaudgari 2 years ago
parent b883515a5f
commit 114f32cdc7
13 changed files with 130 additions and 132 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 1
      eslint.config.mjs
  2. 6
      src/bool.ts
  3. 41
      src/core.ts
  4. 4
      src/debug.ts
  5. 8
      src/index.ts
  6. 106
      src/list.ts
  7. 8
      src/num.ts
  8. 4
      src/ord.ts
  9. 66
      src/pair.ts
  10. 4
      src/string.ts
  11. 6
      test/list.spec.ts
  12. 4
      test/num.spec.ts
  13. 4
      test/string.spec.ts

1
eslint.config.mjs
Unescape View File

@ -34,6 +34,7 @@ export default [
'@stylistic/semi': ['error', 'always'],
'@stylistic/indent': 'error',
'@stylistic/arrow-parens': ['error', 'as-needed', { requireForBlockBody: false }],
'@stylistic/max-statements-per-line': 'off',
'@typescript-eslint/no-unused-vars': [
'error',
{

6
src/bool.ts
Unescape 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 { 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
= _(t => _(_f => t)) as Bool;
@ -10,7 +10,7 @@ export const True: Bool
export const False: Bool
= _(_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;
export const not: L<(b: Bool) => Bool>

41
src/core.ts
Unescape 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> {
const r: T = ((p: Parameters<T>[0]) => {
let v: any;
return ___(() => run()(
___(() => v ??= p.run()),
).run());
}) as T;
export type L<T extends F = F> = T & { run: () => 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 type P = L<(v: unknown) => L<any>>;
export const _ = <T extends ((v: unknown) => L<any>)>(v: T): L<T> => ___(() => v);
export const _ = <T extends F>(v: T): L<T> => defer(() => v);
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
= <T>(v: L<any>) => v.run() as T;
export const undef: any = ___(() => {
throw new Error('undefined');
});
export const y = (f: () => L<F>) => defer(() => f().run());
export const undef: any = defer(() => { throw new Error('undefined'); });
export const id: L<<T extends P>(v: T) => T>
export const id: L<<T extends L>(v: T) => T>
= _(v => v);
export const cnst: L<<T extends P>(v: T) => L<(_: unknown) => T>>
= _(v => _(_ => v)) as L<<T extends P>(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>>>
= _(<A extends P, B extends P, C extends P>(f: L<(v: B) => C>) =>
export const cnst: L<<T extends L>(v: T) => L<(_: unknown) => T>>
= _(v => _(_ => v)) as L<<T extends L>(v: T) => L<(_: unknown) => T>>;
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 L, B extends L, C extends L>(f: L<(v: B) => C>) =>
_((g: L<(v: A) => B>) =>
_((v: A) => f(g(v)))));

4
src/debug.ts
Unescape View File

@ -1,7 +1,7 @@
import { L, P, _ } from './core';
import { L, _ } from './core';
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 => {
console.log(toString(s));
return p;

8
src/index.ts
Unescape 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(''))));

106
src/list.ts
Unescape 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 { Bool, False, True, and, iif, or } from './bool';
import { Num, Zero, succ } from './num';
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>
= _(z => _(_f => z)) as List<any>;
export const Cons: L<<T extends P>(x: T) => L<(xs: List<T>) => List<T>>>
= _(<T extends P>(x: T) => _((xs: List<T>) => _(_z => _(f => f(x)(xs))) as List<T>));
export const Cons: L<<T extends L>(x: T) => L<(xs: List<T>) => 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;
export const snoc: L<<T extends P>(xs: List<T>) => L<(x: T) => List<T>>>
= _(<T extends P>(xs: List<T>) =>
export const snoc: L<<T extends L>(xs: List<T>) => L<(x: T) => List<T>>>
= _(<T extends L>(xs: List<T>) =>
_((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))));
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))));
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));
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)))))));
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))));
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)));
export const iterate: L<<T extends P>(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)))));
export const iterate: L<<T extends L>(f: L<(x: T) => T>) => L<(x: T) => List<T>>>
= _(<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));
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)));
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>>>
= _(<T extends P, R extends P>(f: L<(a: R) => L<(x: 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 L, R extends L>(f: L<(a: R) => L<(x: T) => R>>) =>
_((z: R) =>
_((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>>
= _(<T extends P>(f: L<(a: T) => L<(x: T) => T>>) => _((xs: List<T>) => xs(undef)(foldl(f))));
export const foldlz: L<<T extends L>(f: L<(a: T) => L<(x: T) => T>>) => L<(xs: List<T>) => T>>
= _(<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>>>
= _(<T extends P, R extends P>(f: L<(x: T) => L<(a: R) => 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 L, R extends L>(f: L<(x: T) => L<(a: R) => R>>) =>
_((z: R) =>
_((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;
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>>) =>
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 L>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
_((l: List<T>) =>
_((r: List<T>) => l
(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))
(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>>) =>
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 L>(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>>) =>
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 L>(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>>) =>
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 L>(eeq: L<(l: T) => L<(r: T) => Bool>>) =>
_((l: List<T>) =>
_((r: List<T>) => l
(r(True)(cnst(cnst(False))))
(_(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>>) =>
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 L>(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>>) =>
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 L>(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>) =>
export const map: L<<T extends L, R extends L>(f: L<(x: T) => R>) => L<(xs: List<T>) => List<R>>>
= _(<T extends L, R extends L>(f: L<(x: T) => R>) =>
_((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>>>
= _(<T extends P>(f: L<(x: T) => Bool>) =>
export const filter: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => List<T>>>
= _(<T extends L>(f: L<(x: T) => Bool>) =>
_((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>>
= _(<T extends P>(f: L<(x: T) => Bool>) =>
export const any: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>>
= _(<T extends L>(f: L<(x: T) => Bool>) =>
_((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>>
= _(<T extends P>(f: L<(x: T) => Bool>) =>
export const all: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>>
= _(<T extends L>(f: L<(x: T) => Bool>) =>
_((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)))));
export const update: L<<T extends P>(f: L< (p: T) => T>) => L<(i: Num) => L<(xs: List<T>) => List<T>>>>
= _(<T extends P>(f: L< (p: T) => T>) =>
export const update: L<<T extends L>(f: L< (p: T) => T>) => L<(i: Num) => L<(xs: List<T>) => List<T>>>>
= _(<T extends L>(f: L< (p: T) => T>) =>
_((i: Num) =>
_((xs: List<T>) =>
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);
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)))))))))));
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(']')))));
export const fromArray: <T extends P>(xs: T[]) => List<T>
= xs => xs.length === 0 ? Nil : cons(xs[0])(___(() => fromArray(xs.slice(1)).run()));
export const fromArray: <T extends L>(xs: T[]) => List<T>
= 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)])))));

8
src/num.ts
Unescape 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 { Bool, False, True, iif } from './bool';
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
= _(z => _(_n => z)) as Num;
@ -11,7 +11,7 @@ export const Zero: Num
export const Succ: L<(p: Num) => Num>
= _(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)))));
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))))));
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
= n => $$(n(__(0))(_(p => __(1 + toNumber(p)))));

4
src/ord.ts
Unescape 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 { 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 {
LT,

66
src/pair.ts
Unescape View File

@ -1,82 +1,82 @@
import { L, P, _ } from './core';
import { L, _ } from './core';
import { GT, LT, Ord } from './ord';
import { Bool, False, True, and } from './bool';
import { Nil, concat, cons } from './list';
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>>>
= _(<F extends P, S extends P>(f: F) =>
export const Pair: L<<F extends L, S extends L>(f: F) => L<(s: S) => Pair<F, S>>>
= _(<F extends L, S extends L>(f: F) =>
_((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))));
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))));
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>>>
= _(<F extends P, FR extends P>(t: L<(f: F) => FR>) =>
_(<S extends P>(p: Pair<F, S>) => p(_(f => _(s => Pair(t(f))(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 L, FR extends L>(t: L<(f: F) => FR>) =>
_(<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>>>
= _(<S extends P, SR extends P>(t: L<(s: S) => SR>) =>
_(<F extends P>(p: Pair<F, S>) => p(_(f => _(s => Pair(f)(t(s)))))));
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 L, SR extends L>(t: L<(s: S) => SR>) =>
_(<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>>>>
= _(<F extends P, FR extends P>(tf: L<(f: F) => FR>) =>
_(<S extends P, SR extends P>(ts: L<(s: S) => 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 L, FR extends L>(tf: L<(f: F) => FR>) =>
_(<S extends L, SR extends L>(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>>) =>
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 L, S extends L, R extends L>(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>>) =>
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 L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) =>
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>>>>
= _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
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 L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) =>
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>>>>
= _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
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 L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) =>
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>>>>
= _(<F extends P, S extends P>(feq: L<(l: F) => L<(r: F) => 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 L, S extends L>(feq: L<(l: F) => L<(r: F) => Bool>>) =>
_((seq: L<(l: S) => L<(r: S) => Bool>>) =>
uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) =>
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>>>>
= _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
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 L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) =>
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>>>>
= _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
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 L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) =>
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>>>
= _(<F extends P>(fshow: L<(f: F) => String>) =>
_(<S extends P>(sshow: L<(s: 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 L>(fshow: L<(f: F) => 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)))))))))));

4
src/string.ts
Unescape 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 { Bool } from './bool';
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))));
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
= xs => $$(xs(__(''))(_(x => _(xs => __($c(x) + toString(xs))))));

6
test/list.spec.ts
Unescape View File

@ -1,5 +1,5 @@
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 { 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';
@ -11,7 +11,7 @@ describe('List', () => {
const infinite: List<Num> = iterate(Succ)(Zero);
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[]
= xs => $$(xs(__([]))(_(x => _(xs => __([$nn(x), ...$na(xs)])))));
@ -158,7 +158,7 @@ describe('List', () => {
});
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);
});
});

4
test/num.spec.ts
Unescape View File

@ -1,12 +1,12 @@
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 { 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 { toString as $s } from '../src/string';
describe('Num', () => {
const infinity: Num = ___(() => Succ(infinity).run());
const infinity: Num = y(() => Succ(infinity));
describe('toNumber', () => {
it('converts 0', () => {

4
test/string.spec.ts
Unescape View File

@ -1,5 +1,5 @@
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 { toBoolean as $b } from '../src/bool';
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';
describe('String', () => {
const infinite: String = Cons(_c('a'))(___(() => infinite.run()));
const infinite: String = Cons(_c('a'))(y(() => infinite));
describe('toString', () => {
it('converts ""', () => {

Write Preview
Loading…
Cancel
Save