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

Custom engine

Browse Source
master
Freywar Ulvnaudgari 2 years ago
parent 114f32cdc7
commit df0dc199a0
32 changed files with 1181 additions and 1093 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. 2
      eslint.config.mjs
  2. 98
      src/bf.ts
  3. 7
      src/bool.show.ts
  4. 55
      src/bool.ts
  5. 5
      src/byte.show.ts
  6. 35
      src/byte.ts
  7. 7
      src/char.show.ts
  8. 19
      src/char.ts
  9. 251
      src/core.ts
  10. 38
      src/debug.ts
  11. 19
      src/index.ts
  12. 7
      src/list.show.ts
  13. 210
      src/list.ts
  14. 7
      src/log.ts
  15. 8
      src/num.show.ts
  16. 74
      src/num.ts
  17. 6
      src/ord.show.ts
  18. 33
      src/ord.ts
  19. 8
      src/pair.show.ts
  20. 86
      src/pair.ts
  21. 7
      src/string.show.ts
  22. 45
      src/string.ts
  23. 20
      test/bf.spec.ts
  24. 103
      test/bool.spec.ts
  25. 211
      test/byte.spec.ts
  26. 81
      test/char.spec.ts
  27. 8
      test/core.spec.ts
  28. 348
      test/list.spec.ts
  29. 191
      test/num.spec.ts
  30. 111
      test/pair.spec.ts
  31. 173
      test/string.spec.ts
  32. 1
      test/tsconfig.json

2
eslint.config.mjs
Unescape View File

@ -30,11 +30,13 @@ export default [
'no-extra-parens': ['error', 'all'], 'no-extra-parens': ['error', 'all'],
'no-unexpected-multiline': 'off', 'no-unexpected-multiline': 'off',
'sort-imports': ['error', { ignoreDeclarationSort: true }], 'sort-imports': ['error', { ignoreDeclarationSort: true }],
'@stylistic/brace-style': ['error', '1tbs', { allowSingleLine: true }],
'@stylistic/quotes': ['error', 'single'], '@stylistic/quotes': ['error', 'single'],
'@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', '@stylistic/max-statements-per-line': 'off',
'@stylistic/member-delimiter-style': 'error',
'@typescript-eslint/no-unused-vars': [ '@typescript-eslint/no-unused-vars': [
'error', 'error',
{ {

98
src/bf.ts
Unescape View File

@ -1,82 +1,58 @@
import { L, _, fromNative as __, cnst, id, pipe } from './core'; import { _, cnst, g, id, l, m, pipe, r } from './core';
import { Bool, iif } from './bool'; import { iif } from './bool';
import { Num, Zero, ge, ifz, pred, succ } from './num'; import { Zero, ge, ifz, pred, succ } from './num';
import { x00 } from './byte'; import { x00 } from './byte';
import { Char, fromChar as _c, dec as cdec, inc as cinc, eq, ifn } from './char'; import { fromChar as _c, dec as cdec, inc as cinc, eq, ifn } from './char';
import { Pair, first, fst, second, snd, uncurry } from './pair'; import { Pair, first, fst, second, snd, uncurry } from './pair';
import { List, cons, head, repeat, set, singleton, tail, update } from './list'; import { cons, head, repeat, set, singleton, tail, update } from './list';
import { Empty, String, get, len, snoc } from './string'; import { Empty, get, len, snoc } from './string';
type Program = Pair<List<Num>, String>; m('bf');
type Tape = Pair<Num, List<Char>>; const done = g('done', uncurry._(l('p', cnst._(uncurry._(l('is', l('cs', ge._(head._('is'))._(len._('cs')))))._('p')))));
type IO = Pair<String, String>; const command = g('command', l('c', uncurry._(l('p', cnst._(eq._('c')._(uncurry._(pipe._(get)._(head))._('p')))))));
type State = Pair<Program, Pair<Tape, IO>>; const advance = g('advance', first._(first._(update._(succ)._(Zero))));
const done: L<(s: State) => Bool> const save = g('save', first._(first._(l('is', cons._(head._('is'))._('is')))));
= uncurry(_(p => cnst(uncurry(_(is => _(cs => ge(head(is))(len(cs)))))(p))));
const command: L<(c: String) => L<(s: State) => Bool>> const restore = g('restore', first._(first._(tail)));
= _(c => uncurry(_(p => cnst(eq(c)(uncurry(pipe(get)(head))(p))))));
const advance: L<(s: State) => State> const reset = g('reset', first._(first._(l('is', cons._(head._('is'))._(tail._(tail._('is')))))));
= first(first(update(succ)(Zero)));
const save: L<(s: State) => State> const inc = g('inc', second._(first._(l('t', second._(update._(cinc)._(fst._('t')))._('t')))));
= first(first(_(is => cons(head(is))(is))));
const restore: L<(s: State) => State> const dec = g('dec', second._(first._(l('t', second._(update._(cdec)._(fst._('t')))._('t')))));
= first(first(tail));
const reset: L<(s: State) => State> const read = g('read', pipe._(pipe._(uncurry._(get))._(fst))._(snd));
= first(first(_(is => cons(head(is))(tail(tail(is))))));
const inc: L<(t: State) => State> const input = g('input', second._(uncurry._(l('t', l('io', Pair._(second._(set._(head._(fst._('io')))._(fst._('t')))._('t'))._(first._(tail)._('io')))))));
= second(first(_(t => second(update(cinc)(fst(t)))(t))));
const dec: L<(t: State) => State> const output = g('output', second._(uncurry._(l('t', pipe._(Pair._('t'))._(second._(l('os', snoc._('os')._(uncurry._(get)._('t')))))))));
= second(first(_(t => second(update(cdec)(fst(t)))(t))));
const read: L<(s: State) => Char> const next = g('next', second._(first._(first._(succ))));
= pipe(pipe(uncurry(get))(fst))(snd);
const input: L<(s: State) => State> const prev = g('prev', second._(first._(first._(pred))));
= second(uncurry(_(t => _(io => Pair(second(set(head(fst(io)))(fst(t)))(t))(first(tail)(io))))));
const output: L<(s: State) => State> const jump = g('jump', l('d', l('s',
= second(uncurry(_(t => pipe(Pair(t))(second(_(os => snoc(os)(uncurry(get)(t)))))))); iif._(command._(_c('['))._('s'))._(r('bf::jump')._(succ._('d')))
._(iif._(command._(_c(']'))._('s'))._(ifz._(pred._('d'))._(cnst._('s'))._(r('bf::jump')._(pred._('d'))))
._(r('bf::jump')._('d')))._(advance._('s')))));
const next: L<(t: State) => State> const whlnz = g('whlnz', l('s', ifn._(read._('s'))._(jump._(Zero))._(save)._('s')));
= second(first(first(succ)));
const prev: L<(t: State) => State> const endwhl = g('endwhl', l('s', ifn._(read._('s'))._(reset)._(pipe._(save)._(restore))._('s')));
= second(first(first(pred)));
const jump: L<(d: Num) => L<(s: State) => State>> const exec = g('exec', l('s', iif._(done._('s'))._('s')._(r('bf::exec')._(advance
= _(d => _(s => ._(iif._(command._(_c('>'))._('s'))._(next)
iif(command(_c('['))(s))(jump(succ(d))) ._(iif._(command._(_c('<'))._('s'))._(prev)
(iif(command(_c(']'))(s))(ifz(pred(d))(cnst(s))(jump(pred(d)))) ._(iif._(command._(_c('+'))._('s'))._(inc)
(jump(d)))(advance(s)))); ._(iif._(command._(_c('-'))._('s'))._(dec)
._(iif._(command._(_c('.'))._('s'))._(output)
._(iif._(command._(_c(','))._('s'))._(input)
._(iif._(command._(_c('['))._('s'))._(whlnz)
._(iif._(command._(_c(']'))._('s'))._(endwhl)
._(id))))))))._('s'))))));
const whlnz: L<(t: State) => State> export const run = g('run', l('p', l('i', snd._(snd._(snd._(exec._(Pair._(Pair._(singleton._(Zero))._('p'))._(Pair._(Pair._(Zero)._(repeat._(x00)))._(Pair._('i')._(Empty))))))))));
= _(s => ifn(read(s))(jump(Zero))(save)(s));
const endwhl: L<(t: State) => State>
= _(s => ifn(read(s))(reset)(pipe(save)(restore))(s));
const exec: L<(s: State) => State>
= _(s => iif<State>(done(s))(s)(exec(advance
(iif(command(_c('>'))(s))(next)
(iif(command(_c('<'))(s))(prev)
(iif(command(_c('+'))(s))(inc)
(iif(command(_c('-'))(s))(dec)
(iif(command(_c('.'))(s))(output)
(iif(command(_c(','))(s))(input)
(iif(command(_c('['))(s))(whlnz)
(iif(command(_c(']'))(s))(endwhl)
(id))))))))(s)))));
export const run: L<(p: String) => L<(i: String) => String>>
= _(p => _(i => snd(snd(snd(exec(Pair(Pair(singleton(Zero))(p))(Pair(Pair(Zero)(repeat(x00)))(Pair(i)(Empty)))))))));

7
src/bool.show.ts
Unescape View File

@ -0,0 +1,7 @@
import { m, g, l } from './core';
import { iif } from './bool';
import { fromString as _s } from './string';
m('bool.show');
export const show = g('show', l('b', iif._('b')._(_s('True'))._(_s('False'))));

55
src/bool.ts
Unescape View File

@ -1,53 +1,34 @@
import { toNative as $$, L, _, fromNative as __, id, pipe } from './core'; import { $, Term, _, c, g, id, l, m, pipe } from './core';
import { EQ, GT, LT, Ord } from './ord'; import { EQ, GT, LT } from './ord';
import { String, fromString as _s } from './string';
export type Bool = L<<T extends L>(t: T) => L<(f: T) => T>>; m('bool');
export const True: Bool export const True = g('True', l('t', l('_', 't')));
= _(t => _(_f => t)) as Bool;
export const False: Bool export const False = g('False', l('_', l('f', 'f')));
= _(_t => _(f => f));
export const iif: L<<T extends L>(b: Bool) => L<(t: T) => L<(f: T) => T>>> export const iif = g('iif', id);
= id;
export const not: L<(b: Bool) => Bool> export const not = g('not', l('b', c('b', False, True)));
= _(b => b(False)(True));
export const cmp: L<(l: Bool) => L<(r: Bool) => Ord>> export const cmp = g('cmp', l('l', l('r', c('l', c('r', EQ, GT), c('r', LT, EQ)))));
= _(l => _(r => l(r(EQ)(GT))(r(LT)(EQ))));
export const lt: L<(l: Bool) => L<(r: Bool) => Bool>> export const lt = g('lt', l('l', c('l', False)));
= _(l => l(False));
export const le: L<(l: Bool) => L<(r: Bool) => Bool>> export const le = g('le', l('l', not._('l')._(True)));
= _(l => not(l)(True));
export const eq: L<(l: Bool) => L<(r: Bool) => Bool>> export const eq = g('eq', l('l', l('r', c('l', 'r', not._('r')))));
= _(l => _(r => l(r)(not(r))));
export const ge: L<(l: Bool) => L<(r: Bool) => Bool>> export const ge = g('ge', l('l', pipe._(not)._(lt._('l'))));
= _(l => pipe(not)(lt(l)));
export const gt: L<(l: Bool) => L<(r: Bool) => Bool>> export const gt = g('gt', l('l', pipe._(not)._(le._('l'))));
= _(l => pipe(not)(le(l)));
export const and: L<(l: Bool) => L<(r: Bool) => Bool>> export const and = g('and', l('l', not._('l')._(False)));
= _(l => not(l)(False));
export const or: L<(l: Bool) => L<(r: Bool) => Bool>> export const or = g('or', l('l', c('l', True)));
= _(l => l(True));
export const xor: L<(l: Bool) => L<(r: Bool) => Bool>> export const xor = g('xor', l('l', l('r', c('l', not._('r'), 'r'))));
= _(l => _(r => l(not(r))(r)));
export const show: L<(b: Bool) => String> export const fromBoolean: (b: boolean) => Term = b => b ? True : False;
= _(b => iif(b)(_s('True'))(_s('False')));
export const fromBoolean: (b: boolean) => Bool export const toBoolean: (b: Term) => boolean = b => $(b._(_(true))._(_(false)).reduce());
= b => b ? True : False;
export const toBoolean: (b: Bool) => boolean
= b => $$(b(__(true))(__(false)));

5
src/byte.show.ts
Unescape View File

@ -0,0 +1,5 @@
import { m } from './core';
m('byte.show');
export { show } from './num.show';

35
src/byte.ts
Unescape View File

@ -1,34 +1,25 @@
import { L, _, id } from './core'; import { Term, _, g, id, l, m, r } from './core';
import { iif } from './bool'; import { iif } from './bool';
import { Num, Succ, Zero, fromNumber as _n, eq } from './num'; import { Succ, Zero, fromNumber as _n, eq } from './num';
export type Byte = Num; m('byte');
export const x00: Byte export const x00 = g('x00', Zero);
= Zero;
export const xFF: Num export const xFF = g('xFF', _n(255));
= _n(255);
export const Inc: L<(p: Byte) => Byte> export const Inc = g('Inc', l('p', iif._(eq._(xFF)._('p'))._(x00)._(Succ._('p'))));
= _(p => iif(eq(xFF)(p))(x00)(Succ(p)));
export { ifz, cmp, lt, le, eq, ge, gt, even, odd, div, mod, show, toNumber } from './num'; export { ifz, cmp, lt, le, eq, ge, gt, even, odd, div, mod, toNumber } from './num';
export const inc: L<(n: Byte) => Byte> export const inc = g('inc', Inc);
= Inc;
export const dec: L<(n: Byte) => Byte> export const dec = g('dec', l('n', r('n')._(xFF)._(id)));
= _(n => n(xFF)(id));
export const sum: L<(l: Byte) => L<(r: Byte) => Byte>> export const sum = g('sum', l('l', l('r', r('r')._('l')._(r('byte::sum')._(inc._('l'))))));
= _(l => _(r => r(l)(sum(inc(l)))));
export const sub: L<(l: Byte) => L<(r: Byte) => Byte>> export const sub = g('sub', l('l', l('r', r('r')._('l')._(r('byte::sub')._(dec._('l'))))));
= _(l => _(r => r(l)(sub(dec(l)))));
export const mul: L<(l: Byte) => L<(r: Byte) => Byte>> export const mul = g('mul', l('l', l('r', r('l')._(x00)._(l('pl', sum._('r')._(r('byte::mul')._('pl')._('r')))))));
= _(l => _(r => l(x00)(_(pl => sum(r)(mul(pl)(r))))));
export const fromNumber: (n: number) => Byte export const fromNumber: (n: number) => Term = n => _n(n % 256);
= n => _n(n % 256);

7
src/char.show.ts
Unescape View File

@ -0,0 +1,7 @@
import { g, l, m, pipe } from './core';
import { singleton } from './list';
import { wrap, fromString as _s } from './string';
m('char.show');
export const show = g('show', l('c', pipe._(wrap._(_s('\'')))._(singleton)._('c')));

19
src/char.ts
Unescape View File

@ -1,20 +1,13 @@
import { L, _, pipe } from './core'; import { Term, g, l, m, pipe } from './core';
import { toNumber as $n, Byte, fromNumber as _n, x00 } from './byte'; import { toNumber as $n, fromNumber as _n, x00 } from './byte';
import { singleton } from './list'; import { singleton } from './list';
import { String, fromString as _s, wrap } from './string';
export type Char = Byte; m('char');
export const Null: Char export const Null = g('Null', x00);
= x00;
export { inc, dec, ifz as ifn, cmp, lt, le, eq, ge, gt } from './byte'; export { inc, dec, ifz as ifn, cmp, lt, le, eq, ge, gt } from './byte';
export const show: L<(c: Char) => String> export const fromChar: (c: string) => Term = c => _n(c.charCodeAt(0));
= _(c => pipe(wrap(_s('\'')))(singleton)(c));
export const fromChar: (c: string) => Char export const toChar: (c: Term) => string = c => String.fromCharCode($n(c));
= c => _n(c.charCodeAt(0));
export const toChar: (c: Char) => string
= c => String.fromCharCode($n(c));

251
src/core.ts
Unescape View File

@ -1,29 +1,236 @@
type F = (v: L) => L<any>; import { withLog } from './debug';
export type L<T extends F = F> = T & { run: () => T }; let index = 0;
const defer: <T extends F>(run: () => T) => L<T> = <T extends F>(run: () => T) => export abstract class Term {
Object.assign(((p: Parameters<T>[0]): ReturnType<T> => { protected id = index++;
let v: F; protected cache: Term | null = null;
return defer(() => run()(defer(() => v ??= p.run())).run());
}) as T, { run });
export const _ = <T extends F>(v: T): L<T> => defer(() => v); public constructor(protected bindings: Record<string, Term>) { }
export const fromNative: <T>(v: T) => L<any> public refs(_name: string): boolean {
= v => defer(() => v as any); return false;
export const toNative: <T>(v: L<any>) => T };
= <T>(v: L<any>) => v.run() as T;
export const y = (f: () => L<F>) => defer(() => f().run()); public bind(_name: string, _term: Term): Term {
return this;
}
export const undef: any = defer(() => { throw new Error('undefined'); }); public reduce(): Term {
return this;
}
export const id: L<<T extends L>(v: T) => T> public context(): string {
= _(v => v); return !Object.keys(this.bindings).length ? `<${this.id}>` : `<${this.id}>[bound ${Object.keys(this.bindings).join(', ')}] `;
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>>> public stringify(context?: boolean): string {
= _(<A extends L, B extends L, C extends L>(f: L<(v: B) => C>) => return `${context ? this.context() : ''}${this.constructor.name}`;
_((g: L<(v: A) => B>) => }
_((v: A) => f(g(v)))));
public _(arg: RefTerm): Term {
return c(this, arg);
}
}
export class Undef extends Term {
constructor(
public from: string,
) { super({}); }
override reduce(): Term {
throw new Error(`${this.from} = undef`);
}
}
export class Native extends Term {
constructor(
public value: any,
) { super({}); }
public override stringify(): string {
return `\`${JSON.stringify(this.value)}\``;
}
}
export class Deferred extends Term {
constructor(
public func: (bindings: Record<string, Term>) => Term,
bindings: Record<string, Term> = {},
) { super(bindings); }
override refs(_name: string): boolean {
return true;
}
public override bind(name: string, term: Term): Term {
return this.bindings[name] || !this.refs(name)
? this
: new Deferred(this.func, { ...this.bindings, [name]: term });
}
public override reduce(): Term {
const term = this.cache
? withLog(
`Executing ${this.stringify()}`,
() => this.cache!,
r => `got ${r.stringify()} (cached)`,
)
: this.cache = withLog(
`Executing ${this.stringify()}`,
() => this.func({ ...globals, ...this.bindings }),
r => `got ${r.stringify()}`,
);
return Object.entries(this.bindings).reduce((t, b) => t.bind(...b), term).reduce();
}
public override stringify(context: boolean = true): string {
return `${context ? this.context() : ''}\`deferred\``;
}
}
export class Ref extends Term {
constructor(
public name: string,
bindings: Record<string, Term> = {},
) { super(bindings); }
override refs(name: string): boolean {
return this.name === name;
}
public override bind(name: string, term: Term): Term {
return this.bindings[name] || !this.refs(name)
? this
: new Ref(this.name, { [name]: term });
}
public override reduce(): Term {
if (this.cache) {
return withLog(
`Substituting ${this.stringify()}`,
() => this.cache!,
r => `with ${r.stringify()} (cached)`,
);
} else {
return this.cache = withLog(
`Substituting ${this.stringify()}`,
() => (this.bindings[this.name] ?? globals[this.name] ?? new Undef(this.name)).reduce(),
r => `with ${r.stringify()}`,
).reduce();
}
}
public override stringify(context = true): string {
return `${context ? this.context() : ''}${this.name}`;
}
}
export class Lambda extends Term {
constructor(
public param: string,
public body: Term,
bindings: Record<string, Term> = {},
) { super(bindings); }
override refs(name: string): boolean {
return this.param !== name && this.body.refs(name);
}
override bind(name: string, term: Term): Term {
return this.bindings[name] || !this.refs(name)
? this
: new Lambda(this.param, this.body.bind(name, term), { ...this.bindings, [name]: term });
}
public override stringify(context = true): string {
return this.body instanceof Lambda
? `${context ? this.context() : ''}\\ ${this.param} ${this.body.stringify(false).slice(2)}`
: `${context ? this.context() : ''}\\ ${this.param} . ${this.body.stringify(false)}`;
}
}
export class Call extends Term {
constructor(
public func: Term,
public arg: Term,
bindings: Record<string, Term> = {},
) { super(bindings); }
override refs(name: string): boolean {
return this.func.refs(name) || this.arg.refs(name);
}
override bind(name: string, term: Term): Term {
return this.bindings[name] || !this.refs(name)
? this
: new Call(this.func.bind(name, term), this.arg.bind(name, term), { ...this.bindings, [name]: term });
}
override reduce(): Term {
if (this.cache) {
return withLog(
`Reducing ${this.stringify()}`,
() => this.cache!,
r => `to ${r.stringify()} (cached)`,
);
} else {
return this.cache = withLog(
`Reducing ${this.stringify()}`,
() => {
const func = this.func.reduce();
if (func instanceof Lambda) {
return withLog(
`Applying ${func.stringify()} to ${this.arg.stringify()}`,
() => func.body.bind(func.param, this.arg),
r => `got ${r.stringify()}`,
).reduce();
}
return this;
},
r => `to ${r.stringify()}`,
);
}
}
public override stringify(context = true): string {
return `${context ? this.context() : ''}${this.func instanceof Lambda ? `(${this.func.stringify(false)})` : this.func.stringify(false)} ${this.arg instanceof Ref || this.arg instanceof Native ? this.arg.stringify(false) : `(${this.arg.stringify(false)})`}`;
}
}
const globals: Record<string, Term> = {};
type RefTerm = string | Term;
const termify = (t: RefTerm) => typeof t === 'string' ? r(t) : t;
export const _ = (v: any) => new Native(v);
export const r = (name: string): Ref => new Ref(name);
export const l = (param: string, body: RefTerm): Lambda => new Lambda(param, termify(body));
export const c = (func: RefTerm, arg: RefTerm, ...args: RefTerm[]): Call =>
args.reduce<Call>((f: Call, a: RefTerm) => new Call(f, termify(a)), new Call(termify(func), termify(arg)));
export const d = (func: (bindings: Record<string, Term>) => Term) => new Deferred(func);
export const $ = <T>(t: Term): T => {
const rt = t.reduce();
return rt instanceof Native ? rt.value : rt.stringify();
};
let cm: string = 'core';
export const m = (name: string) => cm = name;
export const g = (name: string, term: RefTerm) => {
name = `${cm}::${name}`;
if (globals[name]) {
throw new Error(`Duplicate global: "${name}"`);
}
globals[name] = termify(term);
return new Ref(name);
};
export const undef = g('undef', new Undef('undef'));
export const id = g('id', l('f', 'f'));
export const cnst = g('cnst', l('x', l('_', 'x')));
export const pipe = g('pipe', l('f', l('g', l('x', c('f', c('g', 'x'))))));

38
src/debug.ts
Unescape View File

@ -1,8 +1,30 @@
import { L, _ } from './core'; let indent: string = '';
import { String, toString } from './string'; const logs: string[] = [];
export const log: L<<T extends L>(s: String) => L<(p: T) => T>> let logging: boolean = false;
= _(s => _(p => { export function log(): void {
console.log(toString(s)); logging = true;
return p; }
}));
export function withLog<T>(before: string, f: () => T, after: (v: T) => string): T {
if (!logging) {
return f();
}
logs.push(`${indent}${before}`);
const l = logs.length;
indent += ' ';
const result = f();
indent = indent.slice(2);
if (logs.length === l) {
logs[logs.length - 1] += ` ${after(result)}`;
} else {
logs.push(`${indent}${after(result)}`);
}
return result;
}
export function dump() {
console.log('\n\nExecution log:');
console.log(logs.join('\n'));
}

19
src/index.ts
Unescape View File

@ -1,7 +1,14 @@
import { _, fromNative as __ } from './core'; import { dump, log } from './debug';
import { toString as $s, fromString as _s } from './string'; import { _ } from './core';
import { run } from './bf'; import { fromNumber, toNumber } from './num';
import { Cons, Nil, toArray } from './list';
console.log($s(run log();
(_s('++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.'))
(_s('')))); const program = Cons._(fromNumber(0))._(Nil);
try {
console.log(program.stringify(), ' -> ', toArray(program).map(toNumber));
} finally {
dump();
}

7
src/list.show.ts
Unescape View File

@ -0,0 +1,7 @@
import { _, g, l, m } from './core';
import { concat, intersperse, map } from './list';
import { fromString as _s, cons, snoc } from './string';
m('list.show');
export const show = g('show', l('eshow', l('xs', concat._(snoc._(cons._(_s('['))._(intersperse._(_s(', '))._(map._('eshow')._('xs'))))._(_s(']'))))));

210
src/list.ts
Unescape View File

@ -1,144 +1,72 @@
import { toNative as $$, L, _, fromNative as __, cnst, id, pipe, undef, y } from './core'; import { $, Term, _, cnst, d, g, id, l, m, pipe, r, undef } from './core';
import { EQ, GT, LT, Ord, eq as eqc } from './ord'; import { EQ, GT, LT, eq as eqc } from './ord';
import { Bool, False, True, and, iif, or } from './bool'; import { False, True, and, iif, or } from './bool';
import { Num, Zero, succ } from './num'; import { Zero, succ } from './num';
import { String, fromString as _s } from './string';
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 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 L>(x: T) => L<(xs: List<T>) => List<T>>>
= Cons;
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 L>(xs: List<T>) => Bool>
= _(xs => xs(True)(cnst(cnst(False))));
export const len: L<<T extends L>(xs: List<T>) => Num>
= _(xs => xs(Zero)(cnst(pipe(succ)(len))));
export const singleton: L<<T extends L>(v: T) => List<T>>
= _(x => cons(x)(Nil));
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 L>(ls: List<List<T>>) => List<T>>
= _(ls => ls(Nil)(_(x => pipe(append(x))(concat))));
export const repeat: L<<T extends L>(x: T) => List<T>>
= _(x => cons(x)(repeat(x)));
export const iterate: L<<T extends L>(f: L<(x: T) => T>) => L<(x: T) => List<T>>> m('list');
= _(<T extends L>(f: L<(x: T) => T>) => _((x: T) => cons(x)(iterate(f)(f(x)))));
export const head: L<<T extends L>(xs: List<T>) => T> export const Nil = g('Nil', l('z', l('_', 'z')));
= _(xs => xs(undef)(cnst));
export const tail: L<<T extends L>(xs: List<T>) => List<T>>
= _(xs => xs(undef)(cnst(id)));
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 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 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 L>(f: L<(x: T) => L<(a: T) => T>>) => L<(xs: List<T>) => T>>
= undef;
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))))
(_(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 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 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 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 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 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 L, R extends L>(f: L<(x: T) => R>) => L<(xs: List<T>) => List<R>>> export const Cons = g('Cons', l('x', l('xs', l('_', l('f', r('f')._('x')._('xs'))))));
= _(<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 cons = g('cons', Cons);
export const filter: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => List<T>>> export const snoc = g('snoc', l('xs', l('x', r('xs')._(cons._('x')._(Nil))._(l('y', l('ys', cons._('y')._(r('list::snoc')._('ys')._('x'))))))));
= _(<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 nul = g('nul', l('xs', r('xs')._(True)._(cnst._(cnst._(False)))));
export const any: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>> export const len = g('len', l('xs', r('xs')._(Zero)._(cnst._(pipe._(succ)._(r('list::len'))))));
= _(<T extends L>(f: L<(x: T) => Bool>) =>
_((xs: List<T>) => xs(False)(_(x => pipe(or(f(x)))(any(f)))))); export const singleton = g('singleton', l('x', cons._('x')._(Nil)));
export const all: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>> export const append = g('append', l('l', l('r', r('l')._('r')._(l('x', l('xs', cons._('x')._(r('list::append')._('xs')._('r'))))))));
= _(<T extends L>(f: L<(x: T) => Bool>) =>
_((xs: List<T>) => xs(True)(_(x => pipe(and(f(x)))(all(f)))))); export const concat = g('concat', l('ls', r('ls')._(Nil)._(l('x', pipe._(append._('x'))._(r('list::concat'))))));
export const get: L<<T extends L>(i: Num) => L<(xs: List<T>) => T>> export const repeat = g('repeat', l('x', cons._('x')._(r('list::repeat')._('x'))));
= _(i => _(xs => xs(undef)(_(x => i(cnst(x))(get)))));
export const iterate = g('iterate', l('f', l('x', cons._('x')._(r('list::iterate')._('f')._(r('f')._('x'))))));
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>) => export const head = g('head', l('xs', r('xs')._(undef)._(cnst)));
_((i: Num) =>
_((xs: List<T>) => export const tail = g('tail', l('xs', r('xs')._(undef)._(cnst._(id))));
xs(undef)(_(x => _(xs => i(cons(f(x))(xs))(_(pi => cons(x)(update(f)(pi)(xs))))))))));
export const foldl = g('foldl', l('f', l('z', l('xs', r('xs')._('z')._(pipe._(r('list::foldl')._('f'))._(r('f')._('z')))))));
export const set: L<<T extends L>(v: T) => L<(i: Num) => L<(xs: List<T>) => List<T>>>>
= pipe(update)(cnst); export const foldlz = g('foldlz', l('f', l('xs', r('xs')._(undef)._(foldl._('f')))));
export const intersperse: L<<T extends L>(v: T) => L<(xs: List<T>) => List<T>>> export const foldr = g('foldr', l('f', l('z', l('xs', r('xs')._('z')._(l('x', pipe._(r('f')._('x'))._(r('list::foldr')._('f')._('z'))))))));
= _(v => _(xs => xs(xs)(_(x => _(rxs => rxs(xs)(cnst(cnst(cons(x)(cons(v)(intersperse(v)(rxs)))))))))));
export const foldrz = g('foldrz', undef);
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 cmp = g('cmp', l('ecmp', l('l', l('r', r('l')._(r('r')._(EQ)._(cnst._(cnst._(LT))))._(l('lx', l('lxs', r('r')._(GT)._(l('rx', l('rxs', iif._(eqc._(EQ)._(r('ecmp')._('lx')._('rx')))._(r('list::cmp')._('ecmp')._('lxs')._('rxs'))._(r('ecmp')._('lx')._('rx'))))))))))));
export const fromArray: <T extends L>(xs: T[]) => List<T> export const lt = g('lt', l('ecmp', l('l', l('r', r('r')._(False)._(l('rx', l('rxs', r('l')._(True)._(l('lx', l('lxs', r('ecmp')._('lx')._('rx')._(True)._(r('list::lt')._('ecmp')._('lxs')._('rxs'))._(False)))))))))));
= xs => xs.length === 0 ? Nil : cons(xs[0])(y(() => fromArray(xs.slice(1))));
export const le = g('le', l('ecmp', l('l', l('r', r('l')._(True)._(l('lx', l('lxs', r('r')._(False)._(l('rx', l('rxs', r('ecmp')._('lx')._('rx')._(True)._(r('list::le')._('ecmp')._('lxs')._('rxs'))._(False)))))))))));
export const toArray: <T extends L>(xs: List<T>) => L[]
= xs => $$(xs(__([]))(_(x => _(xs => __([x, ...toArray(xs)]))))); export const eq = g('eq', l('eeq', l('l', l('r', r('l')._(r('r')._(True)._(cnst._(cnst._(False))))._(l('lx', l('lxs', r('r')._(False)._(l('rx', l('rxs', and._(r('eeq')._('lx')._('rx'))._(r('list::eq')._('eeq')._('lxs')._('rxs'))))))))))));
export const ge = g('ge', l('ecmp', l('l', l('r', r('r')._(True)._(l('rx', l('rxs', r('l')._(False)._(l('lx', l('lxs', r('ecmp')._('lx')._('rx')._(False)._(r('list::ge')._('ecmp')._('lxs')._('rxs'))._(True)))))))))));
export const gt = g('gt', l('ecmp', l('l', l('r', r('l')._(False)._(l('lx', l('lxs', r('r')._(True)._(l('rx', l('rxs', r('ecmp')._('lx')._('rx')._(False)._(r('list::gt')._('ecmp')._('lxs')._('rxs'))._(True)))))))))));
export const map = g('map', l('f', l('xs', r('xs')._(Nil)._(l('x', pipe._(cons._(r('f')._('x')))._(r('list::map')._('f')))))));
export const filter = g('filter', l('f', l('xs', r('xs')._(Nil)._(l('x', pipe._(iif._(r('f')._('x'))._(cons._('x'))._(id))._(r('list::filter')._('f')))))));
export const any = g('any', l('f', l('xs', r('xs')._(False)._(l('x', pipe._(or._(r('f')._('x')))._(r('list::any')._('f')))))));
export const all = g('all', l('f', l('xs', r('xs')._(True)._(l('x', pipe._(and._(r('f')._('x')))._(r('list::all')._('f')))))));
export const get = g('get', l('i', l('xs', r('xs')._(undef)._(l('x', r('i')._(cnst._('x'))._('list::get'))))));
export const update = g('update', l('f', l('i', l('xs', r('xs')._(undef)._(l('x', l('xs', r('i')._(cons._(r('f')._('x'))._('xs'))._(l('pi', cons._('x')._(r('list::update')._('f')._('pi')._('xs')))))))))));
export const set = g('set', pipe._(update)._(cnst));
export const intersperse = g('intersperse', l('v', l('xs', r('xs')._('xs')._(l('x', l('rxs', r('rxs')._('xs')._(cnst._(cnst._(cons._('x')._(cons._('v')._(r('list::intersperse')._('v')._('rxs'))))))))))));
export const fromArray: (xs: Term[]) => Term = xs => !xs.length ? Nil : Cons._(xs[0])._(d(() => fromArray(xs.slice(1))));
export const toArray: (xs: Term) => Term[] = xs => $(xs._(_([]))._(l('x', l('xs', d(bs => _([bs['x'], ...toArray(bs['xs'])]))))));

7
src/log.ts
Unescape View File

@ -0,0 +1,7 @@
import { l, d } from './core';
import { toString } from './string';
export const log = l('s', l('p', d(bs => {
console.log(toString(bs['s']));
return bs['p'];
})));

8
src/num.show.ts
Unescape View File

@ -0,0 +1,8 @@
import { _, g, l, m, r } from './core';
import { iif } from './bool';
import { fromNumber as _n, sum, div, mod, lt } from './num';
import { append, cons, Empty } from './string';
m('num.show');
export const show = g('show', l('n', iif._(lt._('n')._(_n(10)))._(cons._(sum._('n')._(_n(48)))._(Empty))._(append._(r('num.show::show')._(div._('n')._(_n(10))))._(r('num.show::show')._(mod._('n')._(_n(10)))))));

74
src/num.ts
Unescape View File

@ -1,71 +1,45 @@
import { toNative as $$, L, _, fromNative as __, cnst, id, pipe, y } from './core'; import { $, Term, _, cnst, d, g, id, l, m, pipe, r } from './core';
import { EQ, GT, LT, Ord } from './ord'; import { EQ, GT, LT } from './ord';
import { Bool, False, True, iif } from './bool'; import { False, True, iif } from './bool';
import { Empty, String, append, cons } from './string';
export type Num = L<<T extends L>(z: T) => L<(n: L<(p: Num) => T>) => T>>; m('num');
export const Zero: Num export const Zero = g('Zero', l('z', l('_n', 'z')));
= _(z => _(_n => z)) as Num;
export const Succ: L<(p: Num) => Num> export const Succ = g('Succ', l('p', l('_z', l('n', r('n')._('p')))));
= _(p => _(_z => _(n => n(p))));
export const ifz: L<<T extends L>(n: Num) => L<(t: T) => L<(f: T) => T>>> export const ifz = g('ifz', l('n', l('t', l('f', r('n')._('t')._(cnst._('f'))))));
= _(n => _(t => _(f => n(t)(cnst(f)))));
export const succ: L<(n: Num) => Num> export const succ = g('succ', Succ);
= Succ;
export const pred: L<(n: Num) => Num> export const pred = g('pred', l('n', r('n')._(Zero)._(id)));
= _(n => n(Zero)(id));
export const cmp: L<(l: Num) => L<(r: Num) => Ord>> export const cmp = g('cmp', l('l', l('r', r('l')._(r('r')._(EQ)._(cnst._(LT)))._(pipe._(r('r')._(GT))._('num::cmp')))));
= _(l => _(r => l(r(EQ)(cnst(LT)))(pipe(r(GT))(cmp))));
export const lt: L<(l: Num) => L<(r: Num) => Bool>> export const lt = g('lt', l('l', l('r', r('r')._(False)._(r('l')._(cnst._(True))._('num::lt')))));
= _(l => _(r => r(False)(l(cnst(True))(lt))));
export const le: L<(l: Num) => L<(r: Num) => Bool>> export const le = g('le', l('l', l('r', r('l')._(True)._(r('r')._(cnst._(False))._('num::ge')))));
= _(l => _(r => l(True)(r(cnst(False))(ge))));
export const eq: L<(l: Num) => L<(r: Num) => Bool>> export const eq = g('eq', l('l', l('r', r('l')._(r('r')._(True)._(cnst._(False)))._(r('r')._(cnst._(False))._('num::eq')))));
= _(l => _(r => l(r(True)(cnst(False)))(r(cnst(False))(eq))));
export const ge: L<(l: Num) => L<(r: Num) => Bool>> export const ge = g('ge', l('l', l('r', r('r')._(True)._(r('l')._(cnst._(False))._('num::ge')))));
= _(l => _(r => r(True)(l(cnst(False))(ge))));
export const gt: L<(l: Num) => L<(r: Num) => Bool>> export const gt = g('gt', l('l', l('r', r('l')._(False)._(r('r')._(cnst._(True))._(lt)))));
= _(l => _(r => l(False)(r(cnst(True))(lt))));
export const even: L<(n: Num) => Bool> export const even = g('even', l('n', r('n')._(True)._('num::odd')));
= _(n => n(True)(odd));
export const odd: L<(n: Num) => Bool> export const odd = g('odd', l('n', r('n')._(False)._('num::even')));
= _(n => n(False)(even));
export const sum: L<(l: Num) => L<(r: Num) => Num>> export const sum = g('sum', l('l', l('r', r('r')._('l')._(r('num::sum')._(Succ._('l'))))));
= _(l => _(r => r(l)(sum(Succ(l)))));
export const sub: L<(l: Num) => L<(r: Num) => Num>> export const sub = g('sub', l('l', l('r', r('r')._('l')._(r('l')._(cnst._(Zero))._('num::sub')))));
= _(l => _(r => r(l)(l(cnst(Zero))(sub))));
export const mul: L<(l: Num) => L<(r: Num) => Num>> export const mul = g('mul', l('l', l('r', r('l')._(Zero)._(l('pl', sum._('r')._(r('num::mul')._('pl')._('r')))))));
= _(l => _(r => l(Zero)(_(pl => sum(r)(mul(pl)(r))))));
export const div: L<(l: Num) => L<(r: Num) => Num>> export const div = g('div', l('l', l('r', iif._(lt._('l')._('r'))._(Zero)._(succ._(r('num::div')._(sub._('l')._('r'))._('r'))))));
= _(l => _(r => iif(lt(l)(r))(Zero)(succ(div(sub(l)(r))(r)))));
export const mod: L<(l: Num) => L<(r: Num) => Num>> export const mod = g('mod', l('l', l('r', iif._(lt._('l')._('r'))._('l')._(r('num::mod')._(sub._('l')._('r'))._('r')))));
= _(l => _(r => iif(lt(l)(r))(l)(mod(sub(l)(r))(r))));
export const show: L<(n: Num) => String> export const fromNumber: (n: number) => Term = n => !n ? Zero : Succ._(d(() => fromNumber(n - 1)));
= _(n => iif(lt(n)(fromNumber(10)))
(cons(sum(n)(fromNumber(48)))(Empty))
(append(show(div(n)(fromNumber(10))))(show(mod(n)(fromNumber(10))))));
export const fromNumber: (n: number) => Num export const toNumber: (n: Term) => number = n => $(n._(_(0))._(l('p', d(bs => _(1 + toNumber(bs['p']))))));
= n => !n ? Zero : Succ(y(() => fromNumber(n - 1)));
export const toNumber: (n: Num) => number
= n => $$(n(__(0))(_(p => __(1 + toNumber(p)))));

6
src/ord.show.ts
Unescape View File

@ -0,0 +1,6 @@
import { _, g, l, m, r } from './core';
import { fromString as _s } from './string';
m('ord.show');
export const show = g('show', l('o', r('o')._(_s('LT'))._(_s('EQ'))._(_s('GT'))));

33
src/ord.ts
Unescape View File

@ -1,8 +1,6 @@
import { toNative as $$, L, _, fromNative as __ } from './core'; import { $, Term, _, c, g, l, m, r } from './core';
import { Bool, False, True } from './bool';
import { String, fromString as _s } from './string';
export type Ord = L<<T extends L>(lt: T) => L<(eq: T) => L<(gt: T) => T>>>; m('ord');
export const enum NOrd { export const enum NOrd {
LT, LT,
@ -10,26 +8,19 @@ export const enum NOrd {
GT, GT,
}; };
export const LT: Ord export const LT = g('LT', l('lt', l('_', l('_', 'lt'))));
= _(lt => _(_eq => _(_gt => lt))) as Ord;
export const EQ: Ord export const EQ = g('EQ', l('_', l('eq', l('_', 'eq'))));
= _(_lt => _(eq => _(_gt => eq)));
export const GT: Ord export const GT = g('GT', l('_', l('_', l('gt', 'gt'))));
= _(_lt => _(_eq => _(gt => gt)));
export const eq: L<(l: Ord) => L<(r: Ord) => Bool>> export const eq = g('eq', l('l', l('r', c('l',
= _(l => _(r => l c('r', 'bool::True', 'bool::False', 'bool::False'),
(r(True)(False)(False)) c('r', 'bool::False', 'bool::True', 'bool::False'),
(r(False)(True)(False)) c('r', 'bool::False', 'bool::False', 'bool::True')))));
(r(False)(False)(True))));
export const show: L<(o: Ord) => String> export const fromNOrd: (o: NOrd) => Term
= _(o => o(_s('LT'))(_s('EQ'))(_s('GT')));
export const fromNOrd: (b: NOrd) => Ord
= o => o === NOrd.LT ? LT : o === NOrd.EQ ? EQ : GT; = o => o === NOrd.LT ? LT : o === NOrd.EQ ? EQ : GT;
export const toNOrd: (b: Ord) => NOrd export const toNOrd: (o: Term) => NOrd
= o => $$(o(__(NOrd.LT))(__(NOrd.EQ))(__(NOrd.GT))); = o => $(c(o, _(NOrd.LT), _(NOrd.EQ), _(NOrd.GT)).reduce());

8
src/pair.show.ts
Unescape View File

@ -0,0 +1,8 @@
import { _, g, l, m, r } from './core';
import { uncurry } from './pair';
import { concat, cons, Nil } from './list';
import { fromString as _s } from './string';
m('pair.show');
export const show = g('show', l('fshow', l('sshow', uncurry._(l('f', l('s', concat._(cons._(_s('('))._(cons._(r('fshow')._('f'))._(cons._(_s(', '))._(cons._(r('sshow')._('s'))._(cons._(_s(')'))._(Nil))))))))))));

86
src/pair.ts
Unescape View File

@ -1,82 +1,32 @@
import { L, _ } from './core'; import { _, g, l, m, r } from './core';
import { GT, LT, Ord } from './ord'; import { GT, LT } from './ord';
import { Bool, False, True, and } from './bool'; import { False, True, and } from './bool';
import { Nil, concat, cons } from './list'; import { fromString as _s } from './string';
import { String, fromString as _s } from './string';
export type Pair<F extends L, S extends L> = L<<R extends L>(f: L<(f: F) => L<(s: S) => R>>) => R>; m('pair');
export const Pair: L<<F extends L, S extends L>(f: F) => L<(s: S) => Pair<F, S>>> export const Pair = g('Pair', l('f', l('s', l('p', r('p')._('f')._('s')))));
= _(<F extends L, S extends L>(f: F) =>
_((s: S) =>
_(<R extends L>(p: L<(f: F) => L<(s: S) => R>>) => p(f)(s))));
export const fst: L<<F extends L, S extends L>(p: Pair<F, S>) => F> export const fst = g('fst', l('p', r('p')._(l('f', l('_', 'f')))));
= _(p => p(_(f => _(_s => f))));
export const snd: L<<F extends L, S extends L>(p: Pair<F, S>) => S> export const snd = g('snd', l('p', r('p')._(l('_', l('s', 's')))));
= _(p => p(_(_f => _(s => 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>>> export const first = g('first', l('t', l('p', r('p')._(l('f', l('s', Pair._(r('t')._('f'))._('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 L, S extends L, SR extends L>(t: L<(s: S) => SR>) => L<(p: Pair<F, S>) => Pair<F, SR>>> export const second = g('second', l('t', l('p', r('p')._(l('f', l('s', Pair._('f')._(r('t')._('s'))))))));
= _(<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 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>>>> export const both = g('both', l('tf', l('ts', l('p', r('p')._(l('f', l('s', Pair._(r('tf')._('f'))._(r('ts')._('s')))))))));
= _(<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 L, S extends L, R extends L>(t: L<(f: F) => L<(s: S) => R>>) => L<(p: Pair<F, S>) => R>> export const uncurry = g('uncurry', l('t', l('p', r('p')._('t'))));
= _(<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 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>>>> export const cmp = g('cmp', l('fcmp', l('scmp', uncurry._(l('lf', l('ls', uncurry._(l('rf', l('rs', r('fcmp')._('lf')._('rf')._(LT)._(r('scmp')._('ls')._('rs'))._(GT))))))))));
= _(<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 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>>>> export const lt = g('lt', l('fcmp', l('scmp', uncurry._(l('lf', l('ls', uncurry._(l('rf', l('rs', r('fcmp')._('lf')._('rf')._(True)._(r('scmp')._('ls')._('rs')._(True)._(False)._(False))._(False))))))))));
= _(<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 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>>>> export const le = g('le', l('fcmp', l('scmp', uncurry._(l('lf', l('ls', uncurry._(l('rf', l('rs', r('fcmp')._('lf')._('rf')._(True)._(r('scmp')._('ls')._('rs')._(True)._(True)._(False))._(False))))))))));
= _(<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 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>>>> export const eq = g('eq', l('feq', l('seq', uncurry._(l('lf', l('ls', uncurry._(l('rf', l('rs', and._(r('feq')._('lf')._('rf'))._(r('seq')._('ls')._('rs')))))))))));
= _(<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 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>>>> export const ge = g('ge', l('fcmp', l('scmp', uncurry._(l('lf', l('ls', uncurry._(l('rf', l('rs', r('fcmp')._('lf')._('rf')._(False)._(r('scmp')._('ls')._('rs')._(False)._(True)._(True))._(True))))))))));
= _(<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 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>>>> export const gt = g('gt', l('fcmp', l('scmp', uncurry._(l('lf', l('ls', uncurry._(l('rf', l('rs', r('fcmp')._('lf')._('rf')._(False)._(r('scmp')._('ls')._('rs')._(False)._(False)._(True))._(True))))))))));
= _(<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 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)))))))))));

7
src/string.show.ts
Unescape View File

@ -0,0 +1,7 @@
import { _, g, m } from './core';
import { fromChar as _c } from './char';
import { wrap, fromString as _s } from './string';
m('string.show');
export const show = g('show', wrap._(_s('"')));

45
src/string.ts
Unescape View File

@ -1,40 +1,29 @@
import { toNative as $$, L, _, fromNative as __, y } from './core'; import { $, Term, _, d, g, l, m } from './core';
import { Ord } from './ord'; import { fromChar as _c, cmp as cmpc, eq as eqc, fromChar, toChar } from './char';
import { Bool } from './bool'; import { Cons, Nil, append, cmp as cmpl, eq as eql, ge as gel, gt as gtl, le as lel, lt as ltl, nul } from './list';
import { fromNumber as _nn } from './num';
import { toChar as $c, Char, fromChar as _c, cmp as cmpc, eq as eqc } from './char';
import { Cons, List, Nil, append, cmp as cmpl, eq as eql, ge as gel, gt as gtl, le as lel, lt as ltl } from './list';
export type String = List<Char>; export { len, Cons, cons, snoc, append, repeat, iterate, get, update, set } from './list';
export { Nil as Empty, nul as empty, len, Cons, cons, snoc, append, repeat, iterate, get, update, set } from './list'; m('string');
export const cmp: L<(l: String) => L<(r: String) => Ord>> export const Empty = g('Empty', Nil);
= cmpl(cmpc);
export const lt: L<(l: String) => L<(r: String) => Bool>> export const empty = g('empty', nul);
= ltl(cmpc);
export const le: L<(l: String) => L<(r: String) => Bool>> export const cmp = g('cmp', cmpl._(cmpc));
= lel(cmpc);
export const eq: L<(l: String) => L<(r: String) => Bool>> export const lt = g('lt', ltl._(cmpc));
= eql(eqc);
export const ge: L<(l: String) => L<(r: String) => Bool>> export const le = g('le', lel._(cmpc));
= gel(cmpc);
export const gt: L<(l: String) => L<(r: String) => Bool>> export const eq = g('eq', eql._(eqc));
= gtl(cmpc);
export const wrap: L<(w: String) => L<(c: String) => String>> export const ge = g('ge', gel._(cmpc));
= _(w => _(c => append(w)(append(c)(w))));
export const fromString: (xs: string) => String export const gt = g('gt', gtl._(cmpc));
= xs => xs.length === 0 ? Nil : Cons(_c(xs[0]))(y(() => fromString(xs.slice(1))));
export const toString: (xs: String) => string export const wrap = g('wrap', l('w', l('c', append._('w')._(append._('c')._('w')))));
= xs => $$(xs(__(''))(_(x => _(xs => __($c(x) + toString(xs))))));
export const show: L<(s: String) => String> export const fromString: (xs: string) => Term = s => !s.length ? Nil : Cons._(fromChar(s[0]))._(d(() => fromString(s.slice(1))));
= wrap(fromString('"'));
export const toString: (xs: Term) => string = s => $(s._(_(''))._(l('x', l('xs', d(bs => _(toChar(bs['x']) + toString(bs['xs'])))))));

20
test/bf.spec.ts
Unescape View File

@ -7,41 +7,41 @@ import { run } from '../src/bf';
describe('BF', () => { describe('BF', () => {
describe('run', () => { describe('run', () => {
it('handles output command', () => { it('handles output command', () => {
expect($s(run(_s('.'))(_s('')))).toBe(String.fromCharCode(0)); expect($s(run._(_s('.'))._(_s('')))).toBe(String.fromCharCode(0));
}); });
it('handles input command', () => { it('handles input command', () => {
expect($s(run(_s(',.'))(_s('a')))).toBe('a'); expect($s(run._(_s(',.'))._(_s('a')))).toBe('a');
}); });
it('handles inc command', () => { it('handles inc command', () => {
expect($s(run(_s('+.'))(_s('')))).toBe(String.fromCharCode(1)); expect($s(run._(_s('+.'))._(_s('')))).toBe(String.fromCharCode(1));
}); });
it('handles dec command', () => { it('handles dec command', () => {
expect($s(run(_s('-.'))(_s('')))).toBe(String.fromCharCode(255)); expect($s(run._(_s('-.'))._(_s('')))).toBe(String.fromCharCode(255));
}); });
it('handles next command', () => { it('handles next command', () => {
expect($s(run(_s('+++++>++.'))(_s('')))).toBe(String.fromCharCode(2)); expect($s(run._(_s('+++++>++.'))._(_s('')))).toBe(String.fromCharCode(2));
}); });
it('handles prev command', () => { it('handles prev command', () => {
expect($s(run(_s('+++++>++<+++++.'))(_s('')))).toBe(String.fromCharCode(10)); expect($s(run._(_s('+++++>++<+++++.'))._(_s('')))).toBe(String.fromCharCode(10));
}); });
it('skips loop block on zero', () => { it('skips loop block on zero', () => {
expect($s(run(_s('[+++++].'))(_s('')))).toBe(String.fromCharCode(0)); expect($s(run._(_s('[+++++].'))._(_s('')))).toBe(String.fromCharCode(0));
}); });
it('repeats loop block while not zero', () => { it('repeats loop block while not zero', () => {
expect($s(run(_s('+++++[-].'))(_s('')))).toBe(String.fromCharCode(0)); expect($s(run._(_s('+++++[-].'))._(_s('')))).toBe(String.fromCharCode(0));
}); });
it('prints "Hello World!"', () => { it('prints "Hello World!"', () => {
expect($s(run expect($s(run
(_s('++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.')) ._(_s('++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.'))
(_s('')))) ._(_s(''))))
.toBe('Hello World!\n'); .toBe('Hello World!\n');
}); });
}); });

103
test/bool.spec.ts
Unescape View File

@ -1,8 +1,9 @@
import { describe, expect, it } from '@jest/globals'; import { describe, expect, it } from '@jest/globals';
import { undef } from '../src/core'; import { undef } from '../src/core';
import { toNOrd as $o, NOrd } from '../src/ord'; import { toNOrd as $o, NOrd } from '../src/ord';
import { toBoolean as $b, False, True, fromBoolean as _b, and, cmp, eq, ge, gt, iif, le, lt, not, or, show, xor } from '../src/bool'; import { toBoolean as $b, False, True, fromBoolean as _b, and, cmp, eq, ge, gt, iif, le, lt, not, or, xor } from '../src/bool';
import { toString as $s } from '../src/string'; import { toString as $s } from '../src/string';
import { show } from '../src/bool.show';
describe('Bool', () => { describe('Bool', () => {
describe('toBoolean', () => { describe('toBoolean', () => {
@ -27,222 +28,222 @@ describe('Bool', () => {
describe('iif', () => { describe('iif', () => {
it('returns true argument', () => { it('returns true argument', () => {
expect($b(iif(True)(True)(False))).toBe(true); expect($b(iif._(True)._(True)._(False))).toBe(true);
}); });
it('returns false argument', () => { it('returns false argument', () => {
expect($b(iif(False)(True)(False))).toBe(false); expect($b(iif._(False)._(True)._(False))).toBe(false);
}); });
it('ignores other argument', () => { it('ignores other argument', () => {
expect($b(iif(True)(True)(undef))).toBe(true); expect($b(iif._(True)._(True)._(undef))).toBe(true);
expect($b(iif(False)(undef)(False))).toBe(false); expect($b(iif._(False)._(undef)._(False))).toBe(false);
}); });
}); });
describe('not', () => { describe('not', () => {
it('not False is True', () => { it('not False is True', () => {
expect($b(not(False))).toBe(true); expect($b(not._(False))).toBe(true);
}); });
it('not True is False', () => { it('not True is False', () => {
expect($b(not(True))).toBe(false); expect($b(not._(True))).toBe(false);
}); });
}); });
describe('lt', () => { describe('lt', () => {
it('False lt False is False', () => { it('False lt False is False', () => {
expect($b(lt(False)(False))).toBe(false); expect($b(lt._(False)._(False))).toBe(false);
}); });
it('False lt True is True', () => { it('False lt True is True', () => {
expect($b(lt(False)(True))).toBe(true); expect($b(lt._(False)._(True))).toBe(true);
}); });
it('True lt False is False', () => { it('True lt False is False', () => {
expect($b(lt(True)(False))).toBe(false); expect($b(lt._(True)._(False))).toBe(false);
}); });
it('True lt True is False', () => { it('True lt True is False', () => {
expect($b(lt(True)(True))).toBe(false); expect($b(lt._(True)._(True))).toBe(false);
}); });
it('True lt ignores second argument', () => { it('True lt ignores second argument', () => {
expect($b(lt(True)(undef))).toBe(false); expect($b(lt._(True)._(undef))).toBe(false);
}); });
}); });
describe('le', () => { describe('le', () => {
it('False le False is True', () => { it('False le False is True', () => {
expect($b(le(False)(False))).toBe(true); expect($b(le._(False)._(False))).toBe(true);
}); });
it('False le True is True', () => { it('False le True is True', () => {
expect($b(le(False)(True))).toBe(true); expect($b(le._(False)._(True))).toBe(true);
}); });
it('True le False is False', () => { it('True le False is False', () => {
expect($b(le(True)(False))).toBe(false); expect($b(le._(True)._(False))).toBe(false);
}); });
it('True le True is True', () => { it('True le True is True', () => {
expect($b(le(True)(True))).toBe(true); expect($b(le._(True)._(True))).toBe(true);
}); });
it('False le ignores second argument', () => { it('False le ignores second argument', () => {
expect($b(le(False)(undef))).toBe(true); expect($b(le._(False)._(undef))).toBe(true);
}); });
}); });
describe('eq', () => { describe('eq', () => {
it('False eq False is True', () => { it('False eq False is True', () => {
expect($b(eq(False)(False))).toBe(true); expect($b(eq._(False)._(False))).toBe(true);
}); });
it('False eq True is False', () => { it('False eq True is False', () => {
expect($b(eq(False)(True))).toBe(false); expect($b(eq._(False)._(True))).toBe(false);
}); });
it('True eq False is False', () => { it('True eq False is False', () => {
expect($b(eq(True)(False))).toBe(false); expect($b(eq._(True)._(False))).toBe(false);
}); });
it('True eq True is True', () => { it('True eq True is True', () => {
expect($b(eq(True)(True))).toBe(true); expect($b(eq._(True)._(True))).toBe(true);
}); });
}); });
describe('ge', () => { describe('ge', () => {
it('False ge False is True', () => { it('False ge False is True', () => {
expect($b(ge(False)(False))).toBe(true); expect($b(ge._(False)._(False))).toBe(true);
}); });
it('False ge True is False', () => { it('False ge True is False', () => {
expect($b(ge(False)(True))).toBe(false); expect($b(ge._(False)._(True))).toBe(false);
}); });
it('True ge False is True', () => { it('True ge False is True', () => {
expect($b(ge(True)(False))).toBe(true); expect($b(ge._(True)._(False))).toBe(true);
}); });
it('True ge True is True', () => { it('True ge True is True', () => {
expect($b(ge(True)(True))).toBe(true); expect($b(ge._(True)._(True))).toBe(true);
}); });
it('True ge ignores second argument', () => { it('True ge ignores second argument', () => {
expect($b(ge(True)(undef))).toBe(true); expect($b(ge._(True)._(undef))).toBe(true);
}); });
}); });
describe('gt', () => { describe('gt', () => {
it('False gt False is False', () => { it('False gt False is False', () => {
expect($b(gt(False)(False))).toBe(false); expect($b(gt._(False)._(False))).toBe(false);
}); });
it('False gt True is False', () => { it('False gt True is False', () => {
expect($b(gt(False)(True))).toBe(false); expect($b(gt._(False)._(True))).toBe(false);
}); });
it('True gt False is True', () => { it('True gt False is True', () => {
expect($b(gt(True)(False))).toBe(true); expect($b(gt._(True)._(False))).toBe(true);
}); });
it('True gt True is False', () => { it('True gt True is False', () => {
expect($b(gt(True)(True))).toBe(false); expect($b(gt._(True)._(True))).toBe(false);
}); });
it('False gt ignores second argument', () => { it('False gt ignores second argument', () => {
expect($b(gt(False)(undef))).toBe(false); expect($b(gt._(False)._(undef))).toBe(false);
}); });
}); });
describe('cmp', () => { describe('cmp', () => {
it('False cmp False is EQ', () => { it('False cmp False is EQ', () => {
expect($o(cmp(False)(False))).toBe(NOrd.EQ); expect($o(cmp._(False)._(False))).toBe(NOrd.EQ);
}); });
it('False cmp True is LT', () => { it('False cmp True is LT', () => {
expect($o(cmp(False)(True))).toBe(NOrd.LT); expect($o(cmp._(False)._(True))).toBe(NOrd.LT);
}); });
it('True cmp False is GT', () => { it('True cmp False is GT', () => {
expect($o(cmp(True)(False))).toBe(NOrd.GT); expect($o(cmp._(True)._(False))).toBe(NOrd.GT);
}); });
it('True cmp True is EQ', () => { it('True cmp True is EQ', () => {
expect($o(cmp(True)(True))).toBe(NOrd.EQ); expect($o(cmp._(True)._(True))).toBe(NOrd.EQ);
}); });
}); });
describe('and', () => { describe('and', () => {
it('False and False is False', () => { it('False and False is False', () => {
expect($b(and(False)(False))).toBe(false); expect($b(and._(False)._(False))).toBe(false);
}); });
it('False and True is False', () => { it('False and True is False', () => {
expect($b(and(False)(True))).toBe(false); expect($b(and._(False)._(True))).toBe(false);
}); });
it('True and False is False', () => { it('True and False is False', () => {
expect($b(and(True)(False))).toBe(false); expect($b(and._(True)._(False))).toBe(false);
}); });
it('True and True is True', () => { it('True and True is True', () => {
expect($b(and(True)(True))).toBe(true); expect($b(and._(True)._(True))).toBe(true);
}); });
it('False and ignores other argument', () => { it('False and ignores other argument', () => {
expect($b(and(False)(undef))).toBe(false); expect($b(and._(False)._(undef))).toBe(false);
}); });
}); });
describe('or', () => { describe('or', () => {
it('False or False is False', () => { it('False or False is False', () => {
expect($b(or(False)(False))).toBe(false); expect($b(or._(False)._(False))).toBe(false);
}); });
it('False or True is True', () => { it('False or True is True', () => {
expect($b(or(False)(True))).toBe(true); expect($b(or._(False)._(True))).toBe(true);
}); });
it('True or False is True', () => { it('True or False is True', () => {
expect($b(or(True)(False))).toBe(true); expect($b(or._(True)._(False))).toBe(true);
}); });
it('True or True is True', () => { it('True or True is True', () => {
expect($b(or(True)(True))).toBe(true); expect($b(or._(True)._(True))).toBe(true);
}); });
it('True or ignores other argument', () => { it('True or ignores other argument', () => {
expect($b(or(True)(undef))).toBe(true); expect($b(or._(True)._(undef))).toBe(true);
}); });
}); });
describe('xor', () => { describe('xor', () => {
it('False xor False is False', () => { it('False xor False is False', () => {
expect($b(xor(False)(False))).toBe(false); expect($b(xor._(False)._(False))).toBe(false);
}); });
it('False xor True is True', () => { it('False xor True is True', () => {
expect($b(xor(False)(True))).toBe(true); expect($b(xor._(False)._(True))).toBe(true);
}); });
it('True xor False is True', () => { it('True xor False is True', () => {
expect($b(xor(True)(False))).toBe(true); expect($b(xor._(True)._(False))).toBe(true);
}); });
it('True xor True is False', () => { it('True xor True is False', () => {
expect($b(xor(True)(True))).toBe(false); expect($b(xor._(True)._(True))).toBe(false);
}); });
}); });
describe('show', () => { describe('show', () => {
it('show False is "False"', () => { it('show False is "False"', () => {
expect($s(show(False))).toBe('False'); expect($s(show._(False))).toBe('False');
}); });
it('show True is "True"', () => { it('show True is "True"', () => {
expect($s(show(True))).toBe('True'); expect($s(show._(True))).toBe('True');
}); });
}); });
}); });

211
test/byte.spec.ts
Unescape View File

@ -2,8 +2,9 @@ import { describe, expect, it } from '@jest/globals';
import { undef } from '../src/core'; import { undef } 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, Inc, fromNumber as _n, cmp, dec, div, eq, ge, gt, ifz, inc, le, lt, mod, mul, show, sub, sum, x00 } from '../src/byte'; import { toNumber as $n, Inc, fromNumber as _n, cmp, dec, div, eq, ge, gt, ifz, inc, le, lt, mod, mul, sub, sum, x00 } from '../src/byte';
import { toString as $s } from '../src/string'; import { toString as $s } from '../src/string';
import { show } from '../src/byte.show';
describe('Byte', () => { describe('Byte', () => {
describe('toNumber', () => { describe('toNumber', () => {
@ -12,11 +13,11 @@ describe('Byte', () => {
}); });
it('converts 1', () => { it('converts 1', () => {
expect($n(Inc(x00))).toBe(1); expect($n(Inc._(x00))).toBe(1);
}); });
it('converts 2', () => { it('converts 2', () => {
expect($n(Inc(Inc(x00)))).toBe(2); expect($n(Inc._(Inc._(x00)))).toBe(2);
}); });
}); });
@ -40,436 +41,436 @@ describe('Byte', () => {
describe('ifz', () => { describe('ifz', () => {
it('returns zero branch', () => { it('returns zero branch', () => {
expect($b(ifz(_n(0))(_b(true))(_b(false)))).toBe(true); expect($b(ifz._(_n(0))._(_b(true))._(_b(false)))).toBe(true);
}); });
it('returns non-zero branch', () => { it('returns non-zero branch', () => {
expect($b(ifz(_n(1))(_b(true))(_b(false)))).toBe(false); expect($b(ifz._(_n(1))._(_b(true))._(_b(false)))).toBe(false);
}); });
it('returns non-zero branch', () => { it('returns non-zero branch', () => {
expect($b(ifz(_n(10))(_b(true))(_b(false)))).toBe(false); expect($b(ifz._(_n(10))._(_b(true))._(_b(false)))).toBe(false);
}); });
it('skips other branch', () => { it('skips other branch', () => {
expect($b(ifz(_n(0))(_b(true))(undef))).toBe(true); expect($b(ifz._(_n(0))._(_b(true))._(undef))).toBe(true);
expect($b(ifz(_n(1))(undef)(_b(false)))).toBe(false); expect($b(ifz._(_n(1))._(undef)._(_b(false)))).toBe(false);
}); });
}); });
describe('inc', () => { describe('inc', () => {
it('inc 0 is 1', () => { it('inc 0 is 1', () => {
expect($n(inc(_n(0)))).toBe(1); expect($n(inc._(_n(0)))).toBe(1);
}); });
it('inc 1 is 2', () => { it('inc 1 is 2', () => {
expect($n(inc(_n(1)))).toBe(2); expect($n(inc._(_n(1)))).toBe(2);
}); });
it('inc 10 is 11', () => { it('inc 10 is 11', () => {
expect($n(inc(_n(10)))).toBe(11); expect($n(inc._(_n(10)))).toBe(11);
}); });
it('inc 255 is 0', () => { it('inc 255 is 0', () => {
expect($n(inc(_n(255)))).toBe(0); expect($n(inc._(_n(255)))).toBe(0);
}); });
}); });
describe('dec', () => { describe('dec', () => {
it('dec 0 is 255', () => { it('dec 0 is 255', () => {
expect($n(dec(_n(0)))).toBe(255); expect($n(dec._(_n(0)))).toBe(255);
}); });
it('dec 1 is 0', () => { it('dec 1 is 0', () => {
expect($n(dec(_n(1)))).toBe(0); expect($n(dec._(_n(1)))).toBe(0);
}); });
it('dec 10 is 9', () => { it('dec 10 is 9', () => {
expect($n(dec(_n(10)))).toBe(9); expect($n(dec._(_n(10)))).toBe(9);
}); });
it('dec 255 is 254', () => { it('dec 255 is 254', () => {
expect($n(dec(_n(255)))).toBe(254); expect($n(dec._(_n(255)))).toBe(254);
}); });
}); });
describe('cmp', () => { describe('cmp', () => {
it('0 cmp 0 is EQ', () => { it('0 cmp 0 is EQ', () => {
expect($o(cmp(_n(0))(_n(0)))).toBe(NOrd.EQ); expect($o(cmp._(_n(0))._(_n(0)))).toBe(NOrd.EQ);
}); });
it('0 cmp 1 is LT', () => { it('0 cmp 1 is LT', () => {
expect($o(cmp(_n(0))(_n(1)))).toBe(NOrd.LT); expect($o(cmp._(_n(0))._(_n(1)))).toBe(NOrd.LT);
}); });
it('1 cmp 0 is GT', () => { it('1 cmp 0 is GT', () => {
expect($o(cmp(_n(1))(_n(0)))).toBe(NOrd.GT); expect($o(cmp._(_n(1))._(_n(0)))).toBe(NOrd.GT);
}); });
it('3 cmp 3 is EQ', () => { it('3 cmp 3 is EQ', () => {
expect($o(cmp(_n(3))(_n(3)))).toBe(NOrd.EQ); expect($o(cmp._(_n(3))._(_n(3)))).toBe(NOrd.EQ);
}); });
it('3 cmp 7 is LT', () => { it('3 cmp 7 is LT', () => {
expect($o(cmp(_n(3))(_n(7)))).toBe(NOrd.LT); expect($o(cmp._(_n(3))._(_n(7)))).toBe(NOrd.LT);
}); });
it('7 cmp 3 is GT', () => { it('7 cmp 3 is GT', () => {
expect($o(cmp(_n(7))(_n(3)))).toBe(NOrd.GT); expect($o(cmp._(_n(7))._(_n(3)))).toBe(NOrd.GT);
}); });
it('0 cmp 255 is LT', () => { it('0 cmp 255 is LT', () => {
expect($o(cmp(_n(0))(_n(255)))).toBe(NOrd.LT); expect($o(cmp._(_n(0))._(_n(255)))).toBe(NOrd.LT);
}); });
it('255 cmp 0 is GT', () => { it('255 cmp 0 is GT', () => {
expect($o(cmp(_n(255))(_n(0)))).toBe(NOrd.GT); expect($o(cmp._(_n(255))._(_n(0)))).toBe(NOrd.GT);
}); });
it('255 cmp 255 is EQ', () => { it('255 cmp 255 is EQ', () => {
expect($o(cmp(_n(255))(_n(255)))).toBe(NOrd.EQ); expect($o(cmp._(_n(255))._(_n(255)))).toBe(NOrd.EQ);
}); });
}); });
describe('lt', () => { describe('lt', () => {
it('0 lt 0 is False', () => { it('0 lt 0 is False', () => {
expect($b(lt(_n(0))(_n(0)))).toBe(false); expect($b(lt._(_n(0))._(_n(0)))).toBe(false);
}); });
it('0 lt 1 is True', () => { it('0 lt 1 is True', () => {
expect($b(lt(_n(0))(_n(1)))).toBe(true); expect($b(lt._(_n(0))._(_n(1)))).toBe(true);
}); });
it('1 lt 0 is False', () => { it('1 lt 0 is False', () => {
expect($b(lt(_n(1))(_n(0)))).toBe(false); expect($b(lt._(_n(1))._(_n(0)))).toBe(false);
}); });
it('3 lt 3 is False', () => { it('3 lt 3 is False', () => {
expect($b(lt(_n(3))(_n(3)))).toBe(false); expect($b(lt._(_n(3))._(_n(3)))).toBe(false);
}); });
it('3 lt 7 is True', () => { it('3 lt 7 is True', () => {
expect($b(lt(_n(3))(_n(7)))).toBe(true); expect($b(lt._(_n(3))._(_n(7)))).toBe(true);
}); });
it('7 lt 3 is False', () => { it('7 lt 3 is False', () => {
expect($b(lt(_n(7))(_n(3)))).toBe(false); expect($b(lt._(_n(7))._(_n(3)))).toBe(false);
}); });
it('0 lt 255 is True', () => { it('0 lt 255 is True', () => {
expect($b(lt(_n(0))(_n(255)))).toBe(true); expect($b(lt._(_n(0))._(_n(255)))).toBe(true);
}); });
it('255 lt 0 is False', () => { it('255 lt 0 is False', () => {
expect($b(lt(_n(255))(_n(0)))).toBe(false); expect($b(lt._(_n(255))._(_n(0)))).toBe(false);
}); });
it('255 lt 255 is False', () => { it('255 lt 255 is False', () => {
expect($b(lt(_n(255))(_n(255)))).toBe(false); expect($b(lt._(_n(255))._(_n(255)))).toBe(false);
}); });
}); });
describe('le', () => { describe('le', () => {
it('0 le 0 is True', () => { it('0 le 0 is True', () => {
expect($b(le(_n(0))(_n(0)))).toBe(true); expect($b(le._(_n(0))._(_n(0)))).toBe(true);
}); });
it('0 le 1 is True', () => { it('0 le 1 is True', () => {
expect($b(le(_n(0))(_n(1)))).toBe(true); expect($b(le._(_n(0))._(_n(1)))).toBe(true);
}); });
it('1 le 0 is False', () => { it('1 le 0 is False', () => {
expect($b(le(_n(1))(_n(0)))).toBe(false); expect($b(le._(_n(1))._(_n(0)))).toBe(false);
}); });
it('3 le 3 is True', () => { it('3 le 3 is True', () => {
expect($b(le(_n(3))(_n(3)))).toBe(true); expect($b(le._(_n(3))._(_n(3)))).toBe(true);
}); });
it('3 le 7 is True', () => { it('3 le 7 is True', () => {
expect($b(le(_n(3))(_n(7)))).toBe(true); expect($b(le._(_n(3))._(_n(7)))).toBe(true);
}); });
it('7 le 3 is False', () => { it('7 le 3 is False', () => {
expect($b(le(_n(7))(_n(3)))).toBe(false); expect($b(le._(_n(7))._(_n(3)))).toBe(false);
}); });
it('0 le 255 is True', () => { it('0 le 255 is True', () => {
expect($b(le(_n(0))(_n(255)))).toBe(true); expect($b(le._(_n(0))._(_n(255)))).toBe(true);
}); });
it('255 le 0 is False', () => { it('255 le 0 is False', () => {
expect($b(le(_n(255))(_n(0)))).toBe(false); expect($b(le._(_n(255))._(_n(0)))).toBe(false);
}); });
it('255 le 255 is True', () => { it('255 le 255 is True', () => {
expect($b(le(_n(255))(_n(255)))).toBe(true); expect($b(le._(_n(255))._(_n(255)))).toBe(true);
}); });
it('0 le skips second argument', () => { it('0 le skips second argument', () => {
expect($b(le(_n(0))(undef))).toBe(true); expect($b(le._(_n(0))._(undef))).toBe(true);
}); });
}); });
describe('eq', () => { describe('eq', () => {
it('0 eq 0 is True', () => { it('0 eq 0 is True', () => {
expect($b(eq(_n(0))(_n(0)))).toBe(true); expect($b(eq._(_n(0))._(_n(0)))).toBe(true);
}); });
it('0 eq 1 is False', () => { it('0 eq 1 is False', () => {
expect($b(eq(_n(0))(_n(1)))).toBe(false); expect($b(eq._(_n(0))._(_n(1)))).toBe(false);
}); });
it('1 eq 0 is False', () => { it('1 eq 0 is False', () => {
expect($b(eq(_n(1))(_n(0)))).toBe(false); expect($b(eq._(_n(1))._(_n(0)))).toBe(false);
}); });
it('3 eq 3 is True', () => { it('3 eq 3 is True', () => {
expect($b(eq(_n(3))(_n(3)))).toBe(true); expect($b(eq._(_n(3))._(_n(3)))).toBe(true);
}); });
it('3 eq 7 is False', () => { it('3 eq 7 is False', () => {
expect($b(eq(_n(3))(_n(7)))).toBe(false); expect($b(eq._(_n(3))._(_n(7)))).toBe(false);
}); });
it('7 eq 3 is False', () => { it('7 eq 3 is False', () => {
expect($b(eq(_n(7))(_n(3)))).toBe(false); expect($b(eq._(_n(7))._(_n(3)))).toBe(false);
}); });
it('0 eq 255 is False', () => { it('0 eq 255 is False', () => {
expect($b(eq(_n(0))(_n(255)))).toBe(false); expect($b(eq._(_n(0))._(_n(255)))).toBe(false);
}); });
it('255 eq 0 is False', () => { it('255 eq 0 is False', () => {
expect($b(eq(_n(255))(_n(0)))).toBe(false); expect($b(eq._(_n(255))._(_n(0)))).toBe(false);
}); });
it('255 eq 255 is True', () => { it('255 eq 255 is True', () => {
expect($b(eq(_n(255))(_n(255)))).toBe(true); expect($b(eq._(_n(255))._(_n(255)))).toBe(true);
}); });
}); });
describe('ge', () => { describe('ge', () => {
it('0 ge 0 is True', () => { it('0 ge 0 is True', () => {
expect($b(ge(_n(0))(_n(0)))).toBe(true); expect($b(ge._(_n(0))._(_n(0)))).toBe(true);
}); });
it('0 ge 1 is False', () => { it('0 ge 1 is False', () => {
expect($b(ge(_n(0))(_n(1)))).toBe(false); expect($b(ge._(_n(0))._(_n(1)))).toBe(false);
}); });
it('1 ge 0 is True', () => { it('1 ge 0 is True', () => {
expect($b(ge(_n(1))(_n(0)))).toBe(true); expect($b(ge._(_n(1))._(_n(0)))).toBe(true);
}); });
it('3 ge 3 is True', () => { it('3 ge 3 is True', () => {
expect($b(ge(_n(3))(_n(3)))).toBe(true); expect($b(ge._(_n(3))._(_n(3)))).toBe(true);
}); });
it('3 ge 7 is False', () => { it('3 ge 7 is False', () => {
expect($b(ge(_n(3))(_n(7)))).toBe(false); expect($b(ge._(_n(3))._(_n(7)))).toBe(false);
}); });
it('7 ge 3 is True', () => { it('7 ge 3 is True', () => {
expect($b(ge(_n(7))(_n(3)))).toBe(true); expect($b(ge._(_n(7))._(_n(3)))).toBe(true);
}); });
it('0 ge 255 is False', () => { it('0 ge 255 is False', () => {
expect($b(ge(_n(0))(_n(255)))).toBe(false); expect($b(ge._(_n(0))._(_n(255)))).toBe(false);
}); });
it('255 ge 0 is True', () => { it('255 ge 0 is True', () => {
expect($b(ge(_n(255))(_n(0)))).toBe(true); expect($b(ge._(_n(255))._(_n(0)))).toBe(true);
}); });
it('255 ge 255 is True', () => { it('255 ge 255 is True', () => {
expect($b(ge(_n(255))(_n(255)))).toBe(true); expect($b(ge._(_n(255))._(_n(255)))).toBe(true);
}); });
it('ge 0 skips first argument', () => { it('ge 0 skips first argument', () => {
expect($b(ge(undef)(_n(0)))).toBe(true); expect($b(ge._(undef)._(_n(0)))).toBe(true);
}); });
}); });
describe('gt', () => { describe('gt', () => {
it('0 gt 0 is False', () => { it('0 gt 0 is False', () => {
expect($b(gt(_n(0))(_n(0)))).toBe(false); expect($b(gt._(_n(0))._(_n(0)))).toBe(false);
}); });
it('0 gt 1 is False', () => { it('0 gt 1 is False', () => {
expect($b(gt(_n(0))(_n(1)))).toBe(false); expect($b(gt._(_n(0))._(_n(1)))).toBe(false);
}); });
it('1 gt 0 is True', () => { it('1 gt 0 is True', () => {
expect($b(gt(_n(1))(_n(0)))).toBe(true); expect($b(gt._(_n(1))._(_n(0)))).toBe(true);
}); });
it('3 gt 3 is False', () => { it('3 gt 3 is False', () => {
expect($b(gt(_n(3))(_n(3)))).toBe(false); expect($b(gt._(_n(3))._(_n(3)))).toBe(false);
}); });
it('3 gt 7 is False', () => { it('3 gt 7 is False', () => {
expect($b(gt(_n(3))(_n(7)))).toBe(false); expect($b(gt._(_n(3))._(_n(7)))).toBe(false);
}); });
it('7 gt 3 is True', () => { it('7 gt 3 is True', () => {
expect($b(gt(_n(7))(_n(3)))).toBe(true); expect($b(gt._(_n(7))._(_n(3)))).toBe(true);
}); });
it('0 gt 255 is False', () => { it('0 gt 255 is False', () => {
expect($b(gt(_n(0))(_n(255)))).toBe(false); expect($b(gt._(_n(0))._(_n(255)))).toBe(false);
}); });
it('255 gt 0 is True', () => { it('255 gt 0 is True', () => {
expect($b(gt(_n(255))(_n(0)))).toBe(true); expect($b(gt._(_n(255))._(_n(0)))).toBe(true);
}); });
it('255 gt 255 is False', () => { it('255 gt 255 is False', () => {
expect($b(gt(_n(255))(_n(255)))).toBe(false); expect($b(gt._(_n(255))._(_n(255)))).toBe(false);
}); });
}); });
describe('sum', () => { describe('sum', () => {
it('0 sum 0 is 0', () => { it('0 sum 0 is 0', () => {
expect($n(sum(_n(0))(_n(0)))).toBe(0); expect($n(sum._(_n(0))._(_n(0)))).toBe(0);
}); });
it('0 sum 1 is 1', () => { it('0 sum 1 is 1', () => {
expect($n(sum(_n(0))(_n(1)))).toBe(1); expect($n(sum._(_n(0))._(_n(1)))).toBe(1);
}); });
it('1 sum 0 is 1', () => { it('1 sum 0 is 1', () => {
expect($n(sum(_n(1))(_n(0)))).toBe(1); expect($n(sum._(_n(1))._(_n(0)))).toBe(1);
}); });
it('3 sum 4 is 7', () => { it('3 sum 4 is 7', () => {
expect($n(sum(_n(3))(_n(4)))).toBe(7); expect($n(sum._(_n(3))._(_n(4)))).toBe(7);
}); });
it('200 sum 200 is 144', () => { it('200 sum 200 is 144', () => {
expect($n(sum(_n(200))(_n(200)))).toBe(144); expect($n(sum._(_n(200))._(_n(200)))).toBe(144);
}); });
}); });
describe('sub', () => { describe('sub', () => {
it('0 sub 0 is 0', () => { it('0 sub 0 is 0', () => {
expect($n(sub(_n(0))(_n(0)))).toBe(0); expect($n(sub._(_n(0))._(_n(0)))).toBe(0);
}); });
it('0 sub 1 is 255', () => { it('0 sub 1 is 255', () => {
expect($n(sub(_n(0))(_n(1)))).toBe(255); expect($n(sub._(_n(0))._(_n(1)))).toBe(255);
}); });
it('1 sub 0 is 1', () => { it('1 sub 0 is 1', () => {
expect($n(sub(_n(1))(_n(0)))).toBe(1); expect($n(sub._(_n(1))._(_n(0)))).toBe(1);
}); });
it('7 sub 4 is 3', () => { it('7 sub 4 is 3', () => {
expect($n(sub(_n(7))(_n(4)))).toBe(3); expect($n(sub._(_n(7))._(_n(4)))).toBe(3);
}); });
it('4 sub 7 is 253', () => { it('4 sub 7 is 253', () => {
expect($n(sub(_n(4))(_n(7)))).toBe(253); expect($n(sub._(_n(4))._(_n(7)))).toBe(253);
}); });
}); });
describe('mul', () => { describe('mul', () => {
it('0 mul 0 is 0', () => { it('0 mul 0 is 0', () => {
expect($n(mul(_n(0))(_n(0)))).toBe(0); expect($n(mul._(_n(0))._(_n(0)))).toBe(0);
}); });
it('0 mul 10 is 0', () => { it('0 mul 10 is 0', () => {
expect($n(mul(_n(0))(_n(10)))).toBe(0); expect($n(mul._(_n(0))._(_n(10)))).toBe(0);
}); });
it('10 mul 0 is 0', () => { it('10 mul 0 is 0', () => {
expect($n(mul(_n(1))(_n(0)))).toBe(0); expect($n(mul._(_n(1))._(_n(0)))).toBe(0);
}); });
it('1 mul 10 is 10', () => { it('1 mul 10 is 10', () => {
expect($n(mul(_n(1))(_n(10)))).toBe(10); expect($n(mul._(_n(1))._(_n(10)))).toBe(10);
}); });
it('10 mul 1 is 10', () => { it('10 mul 1 is 10', () => {
expect($n(mul(_n(10))(_n(1)))).toBe(10); expect($n(mul._(_n(10))._(_n(1)))).toBe(10);
}); });
it('3 mul 4 is 12', () => { it('3 mul 4 is 12', () => {
expect($n(mul(_n(3))(_n(4)))).toBe(12); expect($n(mul._(_n(3))._(_n(4)))).toBe(12);
}); });
it('100 mul 100 is 12', () => { it('100 mul 100 is 12', () => {
expect($n(mul(_n(3))(_n(4)))).toBe(12); expect($n(mul._(_n(3))._(_n(4)))).toBe(12);
}); });
it('0 mul ignores second argument', () => { it('0 mul ignores second argument', () => {
expect($n(mul(_n(0))(undef))).toBe(0); expect($n(mul._(_n(0))._(undef))).toBe(0);
}); });
}); });
describe('div', () => { describe('div', () => {
it('0 div 10 is 0', () => { it('0 div 10 is 0', () => {
expect($n(div(_n(0))(_n(10)))).toBe(0); expect($n(div._(_n(0))._(_n(10)))).toBe(0);
}); });
it('1 div 10 is 0', () => { it('1 div 10 is 0', () => {
expect($n(div(_n(1))(_n(10)))).toBe(0); expect($n(div._(_n(1))._(_n(10)))).toBe(0);
}); });
it('10 div 1 is 10', () => { it('10 div 1 is 10', () => {
expect($n(div(_n(10))(_n(1)))).toBe(10); expect($n(div._(_n(10))._(_n(1)))).toBe(10);
}); });
it('10 div 5 is 2', () => { it('10 div 5 is 2', () => {
expect($n(div(_n(10))(_n(5)))).toBe(2); expect($n(div._(_n(10))._(_n(5)))).toBe(2);
}); });
it('10 div 3 is 3', () => { it('10 div 3 is 3', () => {
expect($n(div(_n(10))(_n(3)))).toBe(3); expect($n(div._(_n(10))._(_n(3)))).toBe(3);
}); });
it.failing('0 div ignores second argument', () => { it.failing('0 div ignores second argument', () => {
expect($n(div(_n(0))(undef))).toBe(0); expect($n(div._(_n(0))._(undef))).toBe(0);
}); });
}); });
describe('mod', () => { describe('mod', () => {
it('0 mod 10 is 0', () => { it('0 mod 10 is 0', () => {
expect($n(mod(_n(0))(_n(10)))).toBe(0); expect($n(mod._(_n(0))._(_n(10)))).toBe(0);
}); });
it('1 mod 10 is 1', () => { it('1 mod 10 is 1', () => {
expect($n(mod(_n(1))(_n(10)))).toBe(1); expect($n(mod._(_n(1))._(_n(10)))).toBe(1);
}); });
it('10 mod 1 is 0', () => { it('10 mod 1 is 0', () => {
expect($n(mod(_n(10))(_n(1)))).toBe(0); expect($n(mod._(_n(10))._(_n(1)))).toBe(0);
}); });
it('10 mod 5 is 0', () => { it('10 mod 5 is 0', () => {
expect($n(mod(_n(10))(_n(5)))).toBe(0); expect($n(mod._(_n(10))._(_n(5)))).toBe(0);
}); });
it('10 mod 3 is 1', () => { it('10 mod 3 is 1', () => {
expect($n(mod(_n(10))(_n(3)))).toBe(1); expect($n(mod._(_n(10))._(_n(3)))).toBe(1);
}); });
it.failing('0 mod ignores second argument', () => { it.failing('0 mod ignores second argument', () => {
expect($n(mod(_n(0))(undef))).toBe(0); expect($n(mod._(_n(0))._(undef))).toBe(0);
}); });
}); });
describe('show', () => { describe('show', () => {
it('show 0 is "0"', () => { it('show 0 is "0"', () => {
expect($s(show(_n(0)))).toBe('0'); expect($s(show._(_n(0)))).toBe('0');
}); });
it('show 1 is "1"', () => { it('show 1 is "1"', () => {
expect($s(show(_n(1)))).toBe('1'); expect($s(show._(_n(1)))).toBe('1');
}); });
it('show 255 is "255"', () => { it('show 255 is "255"', () => {
expect($s(show(_n(255)))).toBe('255'); expect($s(show._(_n(255)))).toBe('255');
}); });
}); });
}); });

81
test/char.spec.ts
Unescape View File

@ -2,8 +2,9 @@ import { describe, expect, it } from '@jest/globals';
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 { fromNumber as _n } from '../src/byte'; import { fromNumber as _n } from '../src/byte';
import { toChar as $c, fromChar as _c, cmp, eq, ge, gt, le, lt, show } from '../src/char'; import { toChar as $c, fromChar as _c, cmp, eq, ge, gt, le, lt } from '../src/char';
import { toString as $s } from '../src/string'; import { toString as $s } from '../src/string';
import { show } from '../src/char.show';
describe('Char', () => { describe('Char', () => {
describe('toChar', () => { describe('toChar', () => {
@ -44,171 +45,171 @@ describe('Char', () => {
describe('cmp', () => { describe('cmp', () => {
it('"0" cmp "0" is EQ', () => { it('"0" cmp "0" is EQ', () => {
expect($o(cmp(_c('0'))(_c('0')))).toBe(NOrd.EQ); expect($o(cmp._(_c('0'))._(_c('0')))).toBe(NOrd.EQ);
}); });
it('"0" cmp "a" is LT', () => { it('"0" cmp "a" is LT', () => {
expect($o(cmp(_c('0'))(_c('a')))).toBe(NOrd.LT); expect($o(cmp._(_c('0'))._(_c('a')))).toBe(NOrd.LT);
}); });
it('"a" cmp "0" is GT', () => { it('"a" cmp "0" is GT', () => {
expect($o(cmp(_c('a'))(_c('0')))).toBe(NOrd.GT); expect($o(cmp._(_c('a'))._(_c('0')))).toBe(NOrd.GT);
}); });
it('"z" cmp "z" is EQ', () => { it('"z" cmp "z" is EQ', () => {
expect($o(cmp(_c('z'))(_c('z')))).toBe(NOrd.EQ); expect($o(cmp._(_c('z'))._(_c('z')))).toBe(NOrd.EQ);
}); });
it('"z" cmp "-" is GT', () => { it('"z" cmp "-" is GT', () => {
expect($o(cmp(_c('z'))(_c('-')))).toBe(NOrd.GT); expect($o(cmp._(_c('z'))._(_c('-')))).toBe(NOrd.GT);
}); });
it('"-" cmp "z" is LT', () => { it('"-" cmp "z" is LT', () => {
expect($o(cmp(_c('-'))(_c('z')))).toBe(NOrd.LT); expect($o(cmp._(_c('-'))._(_c('z')))).toBe(NOrd.LT);
}); });
}); });
describe('lt', () => { describe('lt', () => {
it('"0" lt "0" is False', () => { it('"0" lt "0" is False', () => {
expect($b(lt(_c('0'))(_c('0')))).toBe(false); expect($b(lt._(_c('0'))._(_c('0')))).toBe(false);
}); });
it('"0" lt "a" is True', () => { it('"0" lt "a" is True', () => {
expect($b(lt(_c('0'))(_c('a')))).toBe(true); expect($b(lt._(_c('0'))._(_c('a')))).toBe(true);
}); });
it('"a" lt "0" is False', () => { it('"a" lt "0" is False', () => {
expect($b(lt(_c('a'))(_c('0')))).toBe(false); expect($b(lt._(_c('a'))._(_c('0')))).toBe(false);
}); });
it('"z" lt "z" is False', () => { it('"z" lt "z" is False', () => {
expect($b(lt(_c('z'))(_c('z')))).toBe(false); expect($b(lt._(_c('z'))._(_c('z')))).toBe(false);
}); });
it('"z" lt "-" is False', () => { it('"z" lt "-" is False', () => {
expect($b(lt(_c('z'))(_c('-')))).toBe(false); expect($b(lt._(_c('z'))._(_c('-')))).toBe(false);
}); });
it('"-" lt "z" is True', () => { it('"-" lt "z" is True', () => {
expect($b(lt(_c('-'))(_c('z')))).toBe(true); expect($b(lt._(_c('-'))._(_c('z')))).toBe(true);
}); });
}); });
describe('le', () => { describe('le', () => {
it('"0" le "0" is True', () => { it('"0" le "0" is True', () => {
expect($b(le(_c('0'))(_c('0')))).toBe(true); expect($b(le._(_c('0'))._(_c('0')))).toBe(true);
}); });
it('"0" le "a" is True', () => { it('"0" le "a" is True', () => {
expect($b(le(_c('0'))(_c('a')))).toBe(true); expect($b(le._(_c('0'))._(_c('a')))).toBe(true);
}); });
it('"a" le "0" is False', () => { it('"a" le "0" is False', () => {
expect($b(le(_c('a'))(_c('0')))).toBe(false); expect($b(le._(_c('a'))._(_c('0')))).toBe(false);
}); });
it('"z" le "z" is True', () => { it('"z" le "z" is True', () => {
expect($b(le(_c('z'))(_c('z')))).toBe(true); expect($b(le._(_c('z'))._(_c('z')))).toBe(true);
}); });
it('"z" le "-" is False', () => { it('"z" le "-" is False', () => {
expect($b(le(_c('z'))(_c('-')))).toBe(false); expect($b(le._(_c('z'))._(_c('-')))).toBe(false);
}); });
it('"-" le "z" is True', () => { it('"-" le "z" is True', () => {
expect($b(le(_c('-'))(_c('z')))).toBe(true); expect($b(le._(_c('-'))._(_c('z')))).toBe(true);
}); });
}); });
describe('eq', () => { describe('eq', () => {
it('"0" eq "0" is True', () => { it('"0" eq "0" is True', () => {
expect($b(eq(_c('0'))(_c('0')))).toBe(true); expect($b(eq._(_c('0'))._(_c('0')))).toBe(true);
}); });
it('"0" eq "a" is False', () => { it('"0" eq "a" is False', () => {
expect($b(eq(_c('0'))(_c('a')))).toBe(false); expect($b(eq._(_c('0'))._(_c('a')))).toBe(false);
}); });
it('"a" eq "0" is False', () => { it('"a" eq "0" is False', () => {
expect($b(eq(_c('a'))(_c('0')))).toBe(false); expect($b(eq._(_c('a'))._(_c('0')))).toBe(false);
}); });
it('"z" eq "z" is True', () => { it('"z" eq "z" is True', () => {
expect($b(eq(_c('z'))(_c('z')))).toBe(true); expect($b(eq._(_c('z'))._(_c('z')))).toBe(true);
}); });
it('"z" eq "-" is False', () => { it('"z" eq "-" is False', () => {
expect($b(eq(_c('z'))(_c('-')))).toBe(false); expect($b(eq._(_c('z'))._(_c('-')))).toBe(false);
}); });
it('"-" eq "z" is False', () => { it('"-" eq "z" is False', () => {
expect($b(eq(_c('-'))(_c('z')))).toBe(false); expect($b(eq._(_c('-'))._(_c('z')))).toBe(false);
}); });
}); });
describe('ge', () => { describe('ge', () => {
it('"0" ge "0" is True', () => { it('"0" ge "0" is True', () => {
expect($b(ge(_c('0'))(_c('0')))).toBe(true); expect($b(ge._(_c('0'))._(_c('0')))).toBe(true);
}); });
it('"0" ge "a" is False', () => { it('"0" ge "a" is False', () => {
expect($b(ge(_c('0'))(_c('a')))).toBe(false); expect($b(ge._(_c('0'))._(_c('a')))).toBe(false);
}); });
it('"a" ge "0" is True', () => { it('"a" ge "0" is True', () => {
expect($b(ge(_c('a'))(_c('0')))).toBe(true); expect($b(ge._(_c('a'))._(_c('0')))).toBe(true);
}); });
it('"z" ge "z" is True', () => { it('"z" ge "z" is True', () => {
expect($b(ge(_c('z'))(_c('z')))).toBe(true); expect($b(ge._(_c('z'))._(_c('z')))).toBe(true);
}); });
it('"z" ge "-" is True', () => { it('"z" ge "-" is True', () => {
expect($b(ge(_c('z'))(_c('-')))).toBe(true); expect($b(ge._(_c('z'))._(_c('-')))).toBe(true);
}); });
it('"-" ge "z" is False', () => { it('"-" ge "z" is False', () => {
expect($b(ge(_c('-'))(_c('z')))).toBe(false); expect($b(ge._(_c('-'))._(_c('z')))).toBe(false);
}); });
}); });
describe('gt', () => { describe('gt', () => {
it('"0" gt "0" is False', () => { it('"0" gt "0" is False', () => {
expect($b(gt(_c('0'))(_c('0')))).toBe(false); expect($b(gt._(_c('0'))._(_c('0')))).toBe(false);
}); });
it('"0" gt "a" is False', () => { it('"0" gt "a" is False', () => {
expect($b(gt(_c('0'))(_c('a')))).toBe(false); expect($b(gt._(_c('0'))._(_c('a')))).toBe(false);
}); });
it('"a" gt "0" is True', () => { it('"a" gt "0" is True', () => {
expect($b(gt(_c('a'))(_c('0')))).toBe(true); expect($b(gt._(_c('a'))._(_c('0')))).toBe(true);
}); });
it('"z" gt "z" is False', () => { it('"z" gt "z" is False', () => {
expect($b(gt(_c('z'))(_c('z')))).toBe(false); expect($b(gt._(_c('z'))._(_c('z')))).toBe(false);
}); });
it('"z" gt "-" is True', () => { it('"z" gt "-" is True', () => {
expect($b(gt(_c('z'))(_c('-')))).toBe(true); expect($b(gt._(_c('z'))._(_c('-')))).toBe(true);
}); });
it('"-" gt "z" is False', () => { it('"-" gt "z" is False', () => {
expect($b(gt(_c('-'))(_c('z')))).toBe(false); expect($b(gt._(_c('-'))._(_c('z')))).toBe(false);
}); });
}); });
describe('show', () => { describe('show', () => {
it('show "0" is "\'0\'"', () => { it('show "0" is "\'0\'"', () => {
expect($s(show(_c('0')))).toBe('\'0\''); expect($s(show._(_c('0')))).toBe('\'0\'');
}); });
it('show "a" is "\'a\'"', () => { it('show "a" is "\'a\'"', () => {
expect($s(show(_c('a')))).toBe('\'a\''); expect($s(show._(_c('a')))).toBe('\'a\'');
}); });
it('show "-" is "\'-\'"', () => { it('show "-" is "\'-\'"', () => {
expect($s(show(_c('-')))).toBe('\'-\''); expect($s(show._(_c('-')))).toBe('\'-\'');
}); });
}); });
}); });

8
test/core.spec.ts
Unescape View File

@ -1,19 +1,19 @@
import { describe, expect, it } from '@jest/globals'; import { describe, expect, it } from '@jest/globals';
import { toNative as $$, _, fromNative as __, cnst, id, undef } from '../src/core'; import { $, _, cnst, id, undef } from '../src/core';
describe('id', () => { describe('id', () => {
it('returns first argument', () => { it('returns first argument', () => {
expect($$(id(__('first')))).toBe('first'); expect($(id._(_('first')))).toBe('first');
}); });
}); });
describe('cnst', () => { describe('cnst', () => {
it('returns first argument after receiving second', () => { it('returns first argument after receiving second', () => {
expect($$(cnst(__('first'))(__('second')))).toBe('first'); expect($(cnst._(_('first'))._(_('second')))).toBe('first');
}); });
it('ignores second argument', () => { it('ignores second argument', () => {
expect($$(cnst(__('first'))(undef))).toBe('first'); expect($(cnst._(_('first'))._(undef))).toBe('first');
}); });
}); });

348
test/list.spec.ts
Unescape View File

@ -1,20 +1,22 @@
import { describe, expect, it } from '@jest/globals'; import { describe, expect, it } from '@jest/globals';
import { toNative as $$, _, fromNative as __, undef, y } from '../src/core'; import { $, Term, _, d, g, l, m, undef } 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, Succ, Zero, fromNumber as _n, fromNumber as _nn, cmp as cmpn, eq as eqn, even, gt as ngt, odd, succ, sum, } from '../src/num';
import { toArray as $a, Cons, Nil, fromArray as _a, all, any, append, cmp, concat, cons, eq, filter, foldl, foldlz, foldr, foldrz, ge, get, gt, head, intersperse, iterate, le, len, lt, map, nul, set, singleton, snoc, tail, update } from '../src/list';
import { toChar as $c } from '../src/char'; import { toChar as $c } from '../src/char';
import { toArray as $a, Cons, List, Nil, fromArray as _a, all, any, append, cmp, concat, cons, eq, filter, foldl, foldlz, foldr, foldrz, ge, get, gt, head, intersperse, iterate, le, len, lt, map, nul, set, show, singleton, snoc, tail, update } from '../src/list';
import { toString as $s } from '../src/string'; import { toString as $s } from '../src/string';
import { show as nshow } from '../src/num.show';
import { show } from '../src/list.show';
m('list.spec');
describe('List', () => { describe('List', () => {
const infinite: List<Num> = iterate(Succ)(Zero); const infinite: Term = g('infinite', iterate._(Succ)._(Zero));
const _na: (xs: number[]) => List<Num> const _na: (xs: number[]) => Term = xs => !xs.length ? Nil : Cons._(_n(xs[0]))._(d(() => _na(xs.slice(1))));
= xs => xs.length === 0 ? Nil : Cons(_nn(xs[0]))(y(() => _na(xs.slice(1))));
const $na: (xs: List<Num>) => number[] const $na: (xs: Term) => number[] = xs => $(xs._(_([]))._(l('x', l('xs', d(bs => _([$n(bs['x']), ...$na(bs['xs'])]))))));
= xs => $$(xs(__([]))(_(x => _(xs => __([$nn(x), ...$na(xs)])))));
describe('toArray', () => { describe('toArray', () => {
it('converts []', () => { it('converts []', () => {
@ -22,11 +24,11 @@ describe('List', () => {
}); });
it('converts [0]', () => { it('converts [0]', () => {
expect($a(Cons(_n(0))(Nil)).map($n)).toEqual([0]); expect($a(Cons._(_n(0))._(Nil)).map($n)).toEqual([0]);
}); });
it('converts [0, 1]', () => { it('converts [0, 1]', () => {
expect($a(Cons(_n(0))(Cons(_n(1))(Nil))).map($n)).toEqual([0, 1]); expect($a(Cons._(_n(0))._(Cons._(_n(1))._(Nil))).map($n)).toEqual([0, 1]);
}); });
}); });
@ -46,679 +48,679 @@ describe('List', () => {
describe('cons', () => { describe('cons', () => {
it('0 cons Nil is [0]', () => { it('0 cons Nil is [0]', () => {
expect($na(cons(_n(0))(Nil))).toEqual([0]); expect($na(cons._(_n(0))._(Nil))).toEqual([0]);
}); });
it('0 cons [1] is [0, 1]', () => { it('0 cons [1] is [0, 1]', () => {
expect($na(cons(_n(0))(_na([1])))).toEqual([0, 1]); expect($na(cons._(_n(0))._(_na([1])))).toEqual([0, 1]);
}); });
it('0 cons [1, 2] is [0, 1, 2]', () => { it('0 cons [1, 2] is [0, 1, 2]', () => {
expect($na(cons(_n(0))(_na([1, 2])))).toEqual([0, 1, 2]); expect($na(cons._(_n(0))._(_na([1, 2])))).toEqual([0, 1, 2]);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($n(cons(_n(0))(infinite)(undef)(_(x => _(_xs => x))))).toBe(0); expect($n(cons._(_n(0))._(infinite)._(undef)._(l('x', l('_', 'x'))))).toBe(0);
}); });
}); });
describe('snoc', () => { describe('snoc', () => {
it('Nil snoc 0 is [0]', () => { it('Nil snoc 0 is [0]', () => {
expect($na(snoc(Nil)(_n(0)))).toEqual([0]); expect($na(snoc._(Nil)._(_n(0)))).toEqual([0]);
}); });
it('[1] snoc 0 is [1, 0]', () => { it('[1] snoc 0 is [1, 0]', () => {
expect($na(snoc(_na([1]))(_n(0)))).toEqual([1, 0]); expect($na(snoc._(_na([1]))._(_n(0)))).toEqual([1, 0]);
}); });
it('[1, 2] snoc 0 is [1, 2, 0]', () => { it('[1, 2] snoc 0 is [1, 2, 0]', () => {
expect($na(snoc(_na([1, 2]))(_n(0)))).toEqual([1, 2, 0]); expect($na(snoc._(_na([1, 2]))._(_n(0)))).toEqual([1, 2, 0]);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($n(snoc(infinite)(_n(0))(undef)(_(x => _(_xs => x))))).toBe(0); expect($n(snoc._(infinite)._(_n(0))._(undef)._(l('x', l('_', 'x'))))).toBe(0);
}); });
}); });
describe('nul', () => { describe('nul', () => {
it('nul Nil is True', () => { it('nul Nil is True', () => {
expect($b(nul(_na([])))).toEqual(true); expect($b(nul._(_na([])))).toEqual(true);
}); });
it('nul [1] is False', () => { it('nul [1] is False', () => {
expect($b(nul(_na([1])))).toEqual(false); expect($b(nul._(_na([1])))).toEqual(false);
}); });
it('nul [1, 2] is False', () => { it('nul [1, 2] is False', () => {
expect($b(nul(_na([1, 2])))).toEqual(false); expect($b(nul._(_na([1, 2])))).toEqual(false);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($b(nul(infinite))).toEqual(false); expect($b(nul._(infinite))).toEqual(false);
}); });
}); });
describe('len', () => { describe('len', () => {
it('len Nil is 0', () => { it('len Nil is 0', () => {
expect($n(len(_na([])))).toEqual(0); expect($n(len._(_na([])))).toEqual(0);
}); });
it('len [1] is 1', () => { it('len [1] is 1', () => {
expect($n(len(_na([1])))).toEqual(1); expect($n(len._(_na([1])))).toEqual(1);
}); });
it('len [1, 2] is 2', () => { it('len [1, 2] is 2', () => {
expect($n(len(_na([1, 2])))).toEqual(2); expect($n(len._(_na([1, 2])))).toEqual(2);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($b(ngt(len(infinite))(Zero))).toEqual(true); expect($b(ngt._(len._(infinite))._(Zero))).toEqual(true);
}); });
it('ignores items', () => { it('ignores items', () => {
expect($n(len(cons(undef)(cons(undef)(Nil))))).toEqual(2); expect($n(len._(cons._(undef)._(cons._(undef)._(Nil))))).toEqual(2);
}); });
}); });
describe('singleton', () => { describe('singleton', () => {
it('singleton 0 is [0]', () => { it('singleton 0 is [0]', () => {
expect($na(singleton(_n(0)))).toEqual([0]); expect($na(singleton._(_n(0)))).toEqual([0]);
}); });
}); });
describe('append', () => { describe('append', () => {
it('Nil append Nil is Nil', () => { it('Nil append Nil is Nil', () => {
expect($na(append(Nil)(Nil))).toEqual([]); expect($na(append._(Nil)._(Nil))).toEqual([]);
}); });
it('[0] append [1] is [0, 1]', () => { it('[0] append [1] is [0, 1]', () => {
expect($na(append(_na([0]))(_na([1])))).toEqual([0, 1]); expect($na(append._(_na([0]))._(_na([1])))).toEqual([0, 1]);
}); });
it('[0, 1] append [2, 3] is [0, 1, 2, 3]', () => { it('[0, 1] append [2, 3] is [0, 1, 2, 3]', () => {
expect($na(append(_na([0, 1]))(_na([2, 3])))).toEqual([0, 1, 2, 3]); expect($na(append._(_na([0, 1]))._(_na([2, 3])))).toEqual([0, 1, 2, 3]);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($n(append(infinite)(infinite)(undef)(_(x => _(_xs => x))))).toBe(0); expect($n(append._(infinite)._(infinite)._(undef)._(l('x', l('_', 'x'))))).toBe(0);
}); });
}); });
describe('concat', () => { describe('concat', () => {
it('concat [Nil, Nil, Nil] is Nil', () => { it('concat [Nil, Nil, Nil] is Nil', () => {
expect($na(concat(cons(Nil)(cons(Nil)(cons(Nil)(Nil)))))).toEqual([]); expect($na(concat._(cons._(Nil)._(cons._(Nil)._(cons._(Nil)._(Nil)))))).toEqual([]);
}); });
it('concat [[0], [1], [2]] is [0, 1, 2]', () => { it('concat [[0], [1], [2]] is [0, 1, 2]', () => {
expect($na(concat(cons(_na([0]))(cons(_na([1]))(cons(_na([2]))(Nil)))))).toEqual([0, 1, 2]); expect($na(concat._(cons._(_na([0]))._(cons._(_na([1]))._(cons._(_na([2]))._(Nil)))))).toEqual([0, 1, 2]);
}); });
it('concat [[0, 1], [2, 3], [4, 5]] is [0, 1, 2, 3, 4, 5]', () => { it('concat [[0, 1], [2, 3], [4, 5]] is [0, 1, 2, 3, 4, 5]', () => {
expect($na(concat(cons(_na([0, 1]))(cons(_na([2, 3]))(cons(_na([4, 5]))(Nil)))))).toEqual([0, 1, 2, 3, 4, 5]); expect($na(concat._(cons._(_na([0, 1]))._(cons._(_na([2, 3]))._(cons._(_na([4, 5]))._(Nil)))))).toEqual([0, 1, 2, 3, 4, 5]);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
const dinfinite: List<Num> = cons(infinite)(y(() => dinfinite)); const dinfinite: Term = g('dinfinite', cons._(infinite)._('dinfinite'));
expect($n(concat(dinfinite)(undef)(_(x => _(_xs => x))))).toBe(0); expect($n(concat._(dinfinite)._(undef)._(l('x', l('_', 'x'))))).toBe(0);
}); });
}); });
// describe('repeat', () => { // describe('repeat', () => {
// it('repeat 0 is [0, 0, 0, ...]', () => { // it('repeat 0 is [0, 0, 0, ...]', () => {
// expect($na( // expect($na(
// repeat(_n(0))<List<Num>>(_((x0: Num) => _((x1s: List<Num>) => // repeat._(_n(0))<List<Num>>(l((x0: Num) => l((x1s: List<Num>) =>
// x1s<List<Num>>(_((x1: Num) => _((x2s: List<Num>) => // x1s<List<Num>>(l((x1: Num) => l((x2s: List<Num>) =>
// x2s<List<Num>>(_((x2: Num) => _((_xrs: List<Num>): List<Num> => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual([0, 0, 0]); // x2s<List<Num>>(l((x2: Num) => l((_xrs: List<Num>): List<Num> => cons._(x0)._(cons._(x1)._(cons._(x2)._(Nil)))))))))))))).toEqual([0, 0, 0]);
// }); // });
// }); // });
// describe('iterate', () => { // describe('iterate', () => {
// it('iterate succ 0 is [0, 1, 2, ...]', () => { // it('iterate succ 0 is [0, 1, 2, ...]', () => {
// expect($na( // expect($na(
// iterate(_n(0))<List<Num>>(_((x0: Num) => _((x1s: List<Num>) => // iterate._(_n(0))<List<Num>>(l((x0: Num) => l((x1s: List<Num>) =>
// x1s<List<Num>>(_((x1: Num) => _((x2s: List<Num>) => // x1s<List<Num>>(l((x1: Num) => l((x2s: List<Num>) =>
// x2s<List<Num>>(_((x2: Num) => _((_xrs: List<Num>): List<Num> => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual([0, 1, 2]); // x2s<List<Num>>(l((x2: Num) => l((_xrs: List<Num>): List<Num> => cons._(x0)._(cons._(x1)._(cons._(x2)._(Nil)))))))))))))).toEqual([0, 1, 2]);
// }); // });
// }); // });
describe('head', () => { describe('head', () => {
it('returns nothing from Nil', () => { it('returns nothing from Nil', () => {
expect(() => $$(head(Nil))).toThrow(); expect(() => $(head._(Nil))).toThrow();
}); });
it('returns only item', () => { it('returns only item', () => {
expect($n(head(_na([0])))).toBe(0); expect($n(head._(_na([0])))).toBe(0);
}); });
it('returns first item', () => { it('returns first item', () => {
expect($n(head(_na([0, 1])))).toBe(0); expect($n(head._(_na([0, 1])))).toBe(0);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($n(head(infinite))).toBe(0); expect($n(head._(infinite))).toBe(0);
}); });
}); });
describe('tail', () => { describe('tail', () => {
it('drops nothing from Nil', () => { it('drops nothing from Nil', () => {
expect(() => $na(tail(Nil))).toThrow(); expect(() => $na(tail._(Nil))).toThrow();
}); });
it('drops only item', () => { it('drops only item', () => {
expect($na(tail(_na([0])))).toEqual([]); expect($na(tail._(_na([0])))).toEqual([]);
}); });
it('drops first item', () => { it('drops first item', () => {
expect($na(tail(_na([0, 1])))).toEqual([1]); expect($na(tail._(_na([0, 1])))).toEqual([1]);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($n(head(tail(infinite)))).toBe(1); expect($n(head._(tail._(infinite)))).toBe(1);
}); });
}); });
describe('foldl', () => { describe('foldl', () => {
it('folds Nil', () => { it('folds Nil', () => {
expect($n(foldl(sum)(Zero)(_na([])))).toBe(0); expect($n(foldl._(sum)._(Zero)._(_na([])))).toBe(0);
}); });
it('folds single item', () => { it('folds single item', () => {
expect($n(foldl(sum)(Zero)(_na([1])))).toBe(1); expect($n(foldl._(sum)._(Zero)._(_na([1])))).toBe(1);
}); });
it('folds several items', () => { it('folds several items', () => {
expect($n(foldl(sum)(Zero)(_na([1, 2])))).toBe(3); expect($n(foldl._(sum)._(Zero)._(_na([1, 2])))).toBe(3);
}); });
}); });
describe('foldlz', () => { describe('foldlz', () => {
it('does not fold Nil', () => { it('does not fold Nil', () => {
expect(() => $n(foldlz(sum)(Nil))).toThrow(); expect(() => $n(foldlz._(sum)._(Nil))).toThrow();
}); });
it('folds single item', () => { it('folds single item', () => {
expect($n(foldlz(sum)(_na([1])))).toBe(1); expect($n(foldlz._(sum)._(_na([1])))).toBe(1);
}); });
it('folds several items', () => { it('folds several items', () => {
expect($n(foldlz(sum)(_na([1, 2])))).toBe(3); expect($n(foldlz._(sum)._(_na([1, 2])))).toBe(3);
}); });
}); });
describe('foldr', () => { describe('foldr', () => {
it('folds Nil', () => { it('folds Nil', () => {
expect($n(foldr(sum)(Zero)(_na([])))).toBe(0); expect($n(foldr._(sum)._(Zero)._(_na([])))).toBe(0);
}); });
it('folds single item', () => { it('folds single item', () => {
expect($n(foldr(sum)(Zero)(_na([1])))).toBe(1); expect($n(foldr._(sum)._(Zero)._(_na([1])))).toBe(1);
}); });
it('folds several items', () => { it('folds several items', () => {
expect($n(foldr(sum)(Zero)(_na([1, 2])))).toBe(3); expect($n(foldr._(sum)._(Zero)._(_na([1, 2])))).toBe(3);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($n( expect($n(
foldr foldr
(_(x => _(a => sum(x)(iif(eqn(_n(5))(x))(Zero)(a))))) ._(l('x', l('a', sum._('x')._(iif._(eqn._(_n(5))._('x'))._(Zero)._('a')))))
(Zero) ._(Zero)
(infinite))) ._(infinite)))
.toBe(15); .toBe(15);
}); });
}); });
describe('foldrz', () => { describe('foldrz', () => {
it('does not fold Nil', () => { it('does not fold Nil', () => {
expect(() => $n(foldrz(sum)(Nil))).toThrow(); expect(() => $n(foldrz._(sum)._(Nil))).toThrow();
}); });
it.failing('folds single item', () => { it.failing('folds single item', () => {
expect($n(foldrz(sum)(_na([1])))).toBe(1); expect($n(foldrz._(sum)._(_na([1])))).toBe(1);
}); });
it.failing('folds several items', () => { it.failing('folds several items', () => {
expect($n(foldrz(sum)(_na([1, 2])))).toBe(3); expect($n(foldrz._(sum)._(_na([1, 2])))).toBe(3);
}); });
it.failing('handles infinite lists', () => { it.failing('handles infinite lists', () => {
expect($n( expect($n(
foldrz foldrz
(_(x => _(a => sum(x)(iif(eqn(_n(5))(x))(Zero)(a))))) ._(l('x', l('a', sum._('x')._(iif._(eqn._(_n(5))._('x'))._(Zero)._('a')))))
(infinite))) ._(infinite)))
.toBe(15); .toBe(15);
}); });
}); });
describe('cmp', () => { describe('cmp', () => {
it('Nil cmp Nil is EQ', () => { it('Nil cmp Nil is EQ', () => {
expect($o(cmp(cmpn)(_na([]))(_na([])))).toEqual(NOrd.EQ); expect($o(cmp._(cmpn)._(_na([]))._(_na([])))).toEqual(NOrd.EQ);
}); });
it('Nil cmp [0, 1, 2] is LT', () => { it('Nil cmp [0, 1, 2] is LT', () => {
expect($o(cmp(cmpn)(_na([]))(_na([0, 1, 2])))).toEqual(NOrd.LT); expect($o(cmp._(cmpn)._(_na([]))._(_na([0, 1, 2])))).toEqual(NOrd.LT);
}); });
it('[0, 1, 2] cmp Nil is GT', () => { it('[0, 1, 2] cmp Nil is GT', () => {
expect($o(cmp(cmpn)(_na([0, 1, 2]))(_na([])))).toEqual(NOrd.GT); expect($o(cmp._(cmpn)._(_na([0, 1, 2]))._(_na([])))).toEqual(NOrd.GT);
}); });
it('[0] cmp [0, 1, 2] is LT', () => { it('[0] cmp [0, 1, 2] is LT', () => {
expect($o(cmp(cmpn)(_na([0]))(_na([0, 1, 2])))).toEqual(NOrd.LT); expect($o(cmp._(cmpn)._(_na([0]))._(_na([0, 1, 2])))).toEqual(NOrd.LT);
}); });
it('[0, 1, 2] cmp [0] is GT', () => { it('[0, 1, 2] cmp [0] is GT', () => {
expect($o(cmp(cmpn)(_na([0, 1, 2]))(_na([0])))).toEqual(NOrd.GT); expect($o(cmp._(cmpn)._(_na([0, 1, 2]))._(_na([0])))).toEqual(NOrd.GT);
}); });
it('[1, 2, 0] cmp [0, 1, 2] is GT', () => { it('[1, 2, 0] cmp [0, 1, 2] is GT', () => {
expect($o(cmp(cmpn)(_na([1, 2, 0]))(_na([0, 1, 2])))).toEqual(NOrd.GT); expect($o(cmp._(cmpn)._(_na([1, 2, 0]))._(_na([0, 1, 2])))).toEqual(NOrd.GT);
}); });
it('[0, 1, 2] cmp [1, 2, 0] is LT', () => { it('[0, 1, 2] cmp [1, 2, 0] is LT', () => {
expect($o(cmp(cmpn)(_na([0, 1, 2]))(_na([1, 2, 0])))).toEqual(NOrd.LT); expect($o(cmp._(cmpn)._(_na([0, 1, 2]))._(_na([1, 2, 0])))).toEqual(NOrd.LT);
}); });
it('[0, 1, 2] cmp [0, 1, 2] is EQ', () => { it('[0, 1, 2] cmp [0, 1, 2] is EQ', () => {
expect($o(cmp(cmpn)(_na([0, 1, 2]))(_na([0, 1, 2])))).toEqual(NOrd.EQ); expect($o(cmp._(cmpn)._(_na([0, 1, 2]))._(_na([0, 1, 2])))).toEqual(NOrd.EQ);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($o(cmp(cmpn)(_na([0, 1, 2]))(infinite))).toEqual(NOrd.LT); expect($o(cmp._(cmpn)._(_na([0, 1, 2]))._(infinite))).toEqual(NOrd.LT);
expect($o(cmp(cmpn)(infinite)(_na([0, 1, 2])))).toEqual(NOrd.GT); expect($o(cmp._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(NOrd.GT);
}); });
}); });
describe('lt', () => { describe('lt', () => {
it('Nil lt Nil is False', () => { it('Nil lt Nil is False', () => {
expect($b(lt(cmpn)(_na([]))(_na([])))).toEqual(false); expect($b(lt._(cmpn)._(_na([]))._(_na([])))).toEqual(false);
}); });
it('Nil lt [0, 1, 2] is True', () => { it('Nil lt [0, 1, 2] is True', () => {
expect($b(lt(cmpn)(_na([]))(_na([0, 1, 2])))).toEqual(true); expect($b(lt._(cmpn)._(_na([]))._(_na([0, 1, 2])))).toEqual(true);
}); });
it('[0, 1, 2] lt Nil is False', () => { it('[0, 1, 2] lt Nil is False', () => {
expect($b(lt(cmpn)(_na([0, 1, 2]))(_na([])))).toEqual(false); expect($b(lt._(cmpn)._(_na([0, 1, 2]))._(_na([])))).toEqual(false);
}); });
it('[0] lt [0, 1, 2] is True', () => { it('[0] lt [0, 1, 2] is True', () => {
expect($b(lt(cmpn)(_na([0]))(_na([0, 1, 2])))).toEqual(true); expect($b(lt._(cmpn)._(_na([0]))._(_na([0, 1, 2])))).toEqual(true);
}); });
it('[0, 1, 2] lt [0] is False', () => { it('[0, 1, 2] lt [0] is False', () => {
expect($b(lt(cmpn)(_na([0, 1, 2]))(_na([0])))).toEqual(false); expect($b(lt._(cmpn)._(_na([0, 1, 2]))._(_na([0])))).toEqual(false);
}); });
it('[1, 2, 0] lt [0, 1, 2] is False', () => { it('[1, 2, 0] lt [0, 1, 2] is False', () => {
expect($b(lt(cmpn)(_na([1, 2, 0]))(_na([0, 1, 2])))).toEqual(false); expect($b(lt._(cmpn)._(_na([1, 2, 0]))._(_na([0, 1, 2])))).toEqual(false);
}); });
it('[0, 1, 2] lt [1, 2, 0] is True', () => { it('[0, 1, 2] lt [1, 2, 0] is True', () => {
expect($b(lt(cmpn)(_na([0, 1, 2]))(_na([1, 2, 0])))).toEqual(true); expect($b(lt._(cmpn)._(_na([0, 1, 2]))._(_na([1, 2, 0])))).toEqual(true);
}); });
it('[0, 1, 2] lt [0, 1, 2] is False', () => { it('[0, 1, 2] lt [0, 1, 2] is False', () => {
expect($b(lt(cmpn)(_na([0, 1, 2]))(_na([0, 1, 2])))).toEqual(false); expect($b(lt._(cmpn)._(_na([0, 1, 2]))._(_na([0, 1, 2])))).toEqual(false);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($b(lt(cmpn)(_na([0, 1, 2]))(infinite))).toEqual(true); expect($b(lt._(cmpn)._(_na([0, 1, 2]))._(infinite))).toEqual(true);
expect($b(lt(cmpn)(infinite)(_na([0, 1, 2])))).toEqual(false); expect($b(lt._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(false);
}); });
}); });
describe('le', () => { describe('le', () => {
it('Nil le Nil is True', () => { it('Nil le Nil is True', () => {
expect($b(le(cmpn)(_na([]))(_na([])))).toEqual(true); expect($b(le._(cmpn)._(_na([]))._(_na([])))).toEqual(true);
}); });
it('Nil le [0, 1, 2] is True', () => { it('Nil le [0, 1, 2] is True', () => {
expect($b(le(cmpn)(_na([]))(_na([0, 1, 2])))).toEqual(true); expect($b(le._(cmpn)._(_na([]))._(_na([0, 1, 2])))).toEqual(true);
}); });
it('[0, 1, 2] le Nil is False', () => { it('[0, 1, 2] le Nil is False', () => {
expect($b(le(cmpn)(_na([0, 1, 2]))(_na([])))).toEqual(false); expect($b(le._(cmpn)._(_na([0, 1, 2]))._(_na([])))).toEqual(false);
}); });
it('[0] le [0, 1, 2] is True', () => { it('[0] le [0, 1, 2] is True', () => {
expect($b(le(cmpn)(_na([0]))(_na([0, 1, 2])))).toEqual(true); expect($b(le._(cmpn)._(_na([0]))._(_na([0, 1, 2])))).toEqual(true);
}); });
it('[0, 1, 2] le [0] is False', () => { it('[0, 1, 2] le [0] is False', () => {
expect($b(le(cmpn)(_na([0, 1, 2]))(_na([0])))).toEqual(false); expect($b(le._(cmpn)._(_na([0, 1, 2]))._(_na([0])))).toEqual(false);
}); });
it('[1, 2, 0] le [0, 1, 2] is False', () => { it('[1, 2, 0] le [0, 1, 2] is False', () => {
expect($b(le(cmpn)(_na([1, 2, 0]))(_na([0, 1, 2])))).toEqual(false); expect($b(le._(cmpn)._(_na([1, 2, 0]))._(_na([0, 1, 2])))).toEqual(false);
}); });
it('[0, 1, 2] le [1, 2, 0] is True', () => { it('[0, 1, 2] le [1, 2, 0] is True', () => {
expect($b(le(cmpn)(_na([0, 1, 2]))(_na([1, 2, 0])))).toEqual(true); expect($b(le._(cmpn)._(_na([0, 1, 2]))._(_na([1, 2, 0])))).toEqual(true);
}); });
it('[0, 1, 2] le [0, 1, 2] is True', () => { it('[0, 1, 2] le [0, 1, 2] is True', () => {
expect($b(le(cmpn)(_na([0, 1, 2]))(_na([0, 1, 2])))).toEqual(true); expect($b(le._(cmpn)._(_na([0, 1, 2]))._(_na([0, 1, 2])))).toEqual(true);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($b(le(cmpn)(_na([0, 1, 2]))(infinite))).toEqual(true); expect($b(le._(cmpn)._(_na([0, 1, 2]))._(infinite))).toEqual(true);
expect($b(le(cmpn)(infinite)(_na([0, 1, 2])))).toEqual(false); expect($b(le._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(false);
}); });
}); });
describe('eq', () => { describe('eq', () => {
it('Nil eq Nil is True', () => { it('Nil eq Nil is True', () => {
expect($b(eq(eqn)(_na([]))(_na([])))).toEqual(true); expect($b(eq._(eqn)._(_na([]))._(_na([])))).toEqual(true);
}); });
it('Nil eq [0, 1, 2] is False', () => { it('Nil eq [0, 1, 2] is False', () => {
expect($b(eq(eqn)(_na([]))(_na([0, 1, 2])))).toEqual(false); expect($b(eq._(eqn)._(_na([]))._(_na([0, 1, 2])))).toEqual(false);
}); });
it('[0, 1, 2] eq Nil is False', () => { it('[0, 1, 2] eq Nil is False', () => {
expect($b(eq(eqn)(_na([0, 1, 2]))(_na([])))).toEqual(false); expect($b(eq._(eqn)._(_na([0, 1, 2]))._(_na([])))).toEqual(false);
}); });
it('[0] eq [0, 1, 2] is False', () => { it('[0] eq [0, 1, 2] is False', () => {
expect($b(eq(eqn)(_na([0]))(_na([0, 1, 2])))).toEqual(false); expect($b(eq._(eqn)._(_na([0]))._(_na([0, 1, 2])))).toEqual(false);
}); });
it('[0, 1, 2] eq [0] is False', () => { it('[0, 1, 2] eq [0] is False', () => {
expect($b(eq(eqn)(_na([0, 1, 2]))(_na([0])))).toEqual(false); expect($b(eq._(eqn)._(_na([0, 1, 2]))._(_na([0])))).toEqual(false);
}); });
it('[1, 2, 0] eq [0, 1, 2] is False', () => { it('[1, 2, 0] eq [0, 1, 2] is False', () => {
expect($b(eq(eqn)(_na([1, 2, 0]))(_na([0, 1, 2])))).toEqual(false); expect($b(eq._(eqn)._(_na([1, 2, 0]))._(_na([0, 1, 2])))).toEqual(false);
}); });
it('[0, 1, 2] eq [1, 2, 0] is False', () => { it('[0, 1, 2] eq [1, 2, 0] is False', () => {
expect($b(eq(eqn)(_na([0, 1, 2]))(_na([1, 2, 0])))).toEqual(false); expect($b(eq._(eqn)._(_na([0, 1, 2]))._(_na([1, 2, 0])))).toEqual(false);
}); });
it('[0, 1, 2] eq [0, 1, 2] is True', () => { it('[0, 1, 2] eq [0, 1, 2] is True', () => {
expect($b(eq(eqn)(_na([0, 1, 2]))(_na([0, 1, 2])))).toEqual(true); expect($b(eq._(eqn)._(_na([0, 1, 2]))._(_na([0, 1, 2])))).toEqual(true);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($b(eq(eqn)(_na([0, 1, 2]))(infinite))).toEqual(false); expect($b(eq._(eqn)._(_na([0, 1, 2]))._(infinite))).toEqual(false);
expect($b(eq(eqn)(infinite)(_na([0, 1, 2])))).toEqual(false); expect($b(eq._(eqn)._(infinite)._(_na([0, 1, 2])))).toEqual(false);
}); });
}); });
describe('ge', () => { describe('ge', () => {
it('Nil ge Nil is True', () => { it('Nil ge Nil is True', () => {
expect($b(ge(cmpn)(_na([]))(_na([])))).toEqual(true); expect($b(ge._(cmpn)._(_na([]))._(_na([])))).toEqual(true);
}); });
it('Nil ge [0, 1, 2] is False', () => { it('Nil ge [0, 1, 2] is False', () => {
expect($b(ge(cmpn)(_na([]))(_na([0, 1, 2])))).toEqual(false); expect($b(ge._(cmpn)._(_na([]))._(_na([0, 1, 2])))).toEqual(false);
}); });
it('[0, 1, 2] ge Nil is True', () => { it('[0, 1, 2] ge Nil is True', () => {
expect($b(ge(cmpn)(_na([0, 1, 2]))(_na([])))).toEqual(true); expect($b(ge._(cmpn)._(_na([0, 1, 2]))._(_na([])))).toEqual(true);
}); });
it('[0] ge [0, 1, 2] is False', () => { it('[0] ge [0, 1, 2] is False', () => {
expect($b(ge(cmpn)(_na([0]))(_na([0, 1, 2])))).toEqual(false); expect($b(ge._(cmpn)._(_na([0]))._(_na([0, 1, 2])))).toEqual(false);
}); });
it('[0, 1, 2] ge [0] is True', () => { it('[0, 1, 2] ge [0] is True', () => {
expect($b(ge(cmpn)(_na([0, 1, 2]))(_na([0])))).toEqual(true); expect($b(ge._(cmpn)._(_na([0, 1, 2]))._(_na([0])))).toEqual(true);
}); });
it('[1, 2, 0] ge [0, 1, 2] is True', () => { it('[1, 2, 0] ge [0, 1, 2] is True', () => {
expect($b(ge(cmpn)(_na([1, 2, 0]))(_na([0, 1, 2])))).toEqual(true); expect($b(ge._(cmpn)._(_na([1, 2, 0]))._(_na([0, 1, 2])))).toEqual(true);
}); });
it('[0, 1, 2] ge [1, 2, 0] is False', () => { it('[0, 1, 2] ge [1, 2, 0] is False', () => {
expect($b(ge(cmpn)(_na([0, 1, 2]))(_na([1, 2, 0])))).toEqual(false); expect($b(ge._(cmpn)._(_na([0, 1, 2]))._(_na([1, 2, 0])))).toEqual(false);
}); });
it('[0, 1, 2] ge [0, 1, 2] is True', () => { it('[0, 1, 2] ge [0, 1, 2] is True', () => {
expect($b(ge(cmpn)(_na([0, 1, 2]))(_na([0, 1, 2])))).toEqual(true); expect($b(ge._(cmpn)._(_na([0, 1, 2]))._(_na([0, 1, 2])))).toEqual(true);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($b(ge(cmpn)(_na([0, 1, 2]))(infinite))).toEqual(false); expect($b(ge._(cmpn)._(_na([0, 1, 2]))._(infinite))).toEqual(false);
expect($b(ge(cmpn)(infinite)(_na([0, 1, 2])))).toEqual(true); expect($b(ge._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(true);
}); });
}); });
describe('gt', () => { describe('gt', () => {
it('Nil gt Nil is False', () => { it('Nil gt Nil is False', () => {
expect($b(gt(cmpn)(_na([]))(_na([])))).toEqual(false); expect($b(gt._(cmpn)._(_na([]))._(_na([])))).toEqual(false);
}); });
it('Nil gt [0, 1, 2] is False', () => { it('Nil gt [0, 1, 2] is False', () => {
expect($b(gt(cmpn)(_na([]))(_na([0, 1, 2])))).toEqual(false); expect($b(gt._(cmpn)._(_na([]))._(_na([0, 1, 2])))).toEqual(false);
}); });
it('[0, 1, 2] gt Nil is True', () => { it('[0, 1, 2] gt Nil is True', () => {
expect($b(gt(cmpn)(_na([0, 1, 2]))(_na([])))).toEqual(true); expect($b(gt._(cmpn)._(_na([0, 1, 2]))._(_na([])))).toEqual(true);
}); });
it('[0] gt [0, 1, 2] is False', () => { it('[0] gt [0, 1, 2] is False', () => {
expect($b(gt(cmpn)(_na([0]))(_na([0, 1, 2])))).toEqual(false); expect($b(gt._(cmpn)._(_na([0]))._(_na([0, 1, 2])))).toEqual(false);
}); });
it('[0, 1, 2] gt [0] is True', () => { it('[0, 1, 2] gt [0] is True', () => {
expect($b(gt(cmpn)(_na([0, 1, 2]))(_na([0])))).toEqual(true); expect($b(gt._(cmpn)._(_na([0, 1, 2]))._(_na([0])))).toEqual(true);
}); });
it('[1, 2, 0] gt [0, 1, 2] is True', () => { it('[1, 2, 0] gt [0, 1, 2] is True', () => {
expect($b(gt(cmpn)(_na([1, 2, 0]))(_na([0, 1, 2])))).toEqual(true); expect($b(gt._(cmpn)._(_na([1, 2, 0]))._(_na([0, 1, 2])))).toEqual(true);
}); });
it('[0, 1, 2] gt [1, 2, 0] is False', () => { it('[0, 1, 2] gt [1, 2, 0] is False', () => {
expect($b(gt(cmpn)(_na([0, 1, 2]))(_na([1, 2, 0])))).toEqual(false); expect($b(gt._(cmpn)._(_na([0, 1, 2]))._(_na([1, 2, 0])))).toEqual(false);
}); });
it('[0, 1, 2] gt [0, 1, 2] is False', () => { it('[0, 1, 2] gt [0, 1, 2] is False', () => {
expect($b(gt(cmpn)(_na([0, 1, 2]))(_na([0, 1, 2])))).toEqual(false); expect($b(gt._(cmpn)._(_na([0, 1, 2]))._(_na([0, 1, 2])))).toEqual(false);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($b(gt(cmpn)(_na([0, 1, 2]))(infinite))).toEqual(false); expect($b(gt._(cmpn)._(_na([0, 1, 2]))._(infinite))).toEqual(false);
expect($b(gt(cmpn)(infinite)(_na([0, 1, 2])))).toEqual(true); expect($b(gt._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(true);
}); });
}); });
describe('map', () => { describe('map', () => {
it('maps Nil', () => { it('maps Nil', () => {
expect($na(map(succ)(_na([])))).toEqual([]); expect($na(map._(succ)._(_na([])))).toEqual([]);
}); });
it('maps only item', () => { it('maps only item', () => {
expect($na(map(succ)(_na([0])))).toEqual([1]); expect($na(map._(succ)._(_na([0])))).toEqual([1]);
}); });
it('maps several items', () => { it('maps several items', () => {
expect($na(map(succ)(_na([0, 1])))).toEqual([1, 2]); expect($na(map._(succ)._(_na([0, 1])))).toEqual([1, 2]);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($n(head(map(succ)(infinite)))).toBe(1); expect($n(head._(map._(succ)._(infinite)))).toBe(1);
}); });
}); });
describe('filter', () => { describe('filter', () => {
it('filter Nil', () => { it('filter Nil', () => {
expect($na(filter(odd)(_na([])))).toEqual([]); expect($na(filter._(odd)._(_na([])))).toEqual([]);
}); });
it('filters only item', () => { it('filters only item', () => {
expect($na(filter(odd)(_na([])))).toEqual([]); expect($na(filter._(odd)._(_na([])))).toEqual([]);
}); });
it('filters several items', () => { it('filters several items', () => {
expect($na(filter(odd)(_na([0, 1])))).toEqual([1]); expect($na(filter._(odd)._(_na([0, 1])))).toEqual([1]);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($n(head(filter(odd)(infinite)))).toBe(1); expect($n(head._(filter._(odd)._(infinite)))).toBe(1);
}); });
}); });
describe('any', () => { describe('any', () => {
it('any Nil is False', () => { it('any Nil is False', () => {
expect($b(any(odd)(_na([])))).toEqual(false); expect($b(any._(odd)._(_na([])))).toEqual(false);
}); });
it('any for no matching item is False', () => { it('any for no matching item is False', () => {
expect($b(any(odd)(_na([0, 2])))).toEqual(false); expect($b(any._(odd)._(_na([0, 2])))).toEqual(false);
}); });
it('any for matching item is True', () => { it('any for matching item is True', () => {
expect($b(any(odd)(_na([0, 1, 2])))).toEqual(true); expect($b(any._(odd)._(_na([0, 1, 2])))).toEqual(true);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($b(any(odd)(infinite))).toEqual(true); expect($b(any._(odd)._(infinite))).toEqual(true);
}); });
}); });
describe('all', () => { describe('all', () => {
it('all Nil is True', () => { it('all Nil is True', () => {
expect($b(all(even)(_na([])))).toEqual(true); expect($b(all._(even)._(_na([])))).toEqual(true);
}); });
it('all for non-matching item is False', () => { it('all for non-matching item is False', () => {
expect($b(all(even)(_na([0, 1, 2])))).toEqual(false); expect($b(all._(even)._(_na([0, 1, 2])))).toEqual(false);
}); });
it('all for no non-matching item is True', () => { it('all for no non-matching item is True', () => {
expect($b(all(even)(_na([0, 2])))).toEqual(true); expect($b(all._(even)._(_na([0, 2])))).toEqual(true);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($b(all(even)(infinite))).toEqual(false); expect($b(all._(even)._(infinite))).toEqual(false);
}); });
}); });
describe('get', () => { describe('get', () => {
it('returns nothing from Nil', () => { it('returns nothing from Nil', () => {
expect(() => $n(get(_n(0))(Nil))).toThrow(); expect(() => $n(get._(_n(0))._(Nil))).toThrow();
}); });
it('returns nothing with out of bounds index', () => { it('returns nothing with out of bounds index', () => {
expect(() => $n(get(_n(100))(_na([0, 1, 2, 3])))).toThrow(); expect(() => $n(get._(_n(100))._(_na([0, 1, 2, 3])))).toThrow();
}); });
it('[0, 1, 2, 3][0] is 0', () => { it('[0, 1, 2, 3][0] is 0', () => {
expect($n(get(_n(0))(_na([0, 1, 2, 3])))).toBe(0); expect($n(get._(_n(0))._(_na([0, 1, 2, 3])))).toBe(0);
}); });
it('[0, 1, 2, 3][1] is 1', () => { it('[0, 1, 2, 3][1] is 1', () => {
expect($n(get(_n(1))(_na([0, 1, 2, 3])))).toBe(1); expect($n(get._(_n(1))._(_na([0, 1, 2, 3])))).toBe(1);
}); });
it('[0, 1, 2, 3][2] is 2', () => { it('[0, 1, 2, 3][2] is 2', () => {
expect($n(get(_n(2))(_na([0, 1, 2, 3])))).toBe(2); expect($n(get._(_n(2))._(_na([0, 1, 2, 3])))).toBe(2);
}); });
it('[0, 1, 2, 3][3] get 3 is 3', () => { it('[0, 1, 2, 3][3] get 3 is 3', () => {
expect($n(get(_n(3))(_na([0, 1, 2, 3])))).toBe(3); expect($n(get._(_n(3))._(_na([0, 1, 2, 3])))).toBe(3);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($n(get(_n(4))(infinite))).toBe(4); expect($n(get._(_n(4))._(infinite))).toBe(4);
}); });
}); });
describe('set', () => { describe('set', () => {
it('can not update Nil', () => { it('can not update Nil', () => {
expect(() => $na(set(_n(10))(_n(0))(Nil))).toThrow(); expect(() => $na(set._(_n(10))._(_n(0))._(Nil))).toThrow();
}); });
it('can not update out of bounds index', () => { it('can not update out of bounds index', () => {
expect(() => $na(set(_n(10))(_n(100))(_na([0, 1, 2, 3])))).toThrow(); expect(() => $na(set._(_n(10))._(_n(100))._(_na([0, 1, 2, 3])))).toThrow();
}); });
it('[0, 1, 2, 3][0] = 10 is [10, 1, 2, 3]', () => { it('[0, 1, 2, 3][0] = 10 is [10, 1, 2, 3]', () => {
expect($na(set(_n(10))(_n(0))(_na([0, 1, 2, 3])))).toEqual([10, 1, 2, 3]); expect($na(set._(_n(10))._(_n(0))._(_na([0, 1, 2, 3])))).toEqual([10, 1, 2, 3]);
}); });
it('[0, 1, 2, 3][1] = 10 is [0, 10, 2, 3]', () => { it('[0, 1, 2, 3][1] = 10 is [0, 10, 2, 3]', () => {
expect($na(set(_n(10))(_n(1))(_na([0, 1, 2, 3])))).toEqual([0, 10, 2, 3]); expect($na(set._(_n(10))._(_n(1))._(_na([0, 1, 2, 3])))).toEqual([0, 10, 2, 3]);
}); });
it('[0, 1, 2, 3][2] = 10 is [0, 1, 10, 3]', () => { it('[0, 1, 2, 3][2] = 10 is [0, 1, 10, 3]', () => {
expect($na(set(_n(10))(_n(2))(_na([0, 1, 2, 3])))).toEqual([0, 1, 10, 3]); expect($na(set._(_n(10))._(_n(2))._(_na([0, 1, 2, 3])))).toEqual([0, 1, 10, 3]);
}); });
it('[0, 1, 2, 3][3] = 10 is [0, 1, 2, 10]', () => { it('[0, 1, 2, 3][3] = 10 is [0, 1, 2, 10]', () => {
expect($na(set(_n(10))(_n(3))(_na([0, 1, 2, 3])))).toEqual([0, 1, 2, 10]); expect($na(set._(_n(10))._(_n(3))._(_na([0, 1, 2, 3])))).toEqual([0, 1, 2, 10]);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($n(get(_n(4))(set(_n(10))(_n(4))(infinite)))).toBe(10); expect($n(get._(_n(4))._(set._(_n(10))._(_n(4))._(infinite)))).toBe(10);
}); });
}); });
describe('update', () => { describe('update', () => {
it('can not update Nil', () => { it('can not update Nil', () => {
expect(() => $na(update(succ)(_n(0))(Nil))).toThrow(); expect(() => $na(update._(succ)._(_n(0))._(Nil))).toThrow();
}); });
it('can not update out of bounds index', () => { it('can not update out of bounds index', () => {
expect(() => $na(update(succ)(_n(100))(_na([0, 1, 2, 3])))).toThrow(); expect(() => $na(update._(succ)._(_n(100))._(_na([0, 1, 2, 3])))).toThrow();
}); });
it('[0, 1, 2, 3][0]++ is [10, 1, 2, 3]', () => { it('[0, 1, 2, 3][0]++ is [10, 1, 2, 3]', () => {
expect($na(update(succ)(_n(0))(_na([0, 1, 2, 3])))).toEqual([1, 1, 2, 3]); expect($na(update._(succ)._(_n(0))._(_na([0, 1, 2, 3])))).toEqual([1, 1, 2, 3]);
}); });
it('[0, 1, 2, 3][1]++ is [0, 10, 2, 3]', () => { it('[0, 1, 2, 3][1]++ is [0, 10, 2, 3]', () => {
expect($na(update(succ)(_n(1))(_na([0, 1, 2, 3])))).toEqual([0, 2, 2, 3]); expect($na(update._(succ)._(_n(1))._(_na([0, 1, 2, 3])))).toEqual([0, 2, 2, 3]);
}); });
it('[0, 1, 2, 3][2]++ is [0, 1, 10, 3]', () => { it('[0, 1, 2, 3][2]++ is [0, 1, 10, 3]', () => {
expect($na(update(succ)(_n(2))(_na([0, 1, 2, 3])))).toEqual([0, 1, 3, 3]); expect($na(update._(succ)._(_n(2))._(_na([0, 1, 2, 3])))).toEqual([0, 1, 3, 3]);
}); });
it('[0, 1, 2, 3][3]++ is [0, 1, 2, 10]', () => { it('[0, 1, 2, 3][3]++ is [0, 1, 2, 10]', () => {
expect($na(update(succ)(_n(3))(_na([0, 1, 2, 3])))).toEqual([0, 1, 2, 4]); expect($na(update._(succ)._(_n(3))._(_na([0, 1, 2, 3])))).toEqual([0, 1, 2, 4]);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($n(get(_n(4))(update(succ)(_n(4))(infinite)))).toBe(5); expect($n(get._(_n(4))._(update._(succ)._(_n(4))._(infinite)))).toBe(5);
}); });
}); });
describe('intersperse', () => { describe('intersperse', () => {
it('0 intersperse Nil is Nil', () => { it('0 intersperse Nil is Nil', () => {
expect($na(intersperse(_n(0))(Nil))).toEqual([]); expect($na(intersperse._(_n(0))._(Nil))).toEqual([]);
}); });
it('0 intersperse [1] is [1]', () => { it('0 intersperse [1] is [1]', () => {
expect($na(intersperse(_n(0))(_na([1])))).toEqual([1]); expect($na(intersperse._(_n(0))._(_na([1])))).toEqual([1]);
}); });
it('0 intersperse [1, 2, 3] is [1, 0, 2, 0, 3]', () => { it('0 intersperse [1, 2, 3] is [1, 0, 2, 0, 3]', () => {
expect($na(intersperse(_n(0))(_na([1, 2, 3])))).toEqual([1, 0, 2, 0, 3]); expect($na(intersperse._(_n(0))._(_na([1, 2, 3])))).toEqual([1, 0, 2, 0, 3]);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($n(head(intersperse(_n(0))(infinite)))).toBe(0); expect($n(head._(intersperse._(_n(0))._(infinite)))).toBe(0);
}); });
}); });
describe('show', () => { describe('show', () => {
it('show Nil is "[]"', () => { it('show Nil is "[]"', () => {
expect($s(show(nshow)(_na([])))).toBe('[]'); expect($s(show._(nshow)._(_na([])))).toBe('[]');
}); });
it('show [0] is "[0]"', () => { it('show [0] is "[0]"', () => {
expect($s(show(nshow)(_na([0])))).toBe('[0]'); expect($s(show._(nshow)._(_na([0])))).toBe('[0]');
}); });
it('show [0, 1, 2] is "[0, 1, 2]"', () => { it('show [0, 1, 2] is "[0, 1, 2]"', () => {
expect($s(show(nshow)(_na([0, 1, 2])))).toBe('[0, 1, 2]'); expect($s(show._(nshow)._(_na([0, 1, 2])))).toBe('[0, 1, 2]');
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($c(head(show(nshow)(infinite)))).toBe('['); expect($c(head._(show._(nshow)._(infinite)))).toBe('[');
}); });
}); });
}); });

191
test/num.spec.ts
Unescape View File

@ -1,12 +1,15 @@
import { describe, expect, it } from '@jest/globals'; import { describe, expect, it } from '@jest/globals';
import { undef, y } from '../src/core'; import { Term, d, g, m, undef } 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, Succ, Zero, fromNumber as _n, cmp, div, eq, ge, gt, ifz, le, lt, mod, mul, pred, sub, succ, sum } from '../src/num';
import { toString as $s } from '../src/string'; import { toString as $s } from '../src/string';
import { show } from '../src/num.show';
m('num.spec');
describe('Num', () => { describe('Num', () => {
const infinity: Num = y(() => Succ(infinity)); const infinity: Term = g('infinity', d(bs => Succ._(bs['num.spec::infinity'])));
describe('toNumber', () => { describe('toNumber', () => {
it('converts 0', () => { it('converts 0', () => {
@ -14,11 +17,11 @@ describe('Num', () => {
}); });
it('converts 1', () => { it('converts 1', () => {
expect($n(Succ(Zero))).toBe(1); expect($n(Succ._(Zero))).toBe(1);
}); });
it('converts 2', () => { it('converts 2', () => {
expect($n(Succ(Succ(Zero)))).toBe(2); expect($n(Succ._(Succ._(Zero)))).toBe(2);
}); });
}); });
@ -38,369 +41,369 @@ describe('Num', () => {
describe('ifz', () => { describe('ifz', () => {
it('returns zero branch', () => { it('returns zero branch', () => {
expect($b(ifz(_n(0))(_b(true))(_b(false)))).toBe(true); expect($b(ifz._(_n(0))._(_b(true))._(_b(false)))).toBe(true);
}); });
it('returns non-zero branch', () => { it('returns non-zero branch', () => {
expect($b(ifz(_n(1))(_b(true))(_b(false)))).toBe(false); expect($b(ifz._(_n(1))._(_b(true))._(_b(false)))).toBe(false);
}); });
it('returns non-zero branch', () => { it('returns non-zero branch', () => {
expect($b(ifz(_n(10))(_b(true))(_b(false)))).toBe(false); expect($b(ifz._(_n(10))._(_b(true))._(_b(false)))).toBe(false);
}); });
it('handles infinity', () => { it('handles infinity', () => {
expect($b(ifz(infinity)(_b(true))(_b(false)))).toBe(false); expect($b(ifz._(infinity)._(_b(true))._(_b(false)))).toBe(false);
}); });
}); });
describe('succ', () => { describe('succ', () => {
it('succ 0 is 1', () => { it('succ 0 is 1', () => {
expect($n(succ(_n(0)))).toBe(1); expect($n(succ._(_n(0)))).toBe(1);
}); });
it('succ 1 is 2', () => { it('succ 1 is 2', () => {
expect($n(succ(_n(1)))).toBe(2); expect($n(succ._(_n(1)))).toBe(2);
}); });
it('succ 10 is 11', () => { it('succ 10 is 11', () => {
expect($n(succ(_n(10)))).toBe(11); expect($n(succ._(_n(10)))).toBe(11);
}); });
}); });
describe('pred', () => { describe('pred', () => {
it('pred 0 is 0', () => { it('pred 0 is 0', () => {
expect($n(pred(_n(0)))).toBe(0); expect($n(pred._(_n(0)))).toBe(0);
}); });
it('pred 1 is 0', () => { it('pred 1 is 0', () => {
expect($n(pred(_n(1)))).toBe(0); expect($n(pred._(_n(1)))).toBe(0);
}); });
it('pred 10 is 9', () => { it('pred 10 is 9', () => {
expect($n(pred(_n(10)))).toBe(9); expect($n(pred._(_n(10)))).toBe(9);
}); });
}); });
describe('cmp', () => { describe('cmp', () => {
it('0 cmp 0 is EQ', () => { it('0 cmp 0 is EQ', () => {
expect($o(cmp(_n(0))(_n(0)))).toBe(NOrd.EQ); expect($o(cmp._(_n(0))._(_n(0)))).toBe(NOrd.EQ);
}); });
it('0 cmp 1 is LT', () => { it('0 cmp 1 is LT', () => {
expect($o(cmp(_n(0))(_n(1)))).toBe(NOrd.LT); expect($o(cmp._(_n(0))._(_n(1)))).toBe(NOrd.LT);
}); });
it('1 cmp 0 is GT', () => { it('1 cmp 0 is GT', () => {
expect($o(cmp(_n(1))(_n(0)))).toBe(NOrd.GT); expect($o(cmp._(_n(1))._(_n(0)))).toBe(NOrd.GT);
}); });
it('3 cmp 3 is EQ', () => { it('3 cmp 3 is EQ', () => {
expect($o(cmp(_n(3))(_n(3)))).toBe(NOrd.EQ); expect($o(cmp._(_n(3))._(_n(3)))).toBe(NOrd.EQ);
}); });
it('3 cmp 7 is LT', () => { it('3 cmp 7 is LT', () => {
expect($o(cmp(_n(3))(_n(7)))).toBe(NOrd.LT); expect($o(cmp._(_n(3))._(_n(7)))).toBe(NOrd.LT);
}); });
it('7 cmp 3 is GT', () => { it('7 cmp 3 is GT', () => {
expect($o(cmp(_n(7))(_n(3)))).toBe(NOrd.GT); expect($o(cmp._(_n(7))._(_n(3)))).toBe(NOrd.GT);
}); });
it('handles infinity', () => { it('handles infinity', () => {
expect($o(cmp(_n(7))(infinity))).toBe(NOrd.LT); expect($o(cmp._(_n(7))._(infinity))).toBe(NOrd.LT);
expect($o(cmp(infinity)(_n(7)))).toBe(NOrd.GT); expect($o(cmp._(infinity)._(_n(7)))).toBe(NOrd.GT);
}); });
}); });
describe('lt', () => { describe('lt', () => {
it('0 lt 0 is False', () => { it('0 lt 0 is False', () => {
expect($b(lt(_n(0))(_n(0)))).toBe(false); expect($b(lt._(_n(0))._(_n(0)))).toBe(false);
}); });
it('0 lt 1 is True', () => { it('0 lt 1 is True', () => {
expect($b(lt(_n(0))(_n(1)))).toBe(true); expect($b(lt._(_n(0))._(_n(1)))).toBe(true);
}); });
it('1 lt 0 is False', () => { it('1 lt 0 is False', () => {
expect($b(lt(_n(1))(_n(0)))).toBe(false); expect($b(lt._(_n(1))._(_n(0)))).toBe(false);
}); });
it('3 lt 3 is False', () => { it('3 lt 3 is False', () => {
expect($b(lt(_n(3))(_n(3)))).toBe(false); expect($b(lt._(_n(3))._(_n(3)))).toBe(false);
}); });
it('3 lt 7 is True', () => { it('3 lt 7 is True', () => {
expect($b(lt(_n(3))(_n(7)))).toBe(true); expect($b(lt._(_n(3))._(_n(7)))).toBe(true);
}); });
it('7 lt 3 is False', () => { it('7 lt 3 is False', () => {
expect($b(lt(_n(7))(_n(3)))).toBe(false); expect($b(lt._(_n(7))._(_n(3)))).toBe(false);
}); });
it('handles infinity', () => { it('handles infinity', () => {
expect($b(lt(_n(7))(infinity))).toBe(true); expect($b(lt._(_n(7))._(infinity))).toBe(true);
expect($b(lt(infinity)(_n(7)))).toBe(false); expect($b(lt._(infinity)._(_n(7)))).toBe(false);
}); });
}); });
describe('le', () => { describe('le', () => {
it('0 le 0 is True', () => { it('0 le 0 is True', () => {
expect($b(le(_n(0))(_n(0)))).toBe(true); expect($b(le._(_n(0))._(_n(0)))).toBe(true);
}); });
it('0 le 1 is True', () => { it('0 le 1 is True', () => {
expect($b(le(_n(0))(_n(1)))).toBe(true); expect($b(le._(_n(0))._(_n(1)))).toBe(true);
}); });
it('1 le 0 is False', () => { it('1 le 0 is False', () => {
expect($b(le(_n(1))(_n(0)))).toBe(false); expect($b(le._(_n(1))._(_n(0)))).toBe(false);
}); });
it('3 le 3 is True', () => { it('3 le 3 is True', () => {
expect($b(le(_n(3))(_n(3)))).toBe(true); expect($b(le._(_n(3))._(_n(3)))).toBe(true);
}); });
it('3 le 7 is True', () => { it('3 le 7 is True', () => {
expect($b(le(_n(3))(_n(7)))).toBe(true); expect($b(le._(_n(3))._(_n(7)))).toBe(true);
}); });
it('7 le 3 is False', () => { it('7 le 3 is False', () => {
expect($b(le(_n(7))(_n(3)))).toBe(false); expect($b(le._(_n(7))._(_n(3)))).toBe(false);
}); });
it('handles infinity', () => { it('handles infinity', () => {
expect($b(le(_n(7))(infinity))).toBe(true); expect($b(le._(_n(7))._(infinity))).toBe(true);
expect($b(le(infinity)(_n(7)))).toBe(false); expect($b(le._(infinity)._(_n(7)))).toBe(false);
}); });
}); });
describe('eq', () => { describe('eq', () => {
it('0 eq 0 is True', () => { it('0 eq 0 is True', () => {
expect($b(eq(_n(0))(_n(0)))).toBe(true); expect($b(eq._(_n(0))._(_n(0)))).toBe(true);
}); });
it('0 eq 1 is False', () => { it('0 eq 1 is False', () => {
expect($b(eq(_n(0))(_n(1)))).toBe(false); expect($b(eq._(_n(0))._(_n(1)))).toBe(false);
}); });
it('1 eq 0 is False', () => { it('1 eq 0 is False', () => {
expect($b(eq(_n(1))(_n(0)))).toBe(false); expect($b(eq._(_n(1))._(_n(0)))).toBe(false);
}); });
it('3 eq 3 is True', () => { it('3 eq 3 is True', () => {
expect($b(eq(_n(3))(_n(3)))).toBe(true); expect($b(eq._(_n(3))._(_n(3)))).toBe(true);
}); });
it('3 eq 7 is False', () => { it('3 eq 7 is False', () => {
expect($b(eq(_n(3))(_n(7)))).toBe(false); expect($b(eq._(_n(3))._(_n(7)))).toBe(false);
}); });
it('7 eq 3 is False', () => { it('7 eq 3 is False', () => {
expect($b(eq(_n(7))(_n(3)))).toBe(false); expect($b(eq._(_n(7))._(_n(3)))).toBe(false);
}); });
it('handles infinity', () => { it('handles infinity', () => {
expect($b(eq(_n(7))(infinity))).toBe(false); expect($b(eq._(_n(7))._(infinity))).toBe(false);
expect($b(eq(infinity)(_n(7)))).toBe(false); expect($b(eq._(infinity)._(_n(7)))).toBe(false);
}); });
}); });
describe('ge', () => { describe('ge', () => {
it('0 ge 0 is True', () => { it('0 ge 0 is True', () => {
expect($b(ge(_n(0))(_n(0)))).toBe(true); expect($b(ge._(_n(0))._(_n(0)))).toBe(true);
}); });
it('0 ge 1 is False', () => { it('0 ge 1 is False', () => {
expect($b(ge(_n(0))(_n(1)))).toBe(false); expect($b(ge._(_n(0))._(_n(1)))).toBe(false);
}); });
it('1 ge 0 is True', () => { it('1 ge 0 is True', () => {
expect($b(ge(_n(1))(_n(0)))).toBe(true); expect($b(ge._(_n(1))._(_n(0)))).toBe(true);
}); });
it('3 ge 3 is True', () => { it('3 ge 3 is True', () => {
expect($b(ge(_n(3))(_n(3)))).toBe(true); expect($b(ge._(_n(3))._(_n(3)))).toBe(true);
}); });
it('3 ge 7 is False', () => { it('3 ge 7 is False', () => {
expect($b(ge(_n(3))(_n(7)))).toBe(false); expect($b(ge._(_n(3))._(_n(7)))).toBe(false);
}); });
it('7 ge 3 is True', () => { it('7 ge 3 is True', () => {
expect($b(ge(_n(7))(_n(3)))).toBe(true); expect($b(ge._(_n(7))._(_n(3)))).toBe(true);
}); });
it('handles infinity', () => { it('handles infinity', () => {
expect($b(ge(_n(7))(infinity))).toBe(false); expect($b(ge._(_n(7))._(infinity))).toBe(false);
expect($b(ge(infinity)(_n(7)))).toBe(true); expect($b(ge._(infinity)._(_n(7)))).toBe(true);
}); });
}); });
describe('gt', () => { describe('gt', () => {
it('0 gt 0 is False', () => { it('0 gt 0 is False', () => {
expect($b(gt(_n(0))(_n(0)))).toBe(false); expect($b(gt._(_n(0))._(_n(0)))).toBe(false);
}); });
it('0 gt 1 is False', () => { it('0 gt 1 is False', () => {
expect($b(gt(_n(0))(_n(1)))).toBe(false); expect($b(gt._(_n(0))._(_n(1)))).toBe(false);
}); });
it('1 gt 0 is True', () => { it('1 gt 0 is True', () => {
expect($b(gt(_n(1))(_n(0)))).toBe(true); expect($b(gt._(_n(1))._(_n(0)))).toBe(true);
}); });
it('3 gt 3 is False', () => { it('3 gt 3 is False', () => {
expect($b(gt(_n(3))(_n(3)))).toBe(false); expect($b(gt._(_n(3))._(_n(3)))).toBe(false);
}); });
it('3 gt 7 is False', () => { it('3 gt 7 is False', () => {
expect($b(gt(_n(3))(_n(7)))).toBe(false); expect($b(gt._(_n(3))._(_n(7)))).toBe(false);
}); });
it('7 gt 3 is True', () => { it('7 gt 3 is True', () => {
expect($b(gt(_n(7))(_n(3)))).toBe(true); expect($b(gt._(_n(7))._(_n(3)))).toBe(true);
}); });
it('handles infinity', () => { it('handles infinity', () => {
expect($b(gt(_n(7))(infinity))).toBe(false); expect($b(gt._(_n(7))._(infinity))).toBe(false);
expect($b(gt(infinity)(_n(7)))).toBe(true); expect($b(gt._(infinity)._(_n(7)))).toBe(true);
}); });
}); });
describe('sum', () => { describe('sum', () => {
it('0 sum 0 is 0', () => { it('0 sum 0 is 0', () => {
expect($n(sum(_n(0))(_n(0)))).toBe(0); expect($n(sum._(_n(0))._(_n(0)))).toBe(0);
}); });
it('0 sum 1 is 1', () => { it('0 sum 1 is 1', () => {
expect($n(sum(_n(0))(_n(1)))).toBe(1); expect($n(sum._(_n(0))._(_n(1)))).toBe(1);
}); });
it('1 sum 0 is 1', () => { it('1 sum 0 is 1', () => {
expect($n(sum(_n(1))(_n(0)))).toBe(1); expect($n(sum._(_n(1))._(_n(0)))).toBe(1);
}); });
it('3 sum 4 is 7', () => { it('3 sum 4 is 7', () => {
expect($n(sum(_n(3))(_n(4)))).toBe(7); expect($n(sum._(_n(3))._(_n(4)))).toBe(7);
}); });
}); });
describe('sub', () => { describe('sub', () => {
it('0 sub 0 is 0', () => { it('0 sub 0 is 0', () => {
expect($n(sub(_n(0))(_n(0)))).toBe(0); expect($n(sub._(_n(0))._(_n(0)))).toBe(0);
}); });
it('0 sub 1 is 0', () => { it('0 sub 1 is 0', () => {
expect($n(sub(_n(0))(_n(1)))).toBe(0); expect($n(sub._(_n(0))._(_n(1)))).toBe(0);
}); });
it('1 sub 0 is 1', () => { it('1 sub 0 is 1', () => {
expect($n(sub(_n(1))(_n(0)))).toBe(1); expect($n(sub._(_n(1))._(_n(0)))).toBe(1);
}); });
it('7 sub 4 is 3', () => { it('7 sub 4 is 3', () => {
expect($n(sub(_n(7))(_n(4)))).toBe(3); expect($n(sub._(_n(7))._(_n(4)))).toBe(3);
}); });
}); });
describe('mul', () => { describe('mul', () => {
it('0 mul 0 is 0', () => { it('0 mul 0 is 0', () => {
expect($n(mul(_n(0))(_n(0)))).toBe(0); expect($n(mul._(_n(0))._(_n(0)))).toBe(0);
}); });
it('0 mul 10 is 0', () => { it('0 mul 10 is 0', () => {
expect($n(mul(_n(0))(_n(10)))).toBe(0); expect($n(mul._(_n(0))._(_n(10)))).toBe(0);
}); });
it('10 mul 0 is 0', () => { it('10 mul 0 is 0', () => {
expect($n(mul(_n(1))(_n(0)))).toBe(0); expect($n(mul._(_n(1))._(_n(0)))).toBe(0);
}); });
it('1 mul 10 is 10', () => { it('1 mul 10 is 10', () => {
expect($n(mul(_n(1))(_n(10)))).toBe(10); expect($n(mul._(_n(1))._(_n(10)))).toBe(10);
}); });
it('10 mul 1 is 10', () => { it('10 mul 1 is 10', () => {
expect($n(mul(_n(10))(_n(1)))).toBe(10); expect($n(mul._(_n(10))._(_n(1)))).toBe(10);
}); });
it('3 mul 4 is 12', () => { it('3 mul 4 is 12', () => {
expect($n(mul(_n(3))(_n(4)))).toBe(12); expect($n(mul._(_n(3))._(_n(4)))).toBe(12);
}); });
it('0 mul ignores second argument', () => { it('0 mul ignores second argument', () => {
expect($n(mul(_n(0))(undef))).toBe(0); expect($n(mul._(_n(0))._(undef))).toBe(0);
}); });
}); });
describe('div', () => { describe('div', () => {
it('0 div 10 is 0', () => { it('0 div 10 is 0', () => {
expect($n(div(_n(0))(_n(10)))).toBe(0); expect($n(div._(_n(0))._(_n(10)))).toBe(0);
}); });
it('1 div 10 is 0', () => { it('1 div 10 is 0', () => {
expect($n(div(_n(1))(_n(10)))).toBe(0); expect($n(div._(_n(1))._(_n(10)))).toBe(0);
}); });
it('10 div 1 is 10', () => { it('10 div 1 is 10', () => {
expect($n(div(_n(10))(_n(1)))).toBe(10); expect($n(div._(_n(10))._(_n(1)))).toBe(10);
}); });
it('10 div 5 is 2', () => { it('10 div 5 is 2', () => {
expect($n(div(_n(10))(_n(5)))).toBe(2); expect($n(div._(_n(10))._(_n(5)))).toBe(2);
}); });
it('10 div 3 is 3', () => { it('10 div 3 is 3', () => {
expect($n(div(_n(10))(_n(3)))).toBe(3); expect($n(div._(_n(10))._(_n(3)))).toBe(3);
}); });
it.failing('0 div ignores second argument', () => { it.failing('0 div ignores second argument', () => {
expect($n(div(_n(0))(undef))).toBe(0); expect($n(div._(_n(0))._(undef))).toBe(0);
}); });
}); });
describe('mod', () => { describe('mod', () => {
it('0 mod 10 is 0', () => { it('0 mod 10 is 0', () => {
expect($n(mod(_n(0))(_n(10)))).toBe(0); expect($n(mod._(_n(0))._(_n(10)))).toBe(0);
}); });
it('1 mod 10 is 1', () => { it('1 mod 10 is 1', () => {
expect($n(mod(_n(1))(_n(10)))).toBe(1); expect($n(mod._(_n(1))._(_n(10)))).toBe(1);
}); });
it('10 mod 1 is 0', () => { it('10 mod 1 is 0', () => {
expect($n(mod(_n(10))(_n(1)))).toBe(0); expect($n(mod._(_n(10))._(_n(1)))).toBe(0);
}); });
it('10 mod 5 is 0', () => { it('10 mod 5 is 0', () => {
expect($n(mod(_n(10))(_n(5)))).toBe(0); expect($n(mod._(_n(10))._(_n(5)))).toBe(0);
}); });
it('10 mod 3 is 1', () => { it('10 mod 3 is 1', () => {
expect($n(mod(_n(10))(_n(3)))).toBe(1); expect($n(mod._(_n(10))._(_n(3)))).toBe(1);
}); });
it.failing('0 mod ignores second argument', () => { it.failing('0 mod ignores second argument', () => {
expect($n(mod(_n(0))(undef))).toBe(0); expect($n(mod._(_n(0))._(undef))).toBe(0);
}); });
}); });
describe('show', () => { describe('show', () => {
it('show 0 is "0"', () => { it('show 0 is "0"', () => {
expect($s(show(_n(0)))).toBe('0'); expect($s(show._(_n(0)))).toBe('0');
}); });
it('show 1 is "1"', () => { it('show 1 is "1"', () => {
expect($s(show(_n(1)))).toBe('1'); expect($s(show._(_n(1)))).toBe('1');
}); });
it('show 255 is "255"', () => { it('show 255 is "255"', () => {
expect($s(show(_n(255)))).toBe('255'); expect($s(show._(_n(255)))).toBe('255');
}); });
it('show 1000 is "1000"', () => { it('show 1000 is "1000"', () => {
expect($s(show(_n(1000)))).toBe('1000'); expect($s(show._(_n(1000)))).toBe('1000');
}); });
}); });
}); });

111
test/pair.spec.ts
Unescape View File

@ -1,230 +1,233 @@
import { describe, expect, it } from '@jest/globals'; import { describe, expect, it } from '@jest/globals';
import { undef } from '../src/core'; import { undef } 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, cmp as bcmp, eq as beq, show as bshow, not } from '../src/bool'; import { toBoolean as $b, fromBoolean as _b, cmp as bcmp, eq as beq, not } from '../src/bool';
import { toNumber as $n, fromNumber as _n, cmp as ncmp, eq as neq, show as nshow, succ } from '../src/num'; import { toNumber as $n, fromNumber as _n, cmp as ncmp, eq as neq, succ } from '../src/num';
import { Pair, both, cmp, eq, first, fst, ge, gt, le, lt, second, show, snd } from '../src/pair'; import { Pair, both, cmp, eq, first, fst, ge, gt, le, lt, second, snd } from '../src/pair';
import { toString as $s } from '../src/string'; import { toString } from '../src/string';
import { show as bshow } from '../src/bool.show';
import { show as nshow } from '../src/num.show';
import { show } from '../src/pair.show';
describe('Pair', () => { describe('Pair', () => {
describe('fst', () => { describe('fst', () => {
it('returns first', () => { it('returns first', () => {
expect($b(fst(Pair(_b(false))(_n(0))))).toBe(false); expect($b(fst._(Pair._(_b(false))._(_n(0))))).toBe(false);
}); });
it('ignores second', () => { it('ignores second', () => {
expect($b(fst(Pair(_b(false))(undef)))).toBe(false); expect($b(fst._(Pair._(_b(false))._(undef)))).toBe(false);
}); });
}); });
describe('snd', () => { describe('snd', () => {
it('returns second', () => { it('returns second', () => {
expect($n(snd(Pair(_b(false))(_n(0))))).toBe(0); expect($n(snd._(Pair._(_b(false))._(_n(0))))).toBe(0);
}); });
it('ignores first', () => { it('ignores first', () => {
expect($n(snd(Pair(undef)(_n(0))))).toBe(0); expect($n(snd._(Pair._(undef)._(_n(0))))).toBe(0);
}); });
}); });
describe('first', () => { describe('first', () => {
it('updates first', () => { it('updates first', () => {
expect($b(fst(first(not)(Pair(_b(false))(_n(0)))))).toBe(true); expect($b(fst._(first._(not)._(Pair._(_b(false))._(_n(0)))))).toBe(true);
}); });
it('ignores second', () => { it('ignores second', () => {
expect($b(fst(first(not)(Pair(_b(false))(undef))))).toBe(true); expect($b(fst._(first._(not)._(Pair._(_b(false))._(undef))))).toBe(true);
}); });
}); });
describe('second', () => { describe('second', () => {
it('updates second', () => { it('updates second', () => {
expect($n(snd(second(succ)(Pair(_b(false))(_n(0)))))).toBe(1); expect($n(snd._(second._(succ)._(Pair._(_b(false))._(_n(0)))))).toBe(1);
}); });
it('ignores first', () => { it('ignores first', () => {
expect($n(snd(second(succ)(Pair(undef)(_n(0)))))).toBe(1); expect($n(snd._(second._(succ)._(Pair._(undef)._(_n(0)))))).toBe(1);
}); });
}); });
describe('both', () => { describe('both', () => {
it('updates both', () => { it('updates both', () => {
expect($b(fst(both(not)(succ)(Pair(_b(false))(_n(0)))))).toBe(true); expect($b(fst._(both._(not)._(succ)._(Pair._(_b(false))._(_n(0)))))).toBe(true);
expect($n(snd(both(not)(succ)(Pair(_b(false))(_n(0)))))).toBe(1); expect($n(snd._(both._(not)._(succ)._(Pair._(_b(false))._(_n(0)))))).toBe(1);
}); });
}); });
describe('cmp', () => { describe('cmp', () => {
it('(False, 0) cmp (False, 0) is EQ', () => { it('(False, 0) cmp (False, 0) is EQ', () => {
expect($o(cmp(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(false))(_n(0))))).toBe(NOrd.EQ); expect($o(cmp._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(false))._(_n(0))))).toBe(NOrd.EQ);
}); });
it('(False, 0) cmp (False, 1) is LT', () => { it('(False, 0) cmp (False, 1) is LT', () => {
expect($o(cmp(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(false))(_n(1))))).toBe(NOrd.LT); expect($o(cmp._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(false))._(_n(1))))).toBe(NOrd.LT);
}); });
it('(False, 1) cmp (False, 0) is GT', () => { it('(False, 1) cmp (False, 0) is GT', () => {
expect($o(cmp(bcmp)(ncmp)(Pair(_b(false))(_n(1)))(Pair(_b(false))(_n(0))))).toBe(NOrd.GT); expect($o(cmp._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(1)))._(Pair._(_b(false))._(_n(0))))).toBe(NOrd.GT);
}); });
it('(False, 0) cmp (True, 0) is LT', () => { it('(False, 0) cmp (True, 0) is LT', () => {
expect($o(cmp(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(true))(_n(0))))).toBe(NOrd.LT); expect($o(cmp._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(true))._(_n(0))))).toBe(NOrd.LT);
}); });
it('(True, 0) cmp (False, 0) is GT', () => { it('(True, 0) cmp (False, 0) is GT', () => {
expect($o(cmp(bcmp)(ncmp)(Pair(_b(true))(_n(0)))(Pair(_b(false))(_n(0))))).toBe(NOrd.GT); expect($o(cmp._(bcmp)._(ncmp)._(Pair._(_b(true))._(_n(0)))._(Pair._(_b(false))._(_n(0))))).toBe(NOrd.GT);
}); });
it('ignores second if first not equal', () => { it('ignores second if first not equal', () => {
expect($o(cmp(bcmp)(undef)(Pair(_b(false))(undef))(Pair(_b(true))(undef)))).toBe(NOrd.LT); expect($o(cmp._(bcmp)._(undef)._(Pair._(_b(false))._(undef))._(Pair._(_b(true))._(undef)))).toBe(NOrd.LT);
}); });
}); });
describe('lt', () => { describe('lt', () => {
it('(False, 0) lt (False, 0) is False', () => { it('(False, 0) lt (False, 0) is False', () => {
expect($b(lt(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(false))(_n(0))))).toBe(false); expect($b(lt._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(false))._(_n(0))))).toBe(false);
}); });
it('(False, 0) lt (False, 1) is True', () => { it('(False, 0) lt (False, 1) is True', () => {
expect($b(lt(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(false))(_n(1))))).toBe(true); expect($b(lt._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(false))._(_n(1))))).toBe(true);
}); });
it('(False, 1) lt (False, 0) is False', () => { it('(False, 1) lt (False, 0) is False', () => {
expect($b(lt(bcmp)(ncmp)(Pair(_b(false))(_n(1)))(Pair(_b(false))(_n(0))))).toBe(false); expect($b(lt._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(1)))._(Pair._(_b(false))._(_n(0))))).toBe(false);
}); });
it('(False, 0) lt (True, 0) is True', () => { it('(False, 0) lt (True, 0) is True', () => {
expect($b(lt(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(true))(_n(0))))).toBe(true); expect($b(lt._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(true))._(_n(0))))).toBe(true);
}); });
it('(True, 0) lt (False, 0) is False', () => { it('(True, 0) lt (False, 0) is False', () => {
expect($b(lt(bcmp)(ncmp)(Pair(_b(true))(_n(0)))(Pair(_b(false))(_n(0))))).toBe(false); expect($b(lt._(bcmp)._(ncmp)._(Pair._(_b(true))._(_n(0)))._(Pair._(_b(false))._(_n(0))))).toBe(false);
}); });
it('ignores second if first not equal', () => { it('ignores second if first not equal', () => {
expect($b(lt(bcmp)(undef)(Pair(_b(false))(undef))(Pair(_b(true))(undef)))).toBe(true); expect($b(lt._(bcmp)._(undef)._(Pair._(_b(false))._(undef))._(Pair._(_b(true))._(undef)))).toBe(true);
}); });
}); });
describe('le', () => { describe('le', () => {
it('(False, 0) le (False, 0) is True', () => { it('(False, 0) le (False, 0) is True', () => {
expect($b(le(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(false))(_n(0))))).toBe(true); expect($b(le._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(false))._(_n(0))))).toBe(true);
}); });
it('(False, 0) le (False, 1) is True', () => { it('(False, 0) le (False, 1) is True', () => {
expect($b(le(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(false))(_n(1))))).toBe(true); expect($b(le._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(false))._(_n(1))))).toBe(true);
}); });
it('(False, 1) le (False, 0) is False', () => { it('(False, 1) le (False, 0) is False', () => {
expect($b(le(bcmp)(ncmp)(Pair(_b(false))(_n(1)))(Pair(_b(false))(_n(0))))).toBe(false); expect($b(le._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(1)))._(Pair._(_b(false))._(_n(0))))).toBe(false);
}); });
it('(False, 0) le (True, 0) is True', () => { it('(False, 0) le (True, 0) is True', () => {
expect($b(le(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(true))(_n(0))))).toBe(true); expect($b(le._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(true))._(_n(0))))).toBe(true);
}); });
it('(True, 0) le (False, 0) is False', () => { it('(True, 0) le (False, 0) is False', () => {
expect($b(le(bcmp)(ncmp)(Pair(_b(true))(_n(0)))(Pair(_b(false))(_n(0))))).toBe(false); expect($b(le._(bcmp)._(ncmp)._(Pair._(_b(true))._(_n(0)))._(Pair._(_b(false))._(_n(0))))).toBe(false);
}); });
it('ignores second if first not equal', () => { it('ignores second if first not equal', () => {
expect($b(le(bcmp)(undef)(Pair(_b(false))(undef))(Pair(_b(true))(undef)))).toBe(true); expect($b(le._(bcmp)._(undef)._(Pair._(_b(false))._(undef))._(Pair._(_b(true))._(undef)))).toBe(true);
}); });
}); });
describe('eq', () => { describe('eq', () => {
it('(False, 0) eq (False, 0) is True', () => { it('(False, 0) eq (False, 0) is True', () => {
expect($b(eq(beq)(neq)(Pair(_b(false))(_n(0)))(Pair(_b(false))(_n(0))))).toBe(true); expect($b(eq._(beq)._(neq)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(false))._(_n(0))))).toBe(true);
}); });
it('(False, 0) eq (False, 1) is False', () => { it('(False, 0) eq (False, 1) is False', () => {
expect($b(eq(beq)(neq)(Pair(_b(false))(_n(0)))(Pair(_b(false))(_n(1))))).toBe(false); expect($b(eq._(beq)._(neq)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(false))._(_n(1))))).toBe(false);
}); });
it('(False, 1) eq (False, 0) is False', () => { it('(False, 1) eq (False, 0) is False', () => {
expect($b(eq(beq)(neq)(Pair(_b(false))(_n(1)))(Pair(_b(false))(_n(0))))).toBe(false); expect($b(eq._(beq)._(neq)._(Pair._(_b(false))._(_n(1)))._(Pair._(_b(false))._(_n(0))))).toBe(false);
}); });
it('(False, 0) eq (True, 0) is True', () => { it('(False, 0) eq (True, 0) is True', () => {
expect($b(eq(beq)(neq)(Pair(_b(false))(_n(0)))(Pair(_b(true))(_n(0))))).toBe(false); expect($b(eq._(beq)._(neq)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(true))._(_n(0))))).toBe(false);
}); });
it('(True, 0) eq (False, 0) is True', () => { it('(True, 0) eq (False, 0) is True', () => {
expect($b(eq(beq)(neq)(Pair(_b(true))(_n(0)))(Pair(_b(false))(_n(0))))).toBe(false); expect($b(eq._(beq)._(neq)._(Pair._(_b(true))._(_n(0)))._(Pair._(_b(false))._(_n(0))))).toBe(false);
}); });
it('ignores second if first not equal', () => { it('ignores second if first not equal', () => {
expect($b(eq(beq)(undef)(Pair(_b(false))(undef))(Pair(_b(true))(undef)))).toBe(false); expect($b(eq._(beq)._(undef)._(Pair._(_b(false))._(undef))._(Pair._(_b(true))._(undef)))).toBe(false);
}); });
}); });
describe('ge', () => { describe('ge', () => {
it('(False, 0) ge (False, 0) is True', () => { it('(False, 0) ge (False, 0) is True', () => {
expect($b(ge(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(false))(_n(0))))).toBe(true); expect($b(ge._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(false))._(_n(0))))).toBe(true);
}); });
it('(False, 0) ge (False, 1) is False', () => { it('(False, 0) ge (False, 1) is False', () => {
expect($b(ge(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(false))(_n(1))))).toBe(false); expect($b(ge._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(false))._(_n(1))))).toBe(false);
}); });
it('(False, 1) ge (False, 0) is True', () => { it('(False, 1) ge (False, 0) is True', () => {
expect($b(ge(bcmp)(ncmp)(Pair(_b(false))(_n(1)))(Pair(_b(false))(_n(0))))).toBe(true); expect($b(ge._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(1)))._(Pair._(_b(false))._(_n(0))))).toBe(true);
}); });
it('(False, 0) ge (True, 0) is False', () => { it('(False, 0) ge (True, 0) is False', () => {
expect($b(ge(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(true))(_n(0))))).toBe(false); expect($b(ge._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(true))._(_n(0))))).toBe(false);
}); });
it('(True, 0) ge (False, 0) is True', () => { it('(True, 0) ge (False, 0) is True', () => {
expect($b(ge(bcmp)(ncmp)(Pair(_b(true))(_n(0)))(Pair(_b(false))(_n(0))))).toBe(true); expect($b(ge._(bcmp)._(ncmp)._(Pair._(_b(true))._(_n(0)))._(Pair._(_b(false))._(_n(0))))).toBe(true);
}); });
it('ignores second if first not equal', () => { it('ignores second if first not equal', () => {
expect($b(ge(bcmp)(undef)(Pair(_b(false))(undef))(Pair(_b(true))(undef)))).toBe(false); expect($b(ge._(bcmp)._(undef)._(Pair._(_b(false))._(undef))._(Pair._(_b(true))._(undef)))).toBe(false);
}); });
}); });
describe('gt', () => { describe('gt', () => {
it('(False, 0) gt (False, 0) is False', () => { it('(False, 0) gt (False, 0) is False', () => {
expect($b(gt(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(false))(_n(0))))).toBe(false); expect($b(gt._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(false))._(_n(0))))).toBe(false);
}); });
it('(False, 0) gt (False, 1) is False', () => { it('(False, 0) gt (False, 1) is False', () => {
expect($b(gt(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(false))(_n(1))))).toBe(false); expect($b(gt._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(false))._(_n(1))))).toBe(false);
}); });
it('(False, 1) gt (False, 0) is True', () => { it('(False, 1) gt (False, 0) is True', () => {
expect($b(gt(bcmp)(ncmp)(Pair(_b(false))(_n(1)))(Pair(_b(false))(_n(0))))).toBe(true); expect($b(gt._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(1)))._(Pair._(_b(false))._(_n(0))))).toBe(true);
}); });
it('(False, 0) gt (True, 0) is False', () => { it('(False, 0) gt (True, 0) is False', () => {
expect($b(gt(bcmp)(ncmp)(Pair(_b(false))(_n(0)))(Pair(_b(true))(_n(0))))).toBe(false); expect($b(gt._(bcmp)._(ncmp)._(Pair._(_b(false))._(_n(0)))._(Pair._(_b(true))._(_n(0))))).toBe(false);
}); });
it('(True, 0) gt (False, 0) is True', () => { it('(True, 0) gt (False, 0) is True', () => {
expect($b(gt(bcmp)(ncmp)(Pair(_b(true))(_n(0)))(Pair(_b(false))(_n(0))))).toBe(true); expect($b(gt._(bcmp)._(ncmp)._(Pair._(_b(true))._(_n(0)))._(Pair._(_b(false))._(_n(0))))).toBe(true);
}); });
it('ignores second if first not equal', () => { it('ignores second if first not equal', () => {
expect($b(gt(bcmp)(undef)(Pair(_b(false))(undef))(Pair(_b(true))(undef)))).toBe(false); expect($b(gt._(bcmp)._(undef)._(Pair._(_b(false))._(undef))._(Pair._(_b(true))._(undef)))).toBe(false);
}); });
}); });
describe('show', () => { describe('show', () => {
it('show (False, 0) is "(False, 0)"', () => { it('show (False, 0) is "(False, 0)"', () => {
expect($s(show(bshow)(nshow)(Pair(_b(false))(_n(0))))).toBe('(False, 0)'); expect(toString(show._(bshow)._(nshow)._(Pair._(_b(false))._(_n(0))))).toBe('(False, 0)');
}); });
it('show (False, 1) is "(False, 1)"', () => { it('show (False, 1) is "(False, 1)"', () => {
expect($s(show(bshow)(nshow)(Pair(_b(false))(_n(1))))).toBe('(False, 1)'); expect(toString(show._(bshow)._(nshow)._(Pair._(_b(false))._(_n(1))))).toBe('(False, 1)');
}); });
it('show (True, 0) is "(True, 0)"', () => { it('show (True, 0) is "(True, 0)"', () => {
expect($s(show(bshow)(nshow)(Pair(_b(true))(_n(0))))).toBe('(True, 0)'); expect(toString(show._(bshow)._(nshow)._(Pair._(_b(true))._(_n(0))))).toBe('(True, 0)');
}); });
it('show (True, 1) is "(True, 1)"', () => { it('show (True, 1) is "(True, 1)"', () => {
expect($s(show(bshow)(nshow)(Pair(_b(true))(_n(1))))).toBe('(True, 1)'); expect(toString(show._(bshow)._(nshow)._(Pair._(_b(true))._(_n(1))))).toBe('(True, 1)');
}); });
}); });
}); });

173
test/string.spec.ts
Unescape View File

@ -1,13 +1,16 @@
import { describe, expect, it } from '@jest/globals'; import { describe, expect, it } from '@jest/globals';
import { _, undef, y } from '../src/core'; import { Term, _, g, l, m, undef } 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';
import { toChar as $c, fromChar as _c } from '../src/char'; 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, fromString as _s, append, cmp, empty, eq, ge, gt, le, len, lt, wrap } from '../src/string';
import { show } from '../src/string.show';
m('string.spec');
describe('String', () => { describe('String', () => {
const infinite: String = Cons(_c('a'))(y(() => infinite)); const infinite: Term = g('infinite', Cons._(_c('a'))._('string.spec::infinite'));
describe('toString', () => { describe('toString', () => {
it('converts ""', () => { it('converts ""', () => {
@ -15,11 +18,11 @@ describe('String', () => {
}); });
it('converts "a"', () => { it('converts "a"', () => {
expect($s(Cons(_c('a'))(Empty))).toBe('a'); expect($s(Cons._(_c('a'))._(Empty))).toBe('a');
}); });
it('converts "abc"', () => { it('converts "abc"', () => {
expect($s(Cons(_c('a'))(Cons(_c('b'))(Cons(_c('c'))(Empty))))).toBe('abc'); expect($s(Cons._(_c('a'))._(Cons._(_c('b'))._(Cons._(_c('c'))._(Empty))))).toBe('abc');
}); });
}); });
@ -42,7 +45,7 @@ describe('String', () => {
// expect($na( // expect($na(
// repeat(_s('a'))<String>(_((x0: Char) => _((x1s: String) => // repeat(_s('a'))<String>(_((x0: Char) => _((x1s: String) =>
// x1s<String>(_((x1: Char) => _((x2s: String) => // x1s<String>(_((x1: Char) => _((x2s: String) =>
// x2s<String>(_((x2: Char) => _((_xrs: String): String => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual('aaa'); // x2s<String>(_((x2: Char) => _((_xrs: String): String => cons(x0)._(cons(x1)._(cons(x2)._(Nil)))))))))))))).toEqual('aaa');
// }); // });
// }); // });
@ -51,323 +54,323 @@ describe('String', () => {
// expect($na( // expect($na(
// iterate(_s('a'))<String>(_((x0: Char) => _((x1s: String) => // iterate(_s('a'))<String>(_((x0: Char) => _((x1s: String) =>
// x1s<String>(_((x1: Char) => _((x2s: String) => // x1s<String>(_((x1: Char) => _((x2s: String) =>
// x2s<String>(_((x2: Char) => _((_xrs: String): String => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual('abc'); // x2s<String>(_((x2: Char) => _((_xrs: String): String => cons(x0)._(cons(x1)._(cons(x2)._(Nil)))))))))))))).toEqual('abc');
// }); // });
// }); // });
describe('empty', () => { describe('empty', () => {
it('empty "" is True', () => { it('empty "" is True', () => {
expect($b(empty(_s('')))).toEqual(true); expect($b(empty._(_s('')))).toEqual(true);
}); });
it('empty "a" is False', () => { it('empty "a" is False', () => {
expect($b(empty(_s('a')))).toEqual(false); expect($b(empty._(_s('a')))).toEqual(false);
}); });
it('empty "ab" is False', () => { it('empty "ab" is False', () => {
expect($b(empty(_s('ab')))).toEqual(false); expect($b(empty._(_s('ab')))).toEqual(false);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($b(empty(infinite))).toEqual(false); expect($b(empty._(infinite))).toEqual(false);
}); });
}); });
describe('len', () => { describe('len', () => {
it('len "" is 0', () => { it('len "" is 0', () => {
expect($n(len(_s('')))).toEqual(0); expect($n(len._(_s('')))).toEqual(0);
}); });
it('len "a" is 1', () => { it('len "a" is 1', () => {
expect($n(len(_s('a')))).toEqual(1); expect($n(len._(_s('a')))).toEqual(1);
}); });
it('len "ab" is 2', () => { it('len "ab" is 2', () => {
expect($n(len(_s('ab')))).toEqual(2); expect($n(len._(_s('ab')))).toEqual(2);
}); });
it('handles infinite lists', () => { it('handles infinite lists', () => {
expect($b(ngt(len(infinite))(Zero))).toEqual(true); expect($b(ngt._(len._(infinite))._(Zero))).toEqual(true);
}); });
}); });
describe('append', () => { describe('append', () => {
it('"" append "" is ""', () => { it('"" append "" is ""', () => {
expect($s(append(Empty)(Empty))).toBe(''); expect($s(append._(Empty)._(Empty))).toBe('');
}); });
it('"a" append "b" is "ab"', () => { it('"a" append "b" is "ab"', () => {
expect($s(append(_s('a'))(_s('b')))).toBe('ab'); expect($s(append._(_s('a'))._(_s('b')))).toBe('ab');
}); });
it('"abc" append "def" is "abcdef"', () => { it('"abc" append "def" is "abcdef"', () => {
expect($s(append(_s('abc'))(_s('def')))).toBe('abcdef'); expect($s(append._(_s('abc'))._(_s('def')))).toBe('abcdef');
}); });
it('handles infinite strings', () => { it('handles infinite strings', () => {
expect($c(append(infinite)(infinite)(undef)(_(x => _(_xs => x))))).toBe('a'); expect($c(append._(infinite)._(infinite)._(undef)._(l('x', l('_', 'x'))))).toBe('a');
}); });
}); });
describe('wrap', () => { describe('wrap', () => {
it('"" wrap "" is ""', () => { it('"" wrap "" is ""', () => {
expect($s(wrap(Empty)(Empty))).toBe(''); expect($s(wrap._(Empty)._(Empty))).toBe('');
}); });
it('"a" wrap "b" is "aba"', () => { it('"a" wrap "b" is "aba"', () => {
expect($s(wrap(_s('a'))(_s('b')))).toBe('aba'); expect($s(wrap._(_s('a'))._(_s('b')))).toBe('aba');
}); });
it('handles infinite strings', () => { it('handles infinite strings', () => {
expect($c(wrap(infinite)(infinite)(undef)(_(x => _(_xs => x))))).toBe('a'); expect($c(wrap._(infinite)._(infinite)._(undef)._(l('x', l('_', 'x'))))).toBe('a');
}); });
}); });
describe('cmp', () => { describe('cmp', () => {
it('"" cmp "" is EQ', () => { it('"" cmp "" is EQ', () => {
expect(toNOrd(cmp(_s(''))(_s('')))).toEqual(NOrd.EQ); expect(toNOrd(cmp._(_s(''))._(_s('')))).toEqual(NOrd.EQ);
}); });
it('"" cmp "abc" is LT', () => { it('"" cmp "abc" is LT', () => {
expect(toNOrd(cmp(_s(''))(_s('abc')))).toEqual(NOrd.LT); expect(toNOrd(cmp._(_s(''))._(_s('abc')))).toEqual(NOrd.LT);
}); });
it('"abc" cmp "" is GT', () => { it('"abc" cmp "" is GT', () => {
expect(toNOrd(cmp(_s('abc'))(_s('')))).toEqual(NOrd.GT); expect(toNOrd(cmp._(_s('abc'))._(_s('')))).toEqual(NOrd.GT);
}); });
it('"a" cmp "abc" is LT', () => { it('"a" cmp "abc" is LT', () => {
expect(toNOrd(cmp(_s('a'))(_s('abc')))).toEqual(NOrd.LT); expect(toNOrd(cmp._(_s('a'))._(_s('abc')))).toEqual(NOrd.LT);
}); });
it('"abc" cmp "a" is GT', () => { it('"abc" cmp "a" is GT', () => {
expect(toNOrd(cmp(_s('abc'))(_s('a')))).toEqual(NOrd.GT); expect(toNOrd(cmp._(_s('abc'))._(_s('a')))).toEqual(NOrd.GT);
}); });
it('"bca" cmp "abc" is GT', () => { it('"bca" cmp "abc" is GT', () => {
expect(toNOrd(cmp(_s('bca'))(_s('abc')))).toEqual(NOrd.GT); expect(toNOrd(cmp._(_s('bca'))._(_s('abc')))).toEqual(NOrd.GT);
}); });
it('"abc" cmp "bca" is LT', () => { it('"abc" cmp "bca" is LT', () => {
expect(toNOrd(cmp(_s('abc'))(_s('bca')))).toEqual(NOrd.LT); expect(toNOrd(cmp._(_s('abc'))._(_s('bca')))).toEqual(NOrd.LT);
}); });
it('"abc" cmp "abc" is EQ', () => { it('"abc" cmp "abc" is EQ', () => {
expect(toNOrd(cmp(_s('abc'))(_s('abc')))).toEqual(NOrd.EQ); expect(toNOrd(cmp._(_s('abc'))._(_s('abc')))).toEqual(NOrd.EQ);
}); });
it('handles infinite strings', () => { it('handles infinite strings', () => {
expect(toNOrd(cmp(_s('abc'))(infinite))).toEqual(NOrd.GT); expect(toNOrd(cmp._(_s('abc'))._(infinite))).toEqual(NOrd.GT);
expect(toNOrd(cmp(infinite)(_s('abc')))).toEqual(NOrd.LT); expect(toNOrd(cmp._(infinite)._(_s('abc')))).toEqual(NOrd.LT);
}); });
}); });
describe('lt', () => { describe('lt', () => {
it('"" lt "" is False', () => { it('"" lt "" is False', () => {
expect($b(lt(_s(''))(_s('')))).toEqual(false); expect($b(lt._(_s(''))._(_s('')))).toEqual(false);
}); });
it('"" lt "abc" is True', () => { it('"" lt "abc" is True', () => {
expect($b(lt(_s(''))(_s('abc')))).toEqual(true); expect($b(lt._(_s(''))._(_s('abc')))).toEqual(true);
}); });
it('"abc" lt "" is False', () => { it('"abc" lt "" is False', () => {
expect($b(lt(_s('abc'))(_s('')))).toEqual(false); expect($b(lt._(_s('abc'))._(_s('')))).toEqual(false);
}); });
it('"a" lt "abc" is True', () => { it('"a" lt "abc" is True', () => {
expect($b(lt(_s('a'))(_s('abc')))).toEqual(true); expect($b(lt._(_s('a'))._(_s('abc')))).toEqual(true);
}); });
it('"abc" lt "a" is False', () => { it('"abc" lt "a" is False', () => {
expect($b(lt(_s('abc'))(_s('a')))).toEqual(false); expect($b(lt._(_s('abc'))._(_s('a')))).toEqual(false);
}); });
it('"bca" lt "abc" is False', () => { it('"bca" lt "abc" is False', () => {
expect($b(lt(_s('bca'))(_s('abc')))).toEqual(false); expect($b(lt._(_s('bca'))._(_s('abc')))).toEqual(false);
}); });
it('"abc" lt "bca" is True', () => { it('"abc" lt "bca" is True', () => {
expect($b(lt(_s('abc'))(_s('bca')))).toEqual(true); expect($b(lt._(_s('abc'))._(_s('bca')))).toEqual(true);
}); });
it('"abc" lt "abc" is False', () => { it('"abc" lt "abc" is False', () => {
expect($b(lt(_s('abc'))(_s('abc')))).toEqual(false); expect($b(lt._(_s('abc'))._(_s('abc')))).toEqual(false);
}); });
it('handles infinite strings', () => { it('handles infinite strings', () => {
expect($b(lt(_s('abc'))(infinite))).toEqual(false); expect($b(lt._(_s('abc'))._(infinite))).toEqual(false);
expect($b(lt(infinite)(_s('abc')))).toEqual(true); expect($b(lt._(infinite)._(_s('abc')))).toEqual(true);
}); });
}); });
describe('le', () => { describe('le', () => {
it('"" le "" is True', () => { it('"" le "" is True', () => {
expect($b(le(_s(''))(_s('')))).toEqual(true); expect($b(le._(_s(''))._(_s('')))).toEqual(true);
}); });
it('"" le "abc" is True', () => { it('"" le "abc" is True', () => {
expect($b(le(_s(''))(_s('abc')))).toEqual(true); expect($b(le._(_s(''))._(_s('abc')))).toEqual(true);
}); });
it('"abc" le "" is False', () => { it('"abc" le "" is False', () => {
expect($b(le(_s('abc'))(_s('')))).toEqual(false); expect($b(le._(_s('abc'))._(_s('')))).toEqual(false);
}); });
it('"a" le "abc" is True', () => { it('"a" le "abc" is True', () => {
expect($b(le(_s('a'))(_s('abc')))).toEqual(true); expect($b(le._(_s('a'))._(_s('abc')))).toEqual(true);
}); });
it('"abc" le "a" is False', () => { it('"abc" le "a" is False', () => {
expect($b(le(_s('abc'))(_s('a')))).toEqual(false); expect($b(le._(_s('abc'))._(_s('a')))).toEqual(false);
}); });
it('"bca" le "abc" is False', () => { it('"bca" le "abc" is False', () => {
expect($b(le(_s('bca'))(_s('abc')))).toEqual(false); expect($b(le._(_s('bca'))._(_s('abc')))).toEqual(false);
}); });
it('"abc" le "bca" is True', () => { it('"abc" le "bca" is True', () => {
expect($b(le(_s('abc'))(_s('bca')))).toEqual(true); expect($b(le._(_s('abc'))._(_s('bca')))).toEqual(true);
}); });
it('"abc" le "abc" is True', () => { it('"abc" le "abc" is True', () => {
expect($b(le(_s('abc'))(_s('abc')))).toEqual(true); expect($b(le._(_s('abc'))._(_s('abc')))).toEqual(true);
}); });
it('handles infinite strings', () => { it('handles infinite strings', () => {
expect($b(le(_s('abc'))(infinite))).toEqual(false); expect($b(le._(_s('abc'))._(infinite))).toEqual(false);
expect($b(le(infinite)(_s('abc')))).toEqual(true); expect($b(le._(infinite)._(_s('abc')))).toEqual(true);
}); });
}); });
describe('eq', () => { describe('eq', () => {
it('"" eq "" is True', () => { it('"" eq "" is True', () => {
expect($b(eq(_s(''))(_s('')))).toEqual(true); expect($b(eq._(_s(''))._(_s('')))).toEqual(true);
}); });
it('"" eq "abc" is False', () => { it('"" eq "abc" is False', () => {
expect($b(eq(_s(''))(_s('abc')))).toEqual(false); expect($b(eq._(_s(''))._(_s('abc')))).toEqual(false);
}); });
it('"abc" eq "" is False', () => { it('"abc" eq "" is False', () => {
expect($b(eq(_s('abc'))(_s('')))).toEqual(false); expect($b(eq._(_s('abc'))._(_s('')))).toEqual(false);
}); });
it('"a" eq "abc" is False', () => { it('"a" eq "abc" is False', () => {
expect($b(eq(_s('a'))(_s('abc')))).toEqual(false); expect($b(eq._(_s('a'))._(_s('abc')))).toEqual(false);
}); });
it('"abc" eq "a" is False', () => { it('"abc" eq "a" is False', () => {
expect($b(eq(_s('abc'))(_s('a')))).toEqual(false); expect($b(eq._(_s('abc'))._(_s('a')))).toEqual(false);
}); });
it('"bca" eq "abc" is False', () => { it('"bca" eq "abc" is False', () => {
expect($b(eq(_s('bca'))(_s('abc')))).toEqual(false); expect($b(eq._(_s('bca'))._(_s('abc')))).toEqual(false);
}); });
it('"abc" eq "bca" is False', () => { it('"abc" eq "bca" is False', () => {
expect($b(eq(_s('abc'))(_s('bca')))).toEqual(false); expect($b(eq._(_s('abc'))._(_s('bca')))).toEqual(false);
}); });
it('"abc" eq "abc" is True', () => { it('"abc" eq "abc" is True', () => {
expect($b(eq(_s('abc'))(_s('abc')))).toEqual(true); expect($b(eq._(_s('abc'))._(_s('abc')))).toEqual(true);
}); });
it('handles infinite strings', () => { it('handles infinite strings', () => {
expect($b(eq(_s('abc'))(infinite))).toEqual(false); expect($b(eq._(_s('abc'))._(infinite))).toEqual(false);
expect($b(eq(infinite)(_s('abc')))).toEqual(false); expect($b(eq._(infinite)._(_s('abc')))).toEqual(false);
}); });
}); });
describe('ge', () => { describe('ge', () => {
it('"" ge "" is True', () => { it('"" ge "" is True', () => {
expect($b(ge(_s(''))(_s('')))).toEqual(true); expect($b(ge._(_s(''))._(_s('')))).toEqual(true);
}); });
it('"" ge "abc" is False', () => { it('"" ge "abc" is False', () => {
expect($b(ge(_s(''))(_s('abc')))).toEqual(false); expect($b(ge._(_s(''))._(_s('abc')))).toEqual(false);
}); });
it('"abc" ge "" is True', () => { it('"abc" ge "" is True', () => {
expect($b(ge(_s('abc'))(_s('')))).toEqual(true); expect($b(ge._(_s('abc'))._(_s('')))).toEqual(true);
}); });
it('"a" ge "abc" is False', () => { it('"a" ge "abc" is False', () => {
expect($b(ge(_s('a'))(_s('abc')))).toEqual(false); expect($b(ge._(_s('a'))._(_s('abc')))).toEqual(false);
}); });
it('"abc" ge "a" is True', () => { it('"abc" ge "a" is True', () => {
expect($b(ge(_s('abc'))(_s('a')))).toEqual(true); expect($b(ge._(_s('abc'))._(_s('a')))).toEqual(true);
}); });
it('"bca" ge "abc" is True', () => { it('"bca" ge "abc" is True', () => {
expect($b(ge(_s('bca'))(_s('abc')))).toEqual(true); expect($b(ge._(_s('bca'))._(_s('abc')))).toEqual(true);
}); });
it('"abc" ge "bca" is False', () => { it('"abc" ge "bca" is False', () => {
expect($b(ge(_s('abc'))(_s('bca')))).toEqual(false); expect($b(ge._(_s('abc'))._(_s('bca')))).toEqual(false);
}); });
it('"abc" ge "abc" is True', () => { it('"abc" ge "abc" is True', () => {
expect($b(ge(_s('abc'))(_s('abc')))).toEqual(true); expect($b(ge._(_s('abc'))._(_s('abc')))).toEqual(true);
}); });
it('handles infinite strings', () => { it('handles infinite strings', () => {
expect($b(ge(_s('abc'))(infinite))).toEqual(true); expect($b(ge._(_s('abc'))._(infinite))).toEqual(true);
expect($b(ge(infinite)(_s('abc')))).toEqual(false); expect($b(ge._(infinite)._(_s('abc')))).toEqual(false);
}); });
}); });
describe('gt', () => { describe('gt', () => {
it('"" gt "" is False', () => { it('"" gt "" is False', () => {
expect($b(gt(_s(''))(_s('')))).toEqual(false); expect($b(gt._(_s(''))._(_s('')))).toEqual(false);
}); });
it('"" gt "abc" is False', () => { it('"" gt "abc" is False', () => {
expect($b(gt(_s(''))(_s('abc')))).toEqual(false); expect($b(gt._(_s(''))._(_s('abc')))).toEqual(false);
}); });
it('"abc" gt "" is True', () => { it('"abc" gt "" is True', () => {
expect($b(gt(_s('abc'))(_s('')))).toEqual(true); expect($b(gt._(_s('abc'))._(_s('')))).toEqual(true);
}); });
it('"a" gt "abc" is False', () => { it('"a" gt "abc" is False', () => {
expect($b(gt(_s('a'))(_s('abc')))).toEqual(false); expect($b(gt._(_s('a'))._(_s('abc')))).toEqual(false);
}); });
it('"abc" gt "a" is True', () => { it('"abc" gt "a" is True', () => {
expect($b(gt(_s('abc'))(_s('a')))).toEqual(true); expect($b(gt._(_s('abc'))._(_s('a')))).toEqual(true);
}); });
it('"bca" gt "abc" is True', () => { it('"bca" gt "abc" is True', () => {
expect($b(gt(_s('bca'))(_s('abc')))).toEqual(true); expect($b(gt._(_s('bca'))._(_s('abc')))).toEqual(true);
}); });
it('"abc" gt "bca" is False', () => { it('"abc" gt "bca" is False', () => {
expect($b(gt(_s('abc'))(_s('bca')))).toEqual(false); expect($b(gt._(_s('abc'))._(_s('bca')))).toEqual(false);
}); });
it('"abc" gt "abc" is False', () => { it('"abc" gt "abc" is False', () => {
expect($b(gt(_s('abc'))(_s('abc')))).toEqual(false); expect($b(gt._(_s('abc'))._(_s('abc')))).toEqual(false);
}); });
it('handles infinite strings', () => { it('handles infinite strings', () => {
expect($b(gt(_s('abc'))(infinite))).toEqual(true); expect($b(gt._(_s('abc'))._(infinite))).toEqual(true);
expect($b(gt(infinite)(_s('abc')))).toEqual(false); expect($b(gt._(infinite)._(_s('abc')))).toEqual(false);
}); });
}); });
describe('show', () => { describe('show', () => {
it('show "" is """"', () => { it('show "" is """"', () => {
expect($s(show(_s('')))).toBe('""'); expect($s(show._(_s('')))).toBe('""');
}); });
it('show "a" is ""a""', () => { it('show "a" is ""a""', () => {
expect($s(show(_s('a')))).toBe('"a"'); expect($s(show._(_s('a')))).toBe('"a"');
}); });
it('show "abc" is ""abc""', () => { it('show "abc" is ""abc""', () => {
expect($s(show(_s('abc')))).toBe('"abc"'); expect($s(show._(_s('abc')))).toBe('"abc"');
}); });
}); });
}); });

1
test/tsconfig.json
Unescape View File

@ -1,6 +1,7 @@
{ {
"extends": "../tsconfig.json", "extends": "../tsconfig.json",
"include": [ "include": [
"../src/**/*.ts",
"**/*.ts", "**/*.ts",
], ],
} }

Write Preview
Loading…
Cancel
Save