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-unexpected-multiline': 'off',
'sort-imports': ['error', { ignoreDeclarationSort: true }],
'@stylistic/brace-style': ['error', '1tbs', { allowSingleLine: true }],
'@stylistic/quotes': ['error', 'single'],
'@stylistic/semi': ['error', 'always'],
'@stylistic/indent': 'error',
'@stylistic/arrow-parens': ['error', 'as-needed', { requireForBlockBody: false }],
'@stylistic/max-statements-per-line': 'off',
'@stylistic/member-delimiter-style': 'error',
'@typescript-eslint/no-unused-vars': [
'error',
{

98
src/bf.ts
Unescape View File

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

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

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 { 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
= Zero;
export const x00 = g('x00', Zero);
export const xFF: Num
= _n(255);
export const xFF = g('xFF', _n(255));
export const Inc: L<(p: Byte) => Byte>
= _(p => iif(eq(xFF)(p))(x00)(Succ(p)));
export const Inc = g('Inc', l('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>
= Inc;
export const inc = g('inc', Inc);
export const dec: L<(n: Byte) => Byte>
= _(n => n(xFF)(id));
export const dec = g('dec', l('n', r('n')._(xFF)._(id)));
export const sum: L<(l: Byte) => L<(r: Byte) => Byte>>
= _(l => _(r => r(l)(sum(inc(l)))));
export const sum = g('sum', l('l', l('r', r('r')._('l')._(r('byte::sum')._(inc._('l'))))));
export const sub: L<(l: Byte) => L<(r: Byte) => Byte>>
= _(l => _(r => r(l)(sub(dec(l)))));
export const sub = g('sub', l('l', l('r', r('r')._('l')._(r('byte::sub')._(dec._('l'))))));
export const mul: L<(l: Byte) => L<(r: Byte) => Byte>>
= _(l => _(r => l(x00)(_(pl => sum(r)(mul(pl)(r))))));
export const mul = g('mul', l('l', l('r', r('l')._(x00)._(l('pl', sum._('r')._(r('byte::mul')._('pl')._('r')))))));
export const fromNumber: (n: number) => Byte
= n => _n(n % 256);
export const fromNumber: (n: number) => Term = 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 { toNumber as $n, Byte, fromNumber as _n, x00 } from './byte';
import { Term, g, l, m, pipe } from './core';
import { toNumber as $n, fromNumber as _n, x00 } from './byte';
import { singleton } from './list';
import { String, fromString as _s, wrap } from './string';
export type Char = Byte;
m('char');
export const Null: Char
= x00;
export const Null = g('Null', x00);
export { inc, dec, ifz as ifn, cmp, lt, le, eq, ge, gt } from './byte';
export const show: L<(c: Char) => String>
= _(c => pipe(wrap(_s('\'')))(singleton)(c));
export const fromChar: (c: string) => Term = c => _n(c.charCodeAt(0));
export const fromChar: (c: string) => Char
= c => _n(c.charCodeAt(0));
export const toChar: (c: Char) => string
= c => String.fromCharCode($n(c));
export const toChar: (c: Term) => 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) =>
Object.assign(((p: Parameters<T>[0]): ReturnType<T> => {
let v: F;
return defer(() => run()(defer(() => v ??= p.run())).run());
}) as T, { run });
export abstract class Term {
protected id = index++;
protected cache: Term | null = null;
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>
= v => defer(() => v as any);
export const toNative: <T>(v: L<any>) => T
= <T>(v: L<any>) => v.run() as T;
public refs(_name: string): boolean {
return false;
};
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>
= _(v => v);
export const cnst: L<<T extends L>(v: T) => L<(_: unknown) => T>>
= _(v => _(_ => v)) as L<<T extends L>(v: T) => L<(_: unknown) => T>>;
export const pipe: L<<A extends L, B extends L, C extends L>(f: L<(v: B) => C>) => L<(g: L<(v: A) => B>) => L<(v: A) => C>>>
= _(<A extends L, B extends L, C extends L>(f: L<(v: B) => C>) =>
_((g: L<(v: A) => B>) =>
_((v: A) => f(g(v)))));
public context(): string {
return !Object.keys(this.bindings).length ? `<${this.id}>` : `<${this.id}>[bound ${Object.keys(this.bindings).join(', ')}] `;
}
public stringify(context?: boolean): string {
return `${context ? this.context() : ''}${this.constructor.name}`;
}
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';
import { String, toString } from './string';
export const log: L<<T extends L>(s: String) => L<(p: T) => T>>
= _(s => _(p => {
console.log(toString(s));
return p;
}));
let indent: string = '';
const logs: string[] = [];
let logging: boolean = false;
export function log(): void {
logging = true;
}
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 { toString as $s, fromString as _s } from './string';
import { run } from './bf';
import { dump, log } from './debug';
import { _ } from './core';
import { fromNumber, toNumber } from './num';
import { Cons, Nil, toArray } from './list';
console.log($s(run
(_s('++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.'))
(_s(''))));
log();
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 { EQ, GT, LT, Ord, eq as eqc } from './ord';
import { Bool, False, True, and, iif, or } from './bool';
import { Num, Zero, succ } from './num';
import { String, fromString as _s } from './string';
export type List<T extends 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)));
import { $, Term, _, cnst, d, g, id, l, m, pipe, r, undef } from './core';
import { EQ, GT, LT, eq as eqc } from './ord';
import { False, True, and, iif, or } from './bool';
import { Zero, succ } from './num';
export const iterate: L<<T extends L>(f: L<(x: T) => T>) => L<(x: T) => List<T>>>
= _(<T extends L>(f: L<(x: T) => T>) => _((x: T) => cons(x)(iterate(f)(f(x)))));
m('list');
export const head: L<<T extends L>(xs: List<T>) => T>
= _(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 Nil = g('Nil', l('z', l('_', 'z')));
export const map: L<<T extends L, R extends L>(f: L<(x: T) => R>) => L<(xs: List<T>) => List<R>>>
= _(<T extends L, R extends L>(f: L<(x: T) => R>) =>
_((xs: List<T>) => xs(Nil)(_(x => pipe(cons(f(x)))(map(f))))));
export const filter: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => List<T>>>
= _(<T extends L>(f: L<(x: T) => Bool>) =>
_((xs: List<T>) => xs(Nil)(_(x => pipe(iif(f(x))(cons(x))(id))(filter(f))))));
export const any: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>>
= _(<T extends L>(f: L<(x: T) => Bool>) =>
_((xs: List<T>) => xs(False)(_(x => pipe(or(f(x)))(any(f))))));
export const all: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>>
= _(<T extends L>(f: L<(x: T) => Bool>) =>
_((xs: List<T>) => xs(True)(_(x => pipe(and(f(x)))(all(f))))));
export const get: L<<T extends L>(i: Num) => L<(xs: List<T>) => T>>
= _(i => _(xs => xs(undef)(_(x => i(cnst(x))(get)))));
export const update: L<<T extends L>(f: L< (p: T) => T>) => L<(i: Num) => L<(xs: List<T>) => List<T>>>>
= _(<T extends L>(f: L< (p: T) => T>) =>
_((i: Num) =>
_((xs: List<T>) =>
xs(undef)(_(x => _(xs => i(cons(f(x))(xs))(_(pi => cons(x)(update(f)(pi)(xs))))))))));
export const set: L<<T extends L>(v: T) => L<(i: Num) => L<(xs: List<T>) => List<T>>>>
= pipe(update)(cnst);
export const intersperse: L<<T extends L>(v: T) => L<(xs: List<T>) => List<T>>>
= _(v => _(xs => xs(xs)(_(x => _(rxs => rxs(xs)(cnst(cnst(cons(x)(cons(v)(intersperse(v)(rxs)))))))))));
export const show: L<<T extends L>(eshow: L<(e: T) => String>) => L<(xs: List<T>) => String>>
= _(eshow => _(xs => concat(snoc(cons(_s('['))(intersperse(_s(', '))(map(eshow)(xs))))(_s(']')))));
export const fromArray: <T extends L>(xs: T[]) => List<T>
= xs => xs.length === 0 ? Nil : cons(xs[0])(y(() => fromArray(xs.slice(1))));
export const toArray: <T extends L>(xs: List<T>) => L[]
= xs => $$(xs(__([]))(_(x => _(xs => __([x, ...toArray(xs)])))));
export const Cons = g('Cons', l('x', l('xs', l('_', l('f', r('f')._('x')._('xs'))))));
export const cons = g('cons', Cons);
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'))))))));
export const nul = g('nul', l('xs', r('xs')._(True)._(cnst._(cnst._(False)))));
export const len = g('len', l('xs', r('xs')._(Zero)._(cnst._(pipe._(succ)._(r('list::len'))))));
export const singleton = g('singleton', l('x', cons._('x')._(Nil)));
export const append = g('append', l('l', l('r', r('l')._('r')._(l('x', l('xs', cons._('x')._(r('list::append')._('xs')._('r'))))))));
export const concat = g('concat', l('ls', r('ls')._(Nil)._(l('x', pipe._(append._('x'))._(r('list::concat'))))));
export const repeat = g('repeat', l('x', cons._('x')._(r('list::repeat')._('x'))));
export const iterate = g('iterate', l('f', l('x', cons._('x')._(r('list::iterate')._('f')._(r('f')._('x'))))));
export const head = g('head', l('xs', r('xs')._(undef)._(cnst)));
export const tail = g('tail', l('xs', r('xs')._(undef)._(cnst._(id))));
export const foldl = g('foldl', l('f', l('z', l('xs', r('xs')._('z')._(pipe._(r('list::foldl')._('f'))._(r('f')._('z')))))));
export const foldlz = g('foldlz', l('f', l('xs', r('xs')._(undef)._(foldl._('f')))));
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'))))))));
export const foldrz = g('foldrz', undef);
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 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)))))))))));
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 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 { EQ, GT, LT, Ord } from './ord';
import { Bool, False, True, iif } from './bool';
import { Empty, String, append, cons } from './string';
import { $, Term, _, cnst, d, g, id, l, m, pipe, r } from './core';
import { EQ, GT, LT } from './ord';
import { False, True, iif } from './bool';
export type Num = L<<T extends L>(z: T) => L<(n: L<(p: Num) => T>) => T>>;
m('num');
export const Zero: Num
= _(z => _(_n => z)) as Num;
export const Zero = g('Zero', l('z', l('_n', 'z')));
export const Succ: L<(p: Num) => Num>
= _(p => _(_z => _(n => n(p))));
export const Succ = g('Succ', l('p', l('_z', l('n', r('n')._('p')))));
export const ifz: L<<T extends L>(n: Num) => L<(t: T) => L<(f: T) => T>>>
= _(n => _(t => _(f => n(t)(cnst(f)))));
export const ifz = g('ifz', l('n', l('t', l('f', r('n')._('t')._(cnst._('f'))))));
export const succ: L<(n: Num) => Num>
= Succ;
export const succ = g('succ', Succ);
export const pred: L<(n: Num) => Num>
= _(n => n(Zero)(id));
export const pred = g('pred', l('n', r('n')._(Zero)._(id)));
export const cmp: L<(l: Num) => L<(r: Num) => Ord>>
= _(l => _(r => l(r(EQ)(cnst(LT)))(pipe(r(GT))(cmp))));
export const cmp = g('cmp', l('l', l('r', r('l')._(r('r')._(EQ)._(cnst._(LT)))._(pipe._(r('r')._(GT))._('num::cmp')))));
export const lt: L<(l: Num) => L<(r: Num) => Bool>>
= _(l => _(r => r(False)(l(cnst(True))(lt))));
export const lt = g('lt', l('l', l('r', r('r')._(False)._(r('l')._(cnst._(True))._('num::lt')))));
export const le: L<(l: Num) => L<(r: Num) => Bool>>
= _(l => _(r => l(True)(r(cnst(False))(ge))));
export const le = g('le', l('l', l('r', r('l')._(True)._(r('r')._(cnst._(False))._('num::ge')))));
export const eq: L<(l: Num) => L<(r: Num) => Bool>>
= _(l => _(r => l(r(True)(cnst(False)))(r(cnst(False))(eq))));
export const eq = g('eq', l('l', l('r', r('l')._(r('r')._(True)._(cnst._(False)))._(r('r')._(cnst._(False))._('num::eq')))));
export const ge: L<(l: Num) => L<(r: Num) => Bool>>
= _(l => _(r => r(True)(l(cnst(False))(ge))));
export const ge = g('ge', l('l', l('r', r('r')._(True)._(r('l')._(cnst._(False))._('num::ge')))));
export const gt: L<(l: Num) => L<(r: Num) => Bool>>
= _(l => _(r => l(False)(r(cnst(True))(lt))));
export const gt = g('gt', l('l', l('r', r('l')._(False)._(r('r')._(cnst._(True))._(lt)))));
export const even: L<(n: Num) => Bool>
= _(n => n(True)(odd));
export const even = g('even', l('n', r('n')._(True)._('num::odd')));
export const odd: L<(n: Num) => Bool>
= _(n => n(False)(even));
export const odd = g('odd', l('n', r('n')._(False)._('num::even')));
export const sum: L<(l: Num) => L<(r: Num) => Num>>
= _(l => _(r => r(l)(sum(Succ(l)))));
export const sum = g('sum', l('l', l('r', r('r')._('l')._(r('num::sum')._(Succ._('l'))))));
export const sub: L<(l: Num) => L<(r: Num) => Num>>
= _(l => _(r => r(l)(l(cnst(Zero))(sub))));
export const sub = g('sub', l('l', l('r', r('r')._('l')._(r('l')._(cnst._(Zero))._('num::sub')))));
export const mul: L<(l: Num) => L<(r: Num) => Num>>
= _(l => _(r => l(Zero)(_(pl => sum(r)(mul(pl)(r))))));
export const mul = g('mul', l('l', l('r', r('l')._(Zero)._(l('pl', sum._('r')._(r('num::mul')._('pl')._('r')))))));
export const div: L<(l: Num) => L<(r: Num) => Num>>
= _(l => _(r => iif(lt(l)(r))(Zero)(succ(div(sub(l)(r))(r)))));
export const div = g('div', l('l', l('r', iif._(lt._('l')._('r'))._(Zero)._(succ._(r('num::div')._(sub._('l')._('r'))._('r'))))));
export const mod: L<(l: Num) => L<(r: Num) => Num>>
= _(l => _(r => iif(lt(l)(r))(l)(mod(sub(l)(r))(r))));
export const mod = g('mod', l('l', l('r', iif._(lt._('l')._('r'))._('l')._(r('num::mod')._(sub._('l')._('r'))._('r')))));
export const show: L<(n: Num) => String>
= _(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) => Term = n => !n ? Zero : Succ._(d(() => fromNumber(n - 1)));
export const fromNumber: (n: number) => Num
= n => !n ? Zero : Succ(y(() => fromNumber(n - 1)));
export const toNumber: (n: Num) => number
= n => $$(n(__(0))(_(p => __(1 + toNumber(p)))));
export const toNumber: (n: Term) => number = n => $(n._(_(0))._(l('p', d(bs => _(1 + toNumber(bs['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 { Bool, False, True } from './bool';
import { String, fromString as _s } from './string';
import { $, Term, _, c, g, l, m, r } from './core';
export type Ord = L<<T extends L>(lt: T) => L<(eq: T) => L<(gt: T) => T>>>;
m('ord');
export const enum NOrd {
LT,
@ -10,26 +8,19 @@ export const enum NOrd {
GT,
};
export const LT: Ord
= _(lt => _(_eq => _(_gt => lt))) as Ord;
export const LT = g('LT', l('lt', l('_', l('_', 'lt'))));
export const EQ: Ord
= _(_lt => _(eq => _(_gt => eq)));
export const EQ = g('EQ', l('_', l('eq', l('_', 'eq'))));
export const GT: Ord
= _(_lt => _(_eq => _(gt => gt)));
export const GT = g('GT', l('_', l('_', l('gt', 'gt'))));
export const eq: L<(l: Ord) => L<(r: Ord) => Bool>>
= _(l => _(r => l
(r(True)(False)(False))
(r(False)(True)(False))
(r(False)(False)(True))));
export const eq = g('eq', l('l', l('r', c('l',
c('r', 'bool::True', 'bool::False', 'bool::False'),
c('r', 'bool::False', 'bool::True', 'bool::False'),
c('r', 'bool::False', 'bool::False', 'bool::True')))));
export const show: L<(o: Ord) => String>
= _(o => o(_s('LT'))(_s('EQ'))(_s('GT')));
export const fromNOrd: (b: NOrd) => Ord
export const fromNOrd: (o: NOrd) => Term
= o => o === NOrd.LT ? LT : o === NOrd.EQ ? EQ : GT;
export const toNOrd: (b: Ord) => NOrd
= o => $$(o(__(NOrd.LT))(__(NOrd.EQ))(__(NOrd.GT)));
export const toNOrd: (o: Term) => NOrd
= 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 { GT, LT, Ord } from './ord';
import { Bool, False, True, and } from './bool';
import { Nil, concat, cons } from './list';
import { String, fromString as _s } from './string';
import { _, g, l, m, r } from './core';
import { GT, LT } from './ord';
import { False, True, and } from './bool';
import { 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>>>
= _(<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 Pair = g('Pair', l('f', l('s', l('p', r('p')._('f')._('s')))));
export const fst: L<<F extends L, S extends L>(p: Pair<F, S>) => F>
= _(p => p(_(f => _(_s => f))));
export const fst = g('fst', l('p', r('p')._(l('f', l('_', 'f')))));
export const snd: L<<F extends L, S extends L>(p: Pair<F, S>) => S>
= _(p => p(_(_f => _(s => s))));
export const snd = g('snd', l('p', r('p')._(l('_', l('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>>>
= _(<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 first = g('first', l('t', l('p', r('p')._(l('f', l('s', Pair._(r('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>>>
= _(<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 second = g('second', l('t', l('p', r('p')._(l('f', l('s', Pair._('f')._(r('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>>>>
= _(<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 both = g('both', l('tf', l('ts', l('p', r('p')._(l('f', l('s', Pair._(r('tf')._('f'))._(r('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>>
= _(<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 uncurry = g('uncurry', l('t', l('p', r('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>>>>
= _(<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 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))))))))));
export const lt: L<<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
= _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) =>
fcmp(lf)(rf)(True)(scmp(ls)(rs)(True)(False)(False))(False)))))))));
export const 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))))))))));
export const le: L<<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
= _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) =>
fcmp(lf)(rf)(True)(scmp(ls)(rs)(True)(True)(False))(False)))))))));
export const 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))))))))));
export const eq: L<<F extends L, S extends L>(feq: L<(l: F) => L<(r: F) => Bool>>) => L<(seq: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
= _(<F extends L, S extends L>(feq: L<(l: F) => L<(r: F) => Bool>>) =>
_((seq: L<(l: S) => L<(r: S) => Bool>>) =>
uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) =>
and(feq(lf)(rf))(seq(ls)(rs))))))))));
export const 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')))))))))));
export const ge: L<<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
= _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) =>
fcmp(lf)(rf)(False)(scmp(ls)(rs)(False)(True)(True))(True)))))))));
export const 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))))))))));
export const gt: L<<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
= _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
_((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
uncurry(_((lf: F) => _((ls: S) =>
uncurry(_((rf: F) => _((rs: S) =>
fcmp(lf)(rf)(False)(scmp(ls)(rs)(False)(False)(True))(True)))))))));
export const show: L<<F extends 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)))))))))));
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))))))))));

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 { Ord } from './ord';
import { Bool } from './bool';
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';
import { $, Term, _, d, g, l, m } from './core';
import { fromChar as _c, cmp as cmpc, eq as eqc, fromChar, toChar } from './char';
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';
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>>
= cmpl(cmpc);
export const Empty = g('Empty', Nil);
export const lt: L<(l: String) => L<(r: String) => Bool>>
= ltl(cmpc);
export const empty = g('empty', nul);
export const le: L<(l: String) => L<(r: String) => Bool>>
= lel(cmpc);
export const cmp = g('cmp', cmpl._(cmpc));
export const eq: L<(l: String) => L<(r: String) => Bool>>
= eql(eqc);
export const lt = g('lt', ltl._(cmpc));
export const ge: L<(l: String) => L<(r: String) => Bool>>
= gel(cmpc);
export const le = g('le', lel._(cmpc));
export const gt: L<(l: String) => L<(r: String) => Bool>>
= gtl(cmpc);
export const eq = g('eq', eql._(eqc));
export const wrap: L<(w: String) => L<(c: String) => String>>
= _(w => _(c => append(w)(append(c)(w))));
export const ge = g('ge', gel._(cmpc));
export const fromString: (xs: string) => String
= xs => xs.length === 0 ? Nil : Cons(_c(xs[0]))(y(() => fromString(xs.slice(1))));
export const gt = g('gt', gtl._(cmpc));
export const toString: (xs: String) => string
= xs => $$(xs(__(''))(_(x => _(xs => __($c(x) + toString(xs))))));
export const wrap = g('wrap', l('w', l('c', append._('w')._(append._('c')._('w')))));
export const show: L<(s: String) => String>
= wrap(fromString('"'));
export const fromString: (xs: string) => Term = s => !s.length ? Nil : Cons._(fromChar(s[0]))._(d(() => fromString(s.slice(1))));
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('run', () => {
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', () => {
expect($s(run(_s(',.'))(_s('a')))).toBe('a');
expect($s(run._(_s(',.'))._(_s('a')))).toBe('a');
});
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', () => {
expect($s(run(_s('-.'))(_s('')))).toBe(String.fromCharCode(255));
expect($s(run._(_s('-.'))._(_s('')))).toBe(String.fromCharCode(255));
});
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', () => {
expect($s(run(_s('+++++>++<+++++.'))(_s('')))).toBe(String.fromCharCode(10));
expect($s(run._(_s('+++++>++<+++++.'))._(_s('')))).toBe(String.fromCharCode(10));
});
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', () => {
expect($s(run(_s('+++++[-].'))(_s('')))).toBe(String.fromCharCode(0));
expect($s(run._(_s('+++++[-].'))._(_s('')))).toBe(String.fromCharCode(0));
});
it('prints "Hello World!"', () => {
expect($s(run
(_s('++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.'))
(_s(''))))
._(_s('++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.'))
._(_s(''))))
.toBe('Hello World!\n');
});
});

103
test/bool.spec.ts
Unescape View File

@ -1,8 +1,9 @@
import { describe, expect, it } from '@jest/globals';
import { undef } from '../src/core';
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 { show } from '../src/bool.show';
describe('Bool', () => {
describe('toBoolean', () => {
@ -27,222 +28,222 @@ describe('Bool', () => {
describe('iif', () => {
it('returns true argument', () => {
expect($b(iif(True)(True)(False))).toBe(true);
expect($b(iif._(True)._(True)._(False))).toBe(true);
});
it('returns false argument', () => {
expect($b(iif(False)(True)(False))).toBe(false);
expect($b(iif._(False)._(True)._(False))).toBe(false);
});
it('ignores other argument', () => {
expect($b(iif(True)(True)(undef))).toBe(true);
expect($b(iif(False)(undef)(False))).toBe(false);
expect($b(iif._(True)._(True)._(undef))).toBe(true);
expect($b(iif._(False)._(undef)._(False))).toBe(false);
});
});
describe('not', () => {
it('not False is True', () => {
expect($b(not(False))).toBe(true);
expect($b(not._(False))).toBe(true);
});
it('not True is False', () => {
expect($b(not(True))).toBe(false);
expect($b(not._(True))).toBe(false);
});
});
describe('lt', () => {
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', () => {
expect($b(lt(False)(True))).toBe(true);
expect($b(lt._(False)._(True))).toBe(true);
});
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', () => {
expect($b(lt(True)(True))).toBe(false);
expect($b(lt._(True)._(True))).toBe(false);
});
it('True lt ignores second argument', () => {
expect($b(lt(True)(undef))).toBe(false);
expect($b(lt._(True)._(undef))).toBe(false);
});
});
describe('le', () => {
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', () => {
expect($b(le(False)(True))).toBe(true);
expect($b(le._(False)._(True))).toBe(true);
});
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', () => {
expect($b(le(True)(True))).toBe(true);
expect($b(le._(True)._(True))).toBe(true);
});
it('False le ignores second argument', () => {
expect($b(le(False)(undef))).toBe(true);
expect($b(le._(False)._(undef))).toBe(true);
});
});
describe('eq', () => {
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', () => {
expect($b(eq(False)(True))).toBe(false);
expect($b(eq._(False)._(True))).toBe(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', () => {
expect($b(eq(True)(True))).toBe(true);
expect($b(eq._(True)._(True))).toBe(true);
});
});
describe('ge', () => {
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', () => {
expect($b(ge(False)(True))).toBe(false);
expect($b(ge._(False)._(True))).toBe(false);
});
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', () => {
expect($b(ge(True)(True))).toBe(true);
expect($b(ge._(True)._(True))).toBe(true);
});
it('True ge ignores second argument', () => {
expect($b(ge(True)(undef))).toBe(true);
expect($b(ge._(True)._(undef))).toBe(true);
});
});
describe('gt', () => {
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', () => {
expect($b(gt(False)(True))).toBe(false);
expect($b(gt._(False)._(True))).toBe(false);
});
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', () => {
expect($b(gt(True)(True))).toBe(false);
expect($b(gt._(True)._(True))).toBe(false);
});
it('False gt ignores second argument', () => {
expect($b(gt(False)(undef))).toBe(false);
expect($b(gt._(False)._(undef))).toBe(false);
});
});
describe('cmp', () => {
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', () => {
expect($o(cmp(False)(True))).toBe(NOrd.LT);
expect($o(cmp._(False)._(True))).toBe(NOrd.LT);
});
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', () => {
expect($o(cmp(True)(True))).toBe(NOrd.EQ);
expect($o(cmp._(True)._(True))).toBe(NOrd.EQ);
});
});
describe('and', () => {
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', () => {
expect($b(and(False)(True))).toBe(false);
expect($b(and._(False)._(True))).toBe(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', () => {
expect($b(and(True)(True))).toBe(true);
expect($b(and._(True)._(True))).toBe(true);
});
it('False and ignores other argument', () => {
expect($b(and(False)(undef))).toBe(false);
expect($b(and._(False)._(undef))).toBe(false);
});
});
describe('or', () => {
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', () => {
expect($b(or(False)(True))).toBe(true);
expect($b(or._(False)._(True))).toBe(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', () => {
expect($b(or(True)(True))).toBe(true);
expect($b(or._(True)._(True))).toBe(true);
});
it('True or ignores other argument', () => {
expect($b(or(True)(undef))).toBe(true);
expect($b(or._(True)._(undef))).toBe(true);
});
});
describe('xor', () => {
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', () => {
expect($b(xor(False)(True))).toBe(true);
expect($b(xor._(False)._(True))).toBe(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', () => {
expect($b(xor(True)(True))).toBe(false);
expect($b(xor._(True)._(True))).toBe(false);
});
});
describe('show', () => {
it('show False is "False"', () => {
expect($s(show(False))).toBe('False');
expect($s(show._(False))).toBe('False');
});
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 { toNOrd as $o, NOrd } from '../src/ord';
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 { show } from '../src/byte.show';
describe('Byte', () => {
describe('toNumber', () => {
@ -12,11 +13,11 @@ describe('Byte', () => {
});
it('converts 1', () => {
expect($n(Inc(x00))).toBe(1);
expect($n(Inc._(x00))).toBe(1);
});
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', () => {
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', () => {
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', () => {
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', () => {
expect($b(ifz(_n(0))(_b(true))(undef))).toBe(true);
expect($b(ifz(_n(1))(undef)(_b(false)))).toBe(false);
expect($b(ifz._(_n(0))._(_b(true))._(undef))).toBe(true);
expect($b(ifz._(_n(1))._(undef)._(_b(false)))).toBe(false);
});
});
describe('inc', () => {
it('inc 0 is 1', () => {
expect($n(inc(_n(0)))).toBe(1);
expect($n(inc._(_n(0)))).toBe(1);
});
it('inc 1 is 2', () => {
expect($n(inc(_n(1)))).toBe(2);
expect($n(inc._(_n(1)))).toBe(2);
});
it('inc 10 is 11', () => {
expect($n(inc(_n(10)))).toBe(11);
expect($n(inc._(_n(10)))).toBe(11);
});
it('inc 255 is 0', () => {
expect($n(inc(_n(255)))).toBe(0);
expect($n(inc._(_n(255)))).toBe(0);
});
});
describe('dec', () => {
it('dec 0 is 255', () => {
expect($n(dec(_n(0)))).toBe(255);
expect($n(dec._(_n(0)))).toBe(255);
});
it('dec 1 is 0', () => {
expect($n(dec(_n(1)))).toBe(0);
expect($n(dec._(_n(1)))).toBe(0);
});
it('dec 10 is 9', () => {
expect($n(dec(_n(10)))).toBe(9);
expect($n(dec._(_n(10)))).toBe(9);
});
it('dec 255 is 254', () => {
expect($n(dec(_n(255)))).toBe(254);
expect($n(dec._(_n(255)))).toBe(254);
});
});
describe('cmp', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
expect($o(cmp(_n(255))(_n(255)))).toBe(NOrd.EQ);
expect($o(cmp._(_n(255))._(_n(255)))).toBe(NOrd.EQ);
});
});
describe('lt', () => {
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', () => {
expect($b(lt(_n(0))(_n(1)))).toBe(true);
expect($b(lt._(_n(0))._(_n(1)))).toBe(true);
});
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', () => {
expect($b(lt(_n(3))(_n(3)))).toBe(false);
expect($b(lt._(_n(3))._(_n(3)))).toBe(false);
});
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', () => {
expect($b(lt(_n(7))(_n(3)))).toBe(false);
expect($b(lt._(_n(7))._(_n(3)))).toBe(false);
});
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', () => {
expect($b(lt(_n(255))(_n(0)))).toBe(false);
expect($b(lt._(_n(255))._(_n(0)))).toBe(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', () => {
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', () => {
expect($b(le(_n(0))(_n(1)))).toBe(true);
expect($b(le._(_n(0))._(_n(1)))).toBe(true);
});
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', () => {
expect($b(le(_n(3))(_n(3)))).toBe(true);
expect($b(le._(_n(3))._(_n(3)))).toBe(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', () => {
expect($b(le(_n(7))(_n(3)))).toBe(false);
expect($b(le._(_n(7))._(_n(3)))).toBe(false);
});
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', () => {
expect($b(le(_n(255))(_n(0)))).toBe(false);
expect($b(le._(_n(255))._(_n(0)))).toBe(false);
});
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', () => {
expect($b(le(_n(0))(undef))).toBe(true);
expect($b(le._(_n(0))._(undef))).toBe(true);
});
});
describe('eq', () => {
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', () => {
expect($b(eq(_n(0))(_n(1)))).toBe(false);
expect($b(eq._(_n(0))._(_n(1)))).toBe(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', () => {
expect($b(eq(_n(3))(_n(3)))).toBe(true);
expect($b(eq._(_n(3))._(_n(3)))).toBe(true);
});
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', () => {
expect($b(eq(_n(7))(_n(3)))).toBe(false);
expect($b(eq._(_n(7))._(_n(3)))).toBe(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', () => {
expect($b(eq(_n(255))(_n(0)))).toBe(false);
expect($b(eq._(_n(255))._(_n(0)))).toBe(false);
});
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', () => {
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', () => {
expect($b(ge(_n(0))(_n(1)))).toBe(false);
expect($b(ge._(_n(0))._(_n(1)))).toBe(false);
});
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', () => {
expect($b(ge(_n(3))(_n(3)))).toBe(true);
expect($b(ge._(_n(3))._(_n(3)))).toBe(true);
});
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', () => {
expect($b(ge(_n(7))(_n(3)))).toBe(true);
expect($b(ge._(_n(7))._(_n(3)))).toBe(true);
});
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', () => {
expect($b(ge(_n(255))(_n(0)))).toBe(true);
expect($b(ge._(_n(255))._(_n(0)))).toBe(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', () => {
expect($b(ge(undef)(_n(0)))).toBe(true);
expect($b(ge._(undef)._(_n(0)))).toBe(true);
});
});
describe('gt', () => {
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', () => {
expect($b(gt(_n(0))(_n(1)))).toBe(false);
expect($b(gt._(_n(0))._(_n(1)))).toBe(false);
});
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', () => {
expect($b(gt(_n(3))(_n(3)))).toBe(false);
expect($b(gt._(_n(3))._(_n(3)))).toBe(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', () => {
expect($b(gt(_n(7))(_n(3)))).toBe(true);
expect($b(gt._(_n(7))._(_n(3)))).toBe(true);
});
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', () => {
expect($b(gt(_n(255))(_n(0)))).toBe(true);
expect($b(gt._(_n(255))._(_n(0)))).toBe(true);
});
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', () => {
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', () => {
expect($n(sum(_n(0))(_n(1)))).toBe(1);
expect($n(sum._(_n(0))._(_n(1)))).toBe(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', () => {
expect($n(sum(_n(3))(_n(4)))).toBe(7);
expect($n(sum._(_n(3))._(_n(4)))).toBe(7);
});
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', () => {
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', () => {
expect($n(sub(_n(0))(_n(1)))).toBe(255);
expect($n(sub._(_n(0))._(_n(1)))).toBe(255);
});
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', () => {
expect($n(sub(_n(7))(_n(4)))).toBe(3);
expect($n(sub._(_n(7))._(_n(4)))).toBe(3);
});
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', () => {
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', () => {
expect($n(mul(_n(0))(_n(10)))).toBe(0);
expect($n(mul._(_n(0))._(_n(10)))).toBe(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', () => {
expect($n(mul(_n(1))(_n(10)))).toBe(10);
expect($n(mul._(_n(1))._(_n(10)))).toBe(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', () => {
expect($n(mul(_n(3))(_n(4)))).toBe(12);
expect($n(mul._(_n(3))._(_n(4)))).toBe(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', () => {
expect($n(mul(_n(0))(undef))).toBe(0);
expect($n(mul._(_n(0))._(undef))).toBe(0);
});
});
describe('div', () => {
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', () => {
expect($n(div(_n(1))(_n(10)))).toBe(0);
expect($n(div._(_n(1))._(_n(10)))).toBe(0);
});
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', () => {
expect($n(div(_n(10))(_n(5)))).toBe(2);
expect($n(div._(_n(10))._(_n(5)))).toBe(2);
});
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', () => {
expect($n(div(_n(0))(undef))).toBe(0);
expect($n(div._(_n(0))._(undef))).toBe(0);
});
});
describe('mod', () => {
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', () => {
expect($n(mod(_n(1))(_n(10)))).toBe(1);
expect($n(mod._(_n(1))._(_n(10)))).toBe(1);
});
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', () => {
expect($n(mod(_n(10))(_n(5)))).toBe(0);
expect($n(mod._(_n(10))._(_n(5)))).toBe(0);
});
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', () => {
expect($n(mod(_n(0))(undef))).toBe(0);
expect($n(mod._(_n(0))._(undef))).toBe(0);
});
});
describe('show', () => {
it('show 0 is "0"', () => {
expect($s(show(_n(0)))).toBe('0');
expect($s(show._(_n(0)))).toBe('0');
});
it('show 1 is "1"', () => {
expect($s(show(_n(1)))).toBe('1');
expect($s(show._(_n(1)))).toBe('1');
});
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 { toBoolean as $b, fromBoolean as _b } from '../src/bool';
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 { show } from '../src/char.show';
describe('Char', () => {
describe('toChar', () => {
@ -44,171 +45,171 @@ describe('Char', () => {
describe('cmp', () => {
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', () => {
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', () => {
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', () => {
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', () => {
expect($o(cmp(_c('z'))(_c('-')))).toBe(NOrd.GT);
expect($o(cmp._(_c('z'))._(_c('-')))).toBe(NOrd.GT);
});
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', () => {
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', () => {
expect($b(lt(_c('0'))(_c('a')))).toBe(true);
expect($b(lt._(_c('0'))._(_c('a')))).toBe(true);
});
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', () => {
expect($b(lt(_c('z'))(_c('z')))).toBe(false);
expect($b(lt._(_c('z'))._(_c('z')))).toBe(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', () => {
expect($b(lt(_c('-'))(_c('z')))).toBe(true);
expect($b(lt._(_c('-'))._(_c('z')))).toBe(true);
});
});
describe('le', () => {
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', () => {
expect($b(le(_c('0'))(_c('a')))).toBe(true);
expect($b(le._(_c('0'))._(_c('a')))).toBe(true);
});
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', () => {
expect($b(le(_c('z'))(_c('z')))).toBe(true);
expect($b(le._(_c('z'))._(_c('z')))).toBe(true);
});
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', () => {
expect($b(le(_c('-'))(_c('z')))).toBe(true);
expect($b(le._(_c('-'))._(_c('z')))).toBe(true);
});
});
describe('eq', () => {
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', () => {
expect($b(eq(_c('0'))(_c('a')))).toBe(false);
expect($b(eq._(_c('0'))._(_c('a')))).toBe(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', () => {
expect($b(eq(_c('z'))(_c('z')))).toBe(true);
expect($b(eq._(_c('z'))._(_c('z')))).toBe(true);
});
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', () => {
expect($b(eq(_c('-'))(_c('z')))).toBe(false);
expect($b(eq._(_c('-'))._(_c('z')))).toBe(false);
});
});
describe('ge', () => {
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', () => {
expect($b(ge(_c('0'))(_c('a')))).toBe(false);
expect($b(ge._(_c('0'))._(_c('a')))).toBe(false);
});
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', () => {
expect($b(ge(_c('z'))(_c('z')))).toBe(true);
expect($b(ge._(_c('z'))._(_c('z')))).toBe(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', () => {
expect($b(ge(_c('-'))(_c('z')))).toBe(false);
expect($b(ge._(_c('-'))._(_c('z')))).toBe(false);
});
});
describe('gt', () => {
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', () => {
expect($b(gt(_c('0'))(_c('a')))).toBe(false);
expect($b(gt._(_c('0'))._(_c('a')))).toBe(false);
});
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', () => {
expect($b(gt(_c('z'))(_c('z')))).toBe(false);
expect($b(gt._(_c('z'))._(_c('z')))).toBe(false);
});
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', () => {
expect($b(gt(_c('-'))(_c('z')))).toBe(false);
expect($b(gt._(_c('-'))._(_c('z')))).toBe(false);
});
});
describe('show', () => {
it('show "0" is "\'0\'"', () => {
expect($s(show(_c('0')))).toBe('\'0\'');
expect($s(show._(_c('0')))).toBe('\'0\'');
});
it('show "a" is "\'a\'"', () => {
expect($s(show(_c('a')))).toBe('\'a\'');
expect($s(show._(_c('a')))).toBe('\'a\'');
});
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 { toNative as $$, _, fromNative as __, cnst, id, undef } from '../src/core';
import { $, _, cnst, id, undef } from '../src/core';
describe('id', () => {
it('returns first argument', () => {
expect($$(id(__('first')))).toBe('first');
expect($(id._(_('first')))).toBe('first');
});
});
describe('cnst', () => {
it('returns first argument after receiving second', () => {
expect($$(cnst(__('first'))(__('second')))).toBe('first');
expect($(cnst._(_('first'))._(_('second')))).toBe('first');
});
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 { 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 { 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 { 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 { show as nshow } from '../src/num.show';
import { show } from '../src/list.show';
m('list.spec');
describe('List', () => {
const infinite: List<Num> = iterate(Succ)(Zero);
const infinite: Term = g('infinite', iterate._(Succ)._(Zero));
const _na: (xs: number[]) => List<Num>
= xs => xs.length === 0 ? Nil : Cons(_nn(xs[0]))(y(() => _na(xs.slice(1))));
const _na: (xs: number[]) => Term = xs => !xs.length ? Nil : Cons._(_n(xs[0]))._(d(() => _na(xs.slice(1))));
const $na: (xs: List<Num>) => number[]
= xs => $$(xs(__([]))(_(x => _(xs => __([$nn(x), ...$na(xs)])))));
const $na: (xs: Term) => number[] = xs => $(xs._(_([]))._(l('x', l('xs', d(bs => _([$n(bs['x']), ...$na(bs['xs'])]))))));
describe('toArray', () => {
it('converts []', () => {
@ -22,11 +24,11 @@ describe('List', () => {
});
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]', () => {
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', () => {
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]', () => {
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]', () => {
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', () => {
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', () => {
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]', () => {
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]', () => {
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', () => {
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', () => {
it('nul Nil is True', () => {
expect($b(nul(_na([])))).toEqual(true);
expect($b(nul._(_na([])))).toEqual(true);
});
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', () => {
expect($b(nul(_na([1, 2])))).toEqual(false);
expect($b(nul._(_na([1, 2])))).toEqual(false);
});
it('handles infinite lists', () => {
expect($b(nul(infinite))).toEqual(false);
expect($b(nul._(infinite))).toEqual(false);
});
});
describe('len', () => {
it('len Nil is 0', () => {
expect($n(len(_na([])))).toEqual(0);
expect($n(len._(_na([])))).toEqual(0);
});
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', () => {
expect($n(len(_na([1, 2])))).toEqual(2);
expect($n(len._(_na([1, 2])))).toEqual(2);
});
it('handles infinite lists', () => {
expect($b(ngt(len(infinite))(Zero))).toEqual(true);
expect($b(ngt._(len._(infinite))._(Zero))).toEqual(true);
});
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', () => {
it('singleton 0 is [0]', () => {
expect($na(singleton(_n(0)))).toEqual([0]);
expect($na(singleton._(_n(0)))).toEqual([0]);
});
});
describe('append', () => {
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]', () => {
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]', () => {
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', () => {
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', () => {
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]', () => {
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]', () => {
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', () => {
const dinfinite: List<Num> = cons(infinite)(y(() => dinfinite));
expect($n(concat(dinfinite)(undef)(_(x => _(_xs => x))))).toBe(0);
const dinfinite: Term = g('dinfinite', cons._(infinite)._('dinfinite'));
expect($n(concat._(dinfinite)._(undef)._(l('x', l('_', 'x'))))).toBe(0);
});
});
// describe('repeat', () => {
// it('repeat 0 is [0, 0, 0, ...]', () => {
// expect($na(
// repeat(_n(0))<List<Num>>(_((x0: Num) => _((x1s: List<Num>) =>
// x1s<List<Num>>(_((x1: Num) => _((x2s: List<Num>) =>
// x2s<List<Num>>(_((x2: Num) => _((_xrs: List<Num>): List<Num> => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual([0, 0, 0]);
// repeat._(_n(0))<List<Num>>(l((x0: Num) => l((x1s: List<Num>) =>
// x1s<List<Num>>(l((x1: Num) => l((x2s: List<Num>) =>
// 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', () => {
// it('iterate succ 0 is [0, 1, 2, ...]', () => {
// expect($na(
// iterate(_n(0))<List<Num>>(_((x0: Num) => _((x1s: List<Num>) =>
// x1s<List<Num>>(_((x1: Num) => _((x2s: List<Num>) =>
// x2s<List<Num>>(_((x2: Num) => _((_xrs: List<Num>): List<Num> => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual([0, 1, 2]);
// iterate._(_n(0))<List<Num>>(l((x0: Num) => l((x1s: List<Num>) =>
// x1s<List<Num>>(l((x1: Num) => l((x2s: List<Num>) =>
// 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', () => {
it('returns nothing from Nil', () => {
expect(() => $$(head(Nil))).toThrow();
expect(() => $(head._(Nil))).toThrow();
});
it('returns only item', () => {
expect($n(head(_na([0])))).toBe(0);
expect($n(head._(_na([0])))).toBe(0);
});
it('returns first item', () => {
expect($n(head(_na([0, 1])))).toBe(0);
expect($n(head._(_na([0, 1])))).toBe(0);
});
it('handles infinite lists', () => {
expect($n(head(infinite))).toBe(0);
expect($n(head._(infinite))).toBe(0);
});
});
describe('tail', () => {
it('drops nothing from Nil', () => {
expect(() => $na(tail(Nil))).toThrow();
expect(() => $na(tail._(Nil))).toThrow();
});
it('drops only item', () => {
expect($na(tail(_na([0])))).toEqual([]);
expect($na(tail._(_na([0])))).toEqual([]);
});
it('drops first item', () => {
expect($na(tail(_na([0, 1])))).toEqual([1]);
expect($na(tail._(_na([0, 1])))).toEqual([1]);
});
it('handles infinite lists', () => {
expect($n(head(tail(infinite)))).toBe(1);
expect($n(head._(tail._(infinite)))).toBe(1);
});
});
describe('foldl', () => {
it('folds Nil', () => {
expect($n(foldl(sum)(Zero)(_na([])))).toBe(0);
expect($n(foldl._(sum)._(Zero)._(_na([])))).toBe(0);
});
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', () => {
expect($n(foldl(sum)(Zero)(_na([1, 2])))).toBe(3);
expect($n(foldl._(sum)._(Zero)._(_na([1, 2])))).toBe(3);
});
});
describe('foldlz', () => {
it('does not fold Nil', () => {
expect(() => $n(foldlz(sum)(Nil))).toThrow();
expect(() => $n(foldlz._(sum)._(Nil))).toThrow();
});
it('folds single item', () => {
expect($n(foldlz(sum)(_na([1])))).toBe(1);
expect($n(foldlz._(sum)._(_na([1])))).toBe(1);
});
it('folds several items', () => {
expect($n(foldlz(sum)(_na([1, 2])))).toBe(3);
expect($n(foldlz._(sum)._(_na([1, 2])))).toBe(3);
});
});
describe('foldr', () => {
it('folds Nil', () => {
expect($n(foldr(sum)(Zero)(_na([])))).toBe(0);
expect($n(foldr._(sum)._(Zero)._(_na([])))).toBe(0);
});
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', () => {
expect($n(foldr(sum)(Zero)(_na([1, 2])))).toBe(3);
expect($n(foldr._(sum)._(Zero)._(_na([1, 2])))).toBe(3);
});
it('handles infinite lists', () => {
expect($n(
foldr
(_(x => _(a => sum(x)(iif(eqn(_n(5))(x))(Zero)(a)))))
(Zero)
(infinite)))
._(l('x', l('a', sum._('x')._(iif._(eqn._(_n(5))._('x'))._(Zero)._('a')))))
._(Zero)
._(infinite)))
.toBe(15);
});
});
describe('foldrz', () => {
it('does not fold Nil', () => {
expect(() => $n(foldrz(sum)(Nil))).toThrow();
expect(() => $n(foldrz._(sum)._(Nil))).toThrow();
});
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', () => {
expect($n(foldrz(sum)(_na([1, 2])))).toBe(3);
expect($n(foldrz._(sum)._(_na([1, 2])))).toBe(3);
});
it.failing('handles infinite lists', () => {
expect($n(
foldrz
(_(x => _(a => sum(x)(iif(eqn(_n(5))(x))(Zero)(a)))))
(infinite)))
._(l('x', l('a', sum._('x')._(iif._(eqn._(_n(5))._('x'))._(Zero)._('a')))))
._(infinite)))
.toBe(15);
});
});
describe('cmp', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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)._(_na([0, 1, 2]))._(infinite))).toEqual(NOrd.LT);
expect($o(cmp._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(NOrd.GT);
});
});
describe('lt', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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)._(_na([0, 1, 2]))._(infinite))).toEqual(true);
expect($b(lt._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(false);
});
});
describe('le', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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)._(_na([0, 1, 2]))._(infinite))).toEqual(true);
expect($b(le._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(false);
});
});
describe('eq', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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)._(_na([0, 1, 2]))._(infinite))).toEqual(false);
expect($b(eq._(eqn)._(infinite)._(_na([0, 1, 2])))).toEqual(false);
});
});
describe('ge', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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)._(_na([0, 1, 2]))._(infinite))).toEqual(false);
expect($b(ge._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(true);
});
});
describe('gt', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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)._(_na([0, 1, 2]))._(infinite))).toEqual(false);
expect($b(gt._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(true);
});
});
describe('map', () => {
it('maps Nil', () => {
expect($na(map(succ)(_na([])))).toEqual([]);
expect($na(map._(succ)._(_na([])))).toEqual([]);
});
it('maps only item', () => {
expect($na(map(succ)(_na([0])))).toEqual([1]);
expect($na(map._(succ)._(_na([0])))).toEqual([1]);
});
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', () => {
expect($n(head(map(succ)(infinite)))).toBe(1);
expect($n(head._(map._(succ)._(infinite)))).toBe(1);
});
});
describe('filter', () => {
it('filter Nil', () => {
expect($na(filter(odd)(_na([])))).toEqual([]);
expect($na(filter._(odd)._(_na([])))).toEqual([]);
});
it('filters only item', () => {
expect($na(filter(odd)(_na([])))).toEqual([]);
expect($na(filter._(odd)._(_na([])))).toEqual([]);
});
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', () => {
expect($n(head(filter(odd)(infinite)))).toBe(1);
expect($n(head._(filter._(odd)._(infinite)))).toBe(1);
});
});
describe('any', () => {
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', () => {
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', () => {
expect($b(any(odd)(_na([0, 1, 2])))).toEqual(true);
expect($b(any._(odd)._(_na([0, 1, 2])))).toEqual(true);
});
it('handles infinite lists', () => {
expect($b(any(odd)(infinite))).toEqual(true);
expect($b(any._(odd)._(infinite))).toEqual(true);
});
});
describe('all', () => {
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', () => {
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', () => {
expect($b(all(even)(_na([0, 2])))).toEqual(true);
expect($b(all._(even)._(_na([0, 2])))).toEqual(true);
});
it('handles infinite lists', () => {
expect($b(all(even)(infinite))).toEqual(false);
expect($b(all._(even)._(infinite))).toEqual(false);
});
});
describe('get', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
expect($n(get(_n(4))(infinite))).toBe(4);
expect($n(get._(_n(4))._(infinite))).toBe(4);
});
});
describe('set', () => {
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', () => {
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]', () => {
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]', () => {
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]', () => {
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]', () => {
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', () => {
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', () => {
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', () => {
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]', () => {
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]', () => {
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]', () => {
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]', () => {
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', () => {
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', () => {
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]', () => {
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]', () => {
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', () => {
expect($n(head(intersperse(_n(0))(infinite)))).toBe(0);
expect($n(head._(intersperse._(_n(0))._(infinite)))).toBe(0);
});
});
describe('show', () => {
it('show Nil is "[]"', () => {
expect($s(show(nshow)(_na([])))).toBe('[]');
expect($s(show._(nshow)._(_na([])))).toBe('[]');
});
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]"', () => {
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', () => {
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 { undef, y } from '../src/core';
import { Term, d, g, m, undef } from '../src/core';
import { toNOrd as $o, NOrd } from '../src/ord';
import { toBoolean as $b, fromBoolean as _b } from '../src/bool';
import { toNumber as $n, Num, Succ, Zero, fromNumber as _n, cmp, div, eq, ge, gt, ifz, le, lt, mod, mul, pred, show, sub, succ, sum } from '../src/num';
import { 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 { show } from '../src/num.show';
m('num.spec');
describe('Num', () => {
const infinity: Num = y(() => Succ(infinity));
const infinity: Term = g('infinity', d(bs => Succ._(bs['num.spec::infinity'])));
describe('toNumber', () => {
it('converts 0', () => {
@ -14,11 +17,11 @@ describe('Num', () => {
});
it('converts 1', () => {
expect($n(Succ(Zero))).toBe(1);
expect($n(Succ._(Zero))).toBe(1);
});
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', () => {
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', () => {
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', () => {
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', () => {
expect($b(ifz(infinity)(_b(true))(_b(false)))).toBe(false);
expect($b(ifz._(infinity)._(_b(true))._(_b(false)))).toBe(false);
});
});
describe('succ', () => {
it('succ 0 is 1', () => {
expect($n(succ(_n(0)))).toBe(1);
expect($n(succ._(_n(0)))).toBe(1);
});
it('succ 1 is 2', () => {
expect($n(succ(_n(1)))).toBe(2);
expect($n(succ._(_n(1)))).toBe(2);
});
it('succ 10 is 11', () => {
expect($n(succ(_n(10)))).toBe(11);
expect($n(succ._(_n(10)))).toBe(11);
});
});
describe('pred', () => {
it('pred 0 is 0', () => {
expect($n(pred(_n(0)))).toBe(0);
expect($n(pred._(_n(0)))).toBe(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', () => {
expect($n(pred(_n(10)))).toBe(9);
expect($n(pred._(_n(10)))).toBe(9);
});
});
describe('cmp', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
expect($o(cmp(_n(7))(_n(3)))).toBe(NOrd.GT);
expect($o(cmp._(_n(7))._(_n(3)))).toBe(NOrd.GT);
});
it('handles infinity', () => {
expect($o(cmp(_n(7))(infinity))).toBe(NOrd.LT);
expect($o(cmp(infinity)(_n(7)))).toBe(NOrd.GT);
expect($o(cmp._(_n(7))._(infinity))).toBe(NOrd.LT);
expect($o(cmp._(infinity)._(_n(7)))).toBe(NOrd.GT);
});
});
describe('lt', () => {
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', () => {
expect($b(lt(_n(0))(_n(1)))).toBe(true);
expect($b(lt._(_n(0))._(_n(1)))).toBe(true);
});
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', () => {
expect($b(lt(_n(3))(_n(3)))).toBe(false);
expect($b(lt._(_n(3))._(_n(3)))).toBe(false);
});
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', () => {
expect($b(lt(_n(7))(_n(3)))).toBe(false);
expect($b(lt._(_n(7))._(_n(3)))).toBe(false);
});
it('handles infinity', () => {
expect($b(lt(_n(7))(infinity))).toBe(true);
expect($b(lt(infinity)(_n(7)))).toBe(false);
expect($b(lt._(_n(7))._(infinity))).toBe(true);
expect($b(lt._(infinity)._(_n(7)))).toBe(false);
});
});
describe('le', () => {
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', () => {
expect($b(le(_n(0))(_n(1)))).toBe(true);
expect($b(le._(_n(0))._(_n(1)))).toBe(true);
});
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', () => {
expect($b(le(_n(3))(_n(3)))).toBe(true);
expect($b(le._(_n(3))._(_n(3)))).toBe(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', () => {
expect($b(le(_n(7))(_n(3)))).toBe(false);
expect($b(le._(_n(7))._(_n(3)))).toBe(false);
});
it('handles infinity', () => {
expect($b(le(_n(7))(infinity))).toBe(true);
expect($b(le(infinity)(_n(7)))).toBe(false);
expect($b(le._(_n(7))._(infinity))).toBe(true);
expect($b(le._(infinity)._(_n(7)))).toBe(false);
});
});
describe('eq', () => {
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', () => {
expect($b(eq(_n(0))(_n(1)))).toBe(false);
expect($b(eq._(_n(0))._(_n(1)))).toBe(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', () => {
expect($b(eq(_n(3))(_n(3)))).toBe(true);
expect($b(eq._(_n(3))._(_n(3)))).toBe(true);
});
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', () => {
expect($b(eq(_n(7))(_n(3)))).toBe(false);
expect($b(eq._(_n(7))._(_n(3)))).toBe(false);
});
it('handles infinity', () => {
expect($b(eq(_n(7))(infinity))).toBe(false);
expect($b(eq(infinity)(_n(7)))).toBe(false);
expect($b(eq._(_n(7))._(infinity))).toBe(false);
expect($b(eq._(infinity)._(_n(7)))).toBe(false);
});
});
describe('ge', () => {
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', () => {
expect($b(ge(_n(0))(_n(1)))).toBe(false);
expect($b(ge._(_n(0))._(_n(1)))).toBe(false);
});
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', () => {
expect($b(ge(_n(3))(_n(3)))).toBe(true);
expect($b(ge._(_n(3))._(_n(3)))).toBe(true);
});
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', () => {
expect($b(ge(_n(7))(_n(3)))).toBe(true);
expect($b(ge._(_n(7))._(_n(3)))).toBe(true);
});
it('handles infinity', () => {
expect($b(ge(_n(7))(infinity))).toBe(false);
expect($b(ge(infinity)(_n(7)))).toBe(true);
expect($b(ge._(_n(7))._(infinity))).toBe(false);
expect($b(ge._(infinity)._(_n(7)))).toBe(true);
});
});
describe('gt', () => {
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', () => {
expect($b(gt(_n(0))(_n(1)))).toBe(false);
expect($b(gt._(_n(0))._(_n(1)))).toBe(false);
});
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', () => {
expect($b(gt(_n(3))(_n(3)))).toBe(false);
expect($b(gt._(_n(3))._(_n(3)))).toBe(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', () => {
expect($b(gt(_n(7))(_n(3)))).toBe(true);
expect($b(gt._(_n(7))._(_n(3)))).toBe(true);
});
it('handles infinity', () => {
expect($b(gt(_n(7))(infinity))).toBe(false);
expect($b(gt(infinity)(_n(7)))).toBe(true);
expect($b(gt._(_n(7))._(infinity))).toBe(false);
expect($b(gt._(infinity)._(_n(7)))).toBe(true);
});
});
describe('sum', () => {
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', () => {
expect($n(sum(_n(0))(_n(1)))).toBe(1);
expect($n(sum._(_n(0))._(_n(1)))).toBe(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', () => {
expect($n(sum(_n(3))(_n(4)))).toBe(7);
expect($n(sum._(_n(3))._(_n(4)))).toBe(7);
});
});
describe('sub', () => {
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', () => {
expect($n(sub(_n(0))(_n(1)))).toBe(0);
expect($n(sub._(_n(0))._(_n(1)))).toBe(0);
});
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', () => {
expect($n(sub(_n(7))(_n(4)))).toBe(3);
expect($n(sub._(_n(7))._(_n(4)))).toBe(3);
});
});
describe('mul', () => {
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', () => {
expect($n(mul(_n(0))(_n(10)))).toBe(0);
expect($n(mul._(_n(0))._(_n(10)))).toBe(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', () => {
expect($n(mul(_n(1))(_n(10)))).toBe(10);
expect($n(mul._(_n(1))._(_n(10)))).toBe(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', () => {
expect($n(mul(_n(3))(_n(4)))).toBe(12);
expect($n(mul._(_n(3))._(_n(4)))).toBe(12);
});
it('0 mul ignores second argument', () => {
expect($n(mul(_n(0))(undef))).toBe(0);
expect($n(mul._(_n(0))._(undef))).toBe(0);
});
});
describe('div', () => {
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', () => {
expect($n(div(_n(1))(_n(10)))).toBe(0);
expect($n(div._(_n(1))._(_n(10)))).toBe(0);
});
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', () => {
expect($n(div(_n(10))(_n(5)))).toBe(2);
expect($n(div._(_n(10))._(_n(5)))).toBe(2);
});
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', () => {
expect($n(div(_n(0))(undef))).toBe(0);
expect($n(div._(_n(0))._(undef))).toBe(0);
});
});
describe('mod', () => {
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', () => {
expect($n(mod(_n(1))(_n(10)))).toBe(1);
expect($n(mod._(_n(1))._(_n(10)))).toBe(1);
});
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', () => {
expect($n(mod(_n(10))(_n(5)))).toBe(0);
expect($n(mod._(_n(10))._(_n(5)))).toBe(0);
});
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', () => {
expect($n(mod(_n(0))(undef))).toBe(0);
expect($n(mod._(_n(0))._(undef))).toBe(0);
});
});
describe('show', () => {
it('show 0 is "0"', () => {
expect($s(show(_n(0)))).toBe('0');
expect($s(show._(_n(0)))).toBe('0');
});
it('show 1 is "1"', () => {
expect($s(show(_n(1)))).toBe('1');
expect($s(show._(_n(1)))).toBe('1');
});
it('show 255 is "255"', () => {
expect($s(show(_n(255)))).toBe('255');
expect($s(show._(_n(255)))).toBe('255');
});
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 { undef } from '../src/core';
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 { toNumber as $n, fromNumber as _n, cmp as ncmp, eq as neq, show as nshow, succ } from '../src/num';
import { Pair, both, cmp, eq, first, fst, ge, gt, le, lt, second, show, snd } from '../src/pair';
import { toString as $s } from '../src/string';
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, succ } from '../src/num';
import { Pair, both, cmp, eq, first, fst, ge, gt, le, lt, second, snd } from '../src/pair';
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('fst', () => {
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', () => {
expect($b(fst(Pair(_b(false))(undef)))).toBe(false);
expect($b(fst._(Pair._(_b(false))._(undef)))).toBe(false);
});
});
describe('snd', () => {
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', () => {
expect($n(snd(Pair(undef)(_n(0))))).toBe(0);
expect($n(snd._(Pair._(undef)._(_n(0))))).toBe(0);
});
});
describe('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', () => {
expect($b(fst(first(not)(Pair(_b(false))(undef))))).toBe(true);
expect($b(fst._(first._(not)._(Pair._(_b(false))._(undef))))).toBe(true);
});
});
describe('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', () => {
expect($n(snd(second(succ)(Pair(undef)(_n(0)))))).toBe(1);
expect($n(snd._(second._(succ)._(Pair._(undef)._(_n(0)))))).toBe(1);
});
});
describe('both', () => {
it('updates both', () => {
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($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);
});
});
describe('cmp', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
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)"', () => {
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)"', () => {
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)"', () => {
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 { _, undef, y } from '../src/core';
import { Term, _, g, l, m, undef } from '../src/core';
import { NOrd, toNOrd } from '../src/ord';
import { toBoolean as $b } from '../src/bool';
import { toNumber as $n, Zero, gt as ngt } from '../src/num';
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', () => {
const infinite: String = Cons(_c('a'))(y(() => infinite));
const infinite: Term = g('infinite', Cons._(_c('a'))._('string.spec::infinite'));
describe('toString', () => {
it('converts ""', () => {
@ -15,11 +18,11 @@ describe('String', () => {
});
it('converts "a"', () => {
expect($s(Cons(_c('a'))(Empty))).toBe('a');
expect($s(Cons._(_c('a'))._(Empty))).toBe('a');
});
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(
// repeat(_s('a'))<String>(_((x0: Char) => _((x1s: 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(
// iterate(_s('a'))<String>(_((x0: Char) => _((x1s: 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', () => {
it('empty "" is True', () => {
expect($b(empty(_s('')))).toEqual(true);
expect($b(empty._(_s('')))).toEqual(true);
});
it('empty "a" is False', () => {
expect($b(empty(_s('a')))).toEqual(false);
expect($b(empty._(_s('a')))).toEqual(false);
});
it('empty "ab" is False', () => {
expect($b(empty(_s('ab')))).toEqual(false);
expect($b(empty._(_s('ab')))).toEqual(false);
});
it('handles infinite lists', () => {
expect($b(empty(infinite))).toEqual(false);
expect($b(empty._(infinite))).toEqual(false);
});
});
describe('len', () => {
it('len "" is 0', () => {
expect($n(len(_s('')))).toEqual(0);
expect($n(len._(_s('')))).toEqual(0);
});
it('len "a" is 1', () => {
expect($n(len(_s('a')))).toEqual(1);
expect($n(len._(_s('a')))).toEqual(1);
});
it('len "ab" is 2', () => {
expect($n(len(_s('ab')))).toEqual(2);
expect($n(len._(_s('ab')))).toEqual(2);
});
it('handles infinite lists', () => {
expect($b(ngt(len(infinite))(Zero))).toEqual(true);
expect($b(ngt._(len._(infinite))._(Zero))).toEqual(true);
});
});
describe('append', () => {
it('"" append "" is ""', () => {
expect($s(append(Empty)(Empty))).toBe('');
expect($s(append._(Empty)._(Empty))).toBe('');
});
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"', () => {
expect($s(append(_s('abc'))(_s('def')))).toBe('abcdef');
expect($s(append._(_s('abc'))._(_s('def')))).toBe('abcdef');
});
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', () => {
it('"" wrap "" is ""', () => {
expect($s(wrap(Empty)(Empty))).toBe('');
expect($s(wrap._(Empty)._(Empty))).toBe('');
});
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', () => {
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', () => {
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', () => {
expect(toNOrd(cmp(_s(''))(_s('abc')))).toEqual(NOrd.LT);
expect(toNOrd(cmp._(_s(''))._(_s('abc')))).toEqual(NOrd.LT);
});
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', () => {
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', () => {
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', () => {
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', () => {
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', () => {
expect(toNOrd(cmp(_s('abc'))(_s('abc')))).toEqual(NOrd.EQ);
expect(toNOrd(cmp._(_s('abc'))._(_s('abc')))).toEqual(NOrd.EQ);
});
it('handles infinite strings', () => {
expect(toNOrd(cmp(_s('abc'))(infinite))).toEqual(NOrd.GT);
expect(toNOrd(cmp(infinite)(_s('abc')))).toEqual(NOrd.LT);
expect(toNOrd(cmp._(_s('abc'))._(infinite))).toEqual(NOrd.GT);
expect(toNOrd(cmp._(infinite)._(_s('abc')))).toEqual(NOrd.LT);
});
});
describe('lt', () => {
it('"" lt "" is False', () => {
expect($b(lt(_s(''))(_s('')))).toEqual(false);
expect($b(lt._(_s(''))._(_s('')))).toEqual(false);
});
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', () => {
expect($b(lt(_s('abc'))(_s('')))).toEqual(false);
expect($b(lt._(_s('abc'))._(_s('')))).toEqual(false);
});
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', () => {
expect($b(lt(_s('abc'))(_s('a')))).toEqual(false);
expect($b(lt._(_s('abc'))._(_s('a')))).toEqual(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', () => {
expect($b(lt(_s('abc'))(_s('bca')))).toEqual(true);
expect($b(lt._(_s('abc'))._(_s('bca')))).toEqual(true);
});
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', () => {
expect($b(lt(_s('abc'))(infinite))).toEqual(false);
expect($b(lt(infinite)(_s('abc')))).toEqual(true);
expect($b(lt._(_s('abc'))._(infinite))).toEqual(false);
expect($b(lt._(infinite)._(_s('abc')))).toEqual(true);
});
});
describe('le', () => {
it('"" le "" is True', () => {
expect($b(le(_s(''))(_s('')))).toEqual(true);
expect($b(le._(_s(''))._(_s('')))).toEqual(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', () => {
expect($b(le(_s('abc'))(_s('')))).toEqual(false);
expect($b(le._(_s('abc'))._(_s('')))).toEqual(false);
});
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', () => {
expect($b(le(_s('abc'))(_s('a')))).toEqual(false);
expect($b(le._(_s('abc'))._(_s('a')))).toEqual(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', () => {
expect($b(le(_s('abc'))(_s('bca')))).toEqual(true);
expect($b(le._(_s('abc'))._(_s('bca')))).toEqual(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', () => {
expect($b(le(_s('abc'))(infinite))).toEqual(false);
expect($b(le(infinite)(_s('abc')))).toEqual(true);
expect($b(le._(_s('abc'))._(infinite))).toEqual(false);
expect($b(le._(infinite)._(_s('abc')))).toEqual(true);
});
});
describe('eq', () => {
it('"" eq "" is True', () => {
expect($b(eq(_s(''))(_s('')))).toEqual(true);
expect($b(eq._(_s(''))._(_s('')))).toEqual(true);
});
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', () => {
expect($b(eq(_s('abc'))(_s('')))).toEqual(false);
expect($b(eq._(_s('abc'))._(_s('')))).toEqual(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', () => {
expect($b(eq(_s('abc'))(_s('a')))).toEqual(false);
expect($b(eq._(_s('abc'))._(_s('a')))).toEqual(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', () => {
expect($b(eq(_s('abc'))(_s('bca')))).toEqual(false);
expect($b(eq._(_s('abc'))._(_s('bca')))).toEqual(false);
});
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', () => {
expect($b(eq(_s('abc'))(infinite))).toEqual(false);
expect($b(eq(infinite)(_s('abc')))).toEqual(false);
expect($b(eq._(_s('abc'))._(infinite))).toEqual(false);
expect($b(eq._(infinite)._(_s('abc')))).toEqual(false);
});
});
describe('ge', () => {
it('"" ge "" is True', () => {
expect($b(ge(_s(''))(_s('')))).toEqual(true);
expect($b(ge._(_s(''))._(_s('')))).toEqual(true);
});
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', () => {
expect($b(ge(_s('abc'))(_s('')))).toEqual(true);
expect($b(ge._(_s('abc'))._(_s('')))).toEqual(true);
});
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', () => {
expect($b(ge(_s('abc'))(_s('a')))).toEqual(true);
expect($b(ge._(_s('abc'))._(_s('a')))).toEqual(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', () => {
expect($b(ge(_s('abc'))(_s('bca')))).toEqual(false);
expect($b(ge._(_s('abc'))._(_s('bca')))).toEqual(false);
});
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', () => {
expect($b(ge(_s('abc'))(infinite))).toEqual(true);
expect($b(ge(infinite)(_s('abc')))).toEqual(false);
expect($b(ge._(_s('abc'))._(infinite))).toEqual(true);
expect($b(ge._(infinite)._(_s('abc')))).toEqual(false);
});
});
describe('gt', () => {
it('"" gt "" is False', () => {
expect($b(gt(_s(''))(_s('')))).toEqual(false);
expect($b(gt._(_s(''))._(_s('')))).toEqual(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', () => {
expect($b(gt(_s('abc'))(_s('')))).toEqual(true);
expect($b(gt._(_s('abc'))._(_s('')))).toEqual(true);
});
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', () => {
expect($b(gt(_s('abc'))(_s('a')))).toEqual(true);
expect($b(gt._(_s('abc'))._(_s('a')))).toEqual(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', () => {
expect($b(gt(_s('abc'))(_s('bca')))).toEqual(false);
expect($b(gt._(_s('abc'))._(_s('bca')))).toEqual(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', () => {
expect($b(gt(_s('abc'))(infinite))).toEqual(true);
expect($b(gt(infinite)(_s('abc')))).toEqual(false);
expect($b(gt._(_s('abc'))._(infinite))).toEqual(true);
expect($b(gt._(infinite)._(_s('abc')))).toEqual(false);
});
});
describe('show', () => {
it('show "" is """"', () => {
expect($s(show(_s('')))).toBe('""');
expect($s(show._(_s('')))).toBe('""');
});
it('show "a" is ""a""', () => {
expect($s(show(_s('a')))).toBe('"a"');
expect($s(show._(_s('a')))).toBe('"a"');
});
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",
"include": [
"../src/**/*.ts",
"**/*.ts",
],
}

Write Preview
Loading…
Cancel
Save