From df0dc199a05d703847276c10b79153a813ada702 Mon Sep 17 00:00:00 2001 From: Freywar Ulvnaudgari Date: Tue, 20 Aug 2024 21:43:33 +0300 Subject: [PATCH] Custom engine --- eslint.config.mjs | 2 + src/bf.ts | 98 +++++-------- src/bool.show.ts | 7 + src/bool.ts | 55 +++---- src/byte.show.ts | 5 + src/byte.ts | 35 ++--- src/char.show.ts | 7 + src/char.ts | 19 +-- src/core.ts | 251 +++++++++++++++++++++++++++++--- src/debug.ts | 38 ++++- src/index.ts | 19 ++- src/list.show.ts | 7 + src/list.ts | 210 +++++++++----------------- src/log.ts | 7 + src/num.show.ts | 8 + src/num.ts | 74 +++------- src/ord.show.ts | 6 + src/ord.ts | 33 ++--- src/pair.show.ts | 8 + src/pair.ts | 86 +++-------- src/string.show.ts | 7 + src/string.ts | 45 +++--- test/bf.spec.ts | 20 +-- test/bool.spec.ts | 103 ++++++------- test/byte.spec.ts | 211 ++++++++++++++------------- test/char.spec.ts | 81 ++++++----- test/core.spec.ts | 8 +- test/list.spec.ts | 348 ++++++++++++++++++++++---------------------- test/num.spec.ts | 191 ++++++++++++------------ test/pair.spec.ts | 111 +++++++------- test/string.spec.ts | 173 +++++++++++----------- test/tsconfig.json | 1 + 32 files changed, 1181 insertions(+), 1093 deletions(-) create mode 100644 src/bool.show.ts create mode 100644 src/byte.show.ts create mode 100644 src/char.show.ts create mode 100644 src/list.show.ts create mode 100644 src/log.ts create mode 100644 src/num.show.ts create mode 100644 src/ord.show.ts create mode 100644 src/pair.show.ts create mode 100644 src/string.show.ts diff --git a/eslint.config.mjs b/eslint.config.mjs index a166a5a..79040ef 100644 --- a/eslint.config.mjs +++ b/eslint.config.mjs @@ -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', { diff --git a/src/bf.ts b/src/bf.ts index f19d4e7..6f303b3 100644 --- a/src/bf.ts +++ b/src/bf.ts @@ -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, String>; +m('bf'); -type Tape = Pair>; +const done = g('done', uncurry._(l('p', cnst._(uncurry._(l('is', l('cs', ge._(head._('is'))._(len._('cs')))))._('p'))))); -type IO = Pair; +const command = g('command', l('c', uncurry._(l('p', cnst._(eq._('c')._(uncurry._(pipe._(get)._(head))._('p'))))))); -type State = Pair>; +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(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)))))))))); diff --git a/src/bool.show.ts b/src/bool.show.ts new file mode 100644 index 0000000..92f0589 --- /dev/null +++ b/src/bool.show.ts @@ -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')))); diff --git a/src/bool.ts b/src/bool.ts index 2d93130..07dc1e5 100644 --- a/src/bool.ts +++ b/src/bool.ts @@ -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: 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<(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()); diff --git a/src/byte.show.ts b/src/byte.show.ts new file mode 100644 index 0000000..4c41d45 --- /dev/null +++ b/src/byte.show.ts @@ -0,0 +1,5 @@ +import { m } from './core'; + +m('byte.show'); + +export { show } from './num.show'; diff --git a/src/byte.ts b/src/byte.ts index c12179f..917535b 100644 --- a/src/byte.ts +++ b/src/byte.ts @@ -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); diff --git a/src/char.show.ts b/src/char.show.ts new file mode 100644 index 0000000..65abc98 --- /dev/null +++ b/src/char.show.ts @@ -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'))); diff --git a/src/char.ts b/src/char.ts index 173a809..45fd104 100644 --- a/src/char.ts +++ b/src/char.ts @@ -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)); diff --git a/src/core.ts b/src/core.ts index 4687634..a120f35 100644 --- a/src/core.ts +++ b/src/core.ts @@ -1,29 +1,236 @@ -type F = (v: L) => L; +import { withLog } from './debug'; -export type L = T & { run: () => T }; +let index = 0; -const defer: (run: () => T) => L = (run: () => T) => - Object.assign(((p: Parameters[0]): ReturnType => { - 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 _ = (v: T): L => defer(() => v); + public constructor(protected bindings: Record) { } -export const fromNative: (v: T) => L - = v => defer(() => v as any); -export const toNative: (v: L) => T - = (v: L) => v.run() as T; + public refs(_name: string): boolean { + return false; + }; -export const y = (f: () => L) => 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<(v: T) => T> - = _(v => v); -export const cnst: L<(v: T) => L<(_: unknown) => T>> - = _(v => _(_ => v)) as L<(v: T) => L<(_: unknown) => T>>; -export const pipe: L<(f: L<(v: B) => C>) => L<(g: L<(v: A) => B>) => L<(v: A) => C>>> - = _((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) => Term, + bindings: Record = {}, + ) { 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 = {}, + ) { 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 = {}, + ) { 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 = {}, + ) { 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 = {}; + +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((f: Call, a: RefTerm) => new Call(f, termify(a)), new Call(termify(func), termify(arg))); +export const d = (func: (bindings: Record) => Term) => new Deferred(func); + +export const $ = (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')))))); diff --git a/src/debug.ts b/src/debug.ts index c742f48..7e77a5c 100644 --- a/src/debug.ts +++ b/src/debug.ts @@ -1,8 +1,30 @@ -import { L, _ } from './core'; -import { String, toString } from './string'; - -export const log: 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(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')); +} diff --git a/src/index.ts b/src/index.ts index 04f5982..9118601 100644 --- a/src/index.ts +++ b/src/index.ts @@ -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(); +} diff --git a/src/list.show.ts b/src/list.show.ts new file mode 100644 index 0000000..d12d820 --- /dev/null +++ b/src/list.show.ts @@ -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(']')))))); diff --git a/src/list.ts b/src/list.ts index ec7be7b..4fede68 100644 --- a/src/list.ts +++ b/src/list.ts @@ -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 = L<(z: R) => L<(f: L<(x: T) => L<(xs: List) => R>>) => R>>; - -export const Nil: List - = _(z => _(_f => z)) as List; - -export const Cons: L<(x: T) => L<(xs: List) => List>> - = _((x: T) => _((xs: List) => _(_z => _(f => f(x)(xs))) as List)); - -export const cons: L<(x: T) => L<(xs: List) => List>> - = Cons; - -export const snoc: L<(xs: List) => L<(x: T) => List>> - = _((xs: List) => - _((x: T) => xs(cons(x)(Nil))(_(y => _(ys => cons(y)(snoc(ys)(x))))))); - -export const nul: L<(xs: List) => Bool> - = _(xs => xs(True)(cnst(cnst(False)))); - -export const len: L<(xs: List) => Num> - = _(xs => xs(Zero)(cnst(pipe(succ)(len)))); - -export const singleton: L<(v: T) => List> - = _(x => cons(x)(Nil)); - -export const append: L<(l: List) => L<(r: List) => List>> - = _(l => _(r => l(r)(_(x => _(xs => cons(x)(append(xs)(r))))))); - -export const concat: L<(ls: List>) => List> - = _(ls => ls(Nil)(_(x => pipe(append(x))(concat)))); - -export const repeat: L<(x: T) => List> - = _(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<(f: L<(x: T) => T>) => L<(x: T) => List>> - = _((f: L<(x: T) => T>) => _((x: T) => cons(x)(iterate(f)(f(x))))); +m('list'); -export const head: L<(xs: List) => T> - = _(xs => xs(undef)(cnst)); - -export const tail: L<(xs: List) => List> - = _(xs => xs(undef)(cnst(id))); - -export const foldl: L<(f: L<(a: R) => L<(x: T) => R>>) => L<(z: R) => L<(xs: List) => R>>> - = _((f: L<(a: R) => L<(x: T) => R>>) => - _((z: R) => - _((xs: List) => xs(z)(pipe(foldl(f))(f(z)))))); - -export const foldlz: L<(f: L<(a: T) => L<(x: T) => T>>) => L<(xs: List) => T>> - = _((f: L<(a: T) => L<(x: T) => T>>) => _((xs: List) => xs(undef)(foldl(f)))); - -export const foldr: L<(f: L<(x: T) => L<(a: R) => R>>) => L<(z: R) => L<(xs: List) => R>>> - = _((f: L<(x: T) => L<(a: R) => R>>) => - _((z: R) => - _((xs: List) => xs(z)(_(x => pipe(f(x))(foldr(f)(z))))))); - -export const foldrz: L<(f: L<(x: T) => L<(a: T) => T>>) => L<(xs: List) => T>> - = undef; - -export const cmp: L<(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List) => L<(r: List) => Ord>>> - = _((ecmp: L<(l: T) => L<(r: T) => Ord>>) => - _((l: List) => - _((r: List) => 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<(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List) => L<(r: List) => Bool>>> - = _((ecmp: L<(l: T) => L<(r: T) => Ord>>) => - _((l: List) => - _((r: List) => - r(False)(_(rx => _(rxs => l(True)(_(lx => _(lxs => ecmp(lx)(rx)(True)(lt(ecmp)(lxs)(rxs))(False)))))))))); - -export const le: L<(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List) => L<(r: List) => Bool>>> - = _((ecmp: L<(l: T) => L<(r: T) => Ord>>) => - _((l: List) => - _((r: List) => - l(True)(_(lx => _(lxs => r(False)(_(rx => _(rxs => ecmp(lx)(rx)(True)(le(ecmp)(lxs)(rxs))(False)))))))))); - -export const eq: L<(eeq: L<(l: T) => L <(r: T) => Bool>>) => L<(l: List) => L<(r: List) => Bool>>> - = _((eeq: L<(l: T) => L<(r: T) => Bool>>) => - _((l: List) => - _((r: List) => l - (r(True)(cnst(cnst(False)))) - (_(lx => _(lxs => r(False)(_(rx => _(rxs => and(eeq(lx)(rx))(eq(eeq)(lxs)(rxs))))))))))); - -export const ge: L<(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List) => L<(r: List) => Bool>>> - = _((ecmp: L<(l: T) => L<(r: T) => Ord>>) => - _((l: List) => - _((r: List) => - r(True)(_(rx => _(rxs => l(False)(_(lx => _(lxs => ecmp(lx)(rx)(False)(ge(ecmp)(lxs)(rxs))(True)))))))))); - -export const gt: L<(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List) => L<(r: List) => Bool>>> - = _((ecmp: L<(l: T) => L<(r: T) => Ord>>) => - _((l: List) => - _((r: List) => - 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<(f: L<(x: T) => R>) => L<(xs: List) => List>> - = _((f: L<(x: T) => R>) => - _((xs: List) => xs(Nil)(_(x => pipe(cons(f(x)))(map(f)))))); - -export const filter: L<(f: L<(x: T) => Bool>) => L<(xs: List) => List>> - = _((f: L<(x: T) => Bool>) => - _((xs: List) => xs(Nil)(_(x => pipe(iif(f(x))(cons(x))(id))(filter(f)))))); - -export const any: L<(f: L<(x: T) => Bool>) => L<(xs: List) => Bool>> - = _((f: L<(x: T) => Bool>) => - _((xs: List) => xs(False)(_(x => pipe(or(f(x)))(any(f)))))); - -export const all: L<(f: L<(x: T) => Bool>) => L<(xs: List) => Bool>> - = _((f: L<(x: T) => Bool>) => - _((xs: List) => xs(True)(_(x => pipe(and(f(x)))(all(f)))))); - -export const get: L<(i: Num) => L<(xs: List) => T>> - = _(i => _(xs => xs(undef)(_(x => i(cnst(x))(get))))); - -export const update: L<(f: L< (p: T) => T>) => L<(i: Num) => L<(xs: List) => List>>> - = _((f: L< (p: T) => T>) => - _((i: Num) => - _((xs: List) => - xs(undef)(_(x => _(xs => i(cons(f(x))(xs))(_(pi => cons(x)(update(f)(pi)(xs)))))))))); - -export const set: L<(v: T) => L<(i: Num) => L<(xs: List) => List>>> - = pipe(update)(cnst); - -export const intersperse: L<(v: T) => L<(xs: List) => List>> - = _(v => _(xs => xs(xs)(_(x => _(rxs => rxs(xs)(cnst(cnst(cons(x)(cons(v)(intersperse(v)(rxs))))))))))); - -export const show: L<(eshow: L<(e: T) => String>) => L<(xs: List) => String>> - = _(eshow => _(xs => concat(snoc(cons(_s('['))(intersperse(_s(', '))(map(eshow)(xs))))(_s(']'))))); - -export const fromArray: (xs: T[]) => List - = xs => xs.length === 0 ? Nil : cons(xs[0])(y(() => fromArray(xs.slice(1)))); - -export const toArray: (xs: List) => 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'])])))))); diff --git a/src/log.ts b/src/log.ts new file mode 100644 index 0000000..a3e8bbc --- /dev/null +++ b/src/log.ts @@ -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']; +}))); diff --git a/src/num.show.ts b/src/num.show.ts new file mode 100644 index 0000000..06bef97 --- /dev/null +++ b/src/num.show.ts @@ -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))))))); diff --git a/src/num.ts b/src/num.ts index 363046e..d6b6d94 100644 --- a/src/num.ts +++ b/src/num.ts @@ -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<(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<(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'])))))); diff --git a/src/ord.show.ts b/src/ord.show.ts new file mode 100644 index 0000000..204cd1f --- /dev/null +++ b/src/ord.show.ts @@ -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')))); diff --git a/src/ord.ts b/src/ord.ts index 6e39e8e..2cdceed 100644 --- a/src/ord.ts +++ b/src/ord.ts @@ -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<(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()); diff --git a/src/pair.show.ts b/src/pair.show.ts new file mode 100644 index 0000000..92719a5 --- /dev/null +++ b/src/pair.show.ts @@ -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)))))))))))); diff --git a/src/pair.ts b/src/pair.ts index 01657e4..9df0f3e 100644 --- a/src/pair.ts +++ b/src/pair.ts @@ -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 = L<(f: L<(f: F) => L<(s: S) => R>>) => R>; +m('pair'); -export const Pair: L<(f: F) => L<(s: S) => Pair>> - = _((f: F) => - _((s: S) => - _((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<(p: Pair) => F> - = _(p => p(_(f => _(_s => f)))); +export const fst = g('fst', l('p', r('p')._(l('f', l('_', 'f'))))); -export const snd: L<(p: Pair) => S> - = _(p => p(_(_f => _(s => s)))); +export const snd = g('snd', l('p', r('p')._(l('_', l('s', 's'))))); -export const first: L<(t: L<(f: F) => FR>) => L<(p: Pair) => Pair>> - = _((t: L<(f: F) => FR>) => - _((p: Pair) => 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<(t: L<(s: S) => SR>) => L<(p: Pair) => Pair>> - = _((t: L<(s: S) => SR>) => - _((p: Pair) => 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<(tf: L<(f: F) => FR>) => L<(ts: L<(s: S) => SR>) => L<(p: Pair) => Pair>>> - = _((tf: L<(f: F) => FR>) => - _((ts: L<(s: S) => SR>) => - _((p: Pair) => 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<(t: L<(f: F) => L<(s: S) => R>>) => L<(p: Pair) => R>> - = _((t: L<(f: F) => L<(s: S) => R>>) => - _((p: Pair) => p(t))); +export const uncurry = g('uncurry', l('t', l('p', r('p')._('t')))); -export const cmp: L<(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Ord>>) => L<(l: Pair) => L<(r: Pair) => Ord>>>> - = _((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<(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair) => L<(r: Pair) => Bool>>>> - = _((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<(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair) => L<(r: Pair) => Bool>>>> - = _((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<(feq: L<(l: F) => L<(r: F) => Bool>>) => L<(seq: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair) => L<(r: Pair) => Bool>>>> - = _((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<(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair) => L<(r: Pair) => Bool>>>> - = _((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<(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair) => L<(r: Pair) => Bool>>>> - = _((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<(fshow: L<(f: F) => String>) => L<(sshow: L<(s: S) => String>) => L<(p: Pair) => String>>> - = _((fshow: L<(f: F) => String>) => - _((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)))))))))); diff --git a/src/string.show.ts b/src/string.show.ts new file mode 100644 index 0000000..c4795af --- /dev/null +++ b/src/string.show.ts @@ -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('"'))); diff --git a/src/string.ts b/src/string.ts index 2f5825c..690b83e 100644 --- a/src/string.ts +++ b/src/string.ts @@ -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; +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']))))))); diff --git a/test/bf.spec.ts b/test/bf.spec.ts index 227a38e..ae77ce8 100644 --- a/test/bf.spec.ts +++ b/test/bf.spec.ts @@ -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'); }); }); diff --git a/test/bool.spec.ts b/test/bool.spec.ts index 07d1adf..4af94a6 100644 --- a/test/bool.spec.ts +++ b/test/bool.spec.ts @@ -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'); }); }); }); diff --git a/test/byte.spec.ts b/test/byte.spec.ts index 9564190..99ffce6 100644 --- a/test/byte.spec.ts +++ b/test/byte.spec.ts @@ -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'); }); }); }); diff --git a/test/char.spec.ts b/test/char.spec.ts index 93f10f7..e55d307 100644 --- a/test/char.spec.ts +++ b/test/char.spec.ts @@ -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('\'-\''); }); }); }); diff --git a/test/core.spec.ts b/test/core.spec.ts index b16b9ec..cfe44d9 100644 --- a/test/core.spec.ts +++ b/test/core.spec.ts @@ -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'); }); }); diff --git a/test/list.spec.ts b/test/list.spec.ts index a2d25be..cf4041c 100644 --- a/test/list.spec.ts +++ b/test/list.spec.ts @@ -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 = iterate(Succ)(Zero); + const infinite: Term = g('infinite', iterate._(Succ)._(Zero)); - const _na: (xs: number[]) => List - = 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) => 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 = 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))>(_((x0: Num) => _((x1s: List) => - // x1s>(_((x1: Num) => _((x2s: List) => - // x2s>(_((x2: Num) => _((_xrs: List): List => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual([0, 0, 0]); + // repeat._(_n(0))>(l((x0: Num) => l((x1s: List) => + // x1s>(l((x1: Num) => l((x2s: List) => + // x2s>(l((x2: Num) => l((_xrs: List): List => 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))>(_((x0: Num) => _((x1s: List) => - // x1s>(_((x1: Num) => _((x2s: List) => - // x2s>(_((x2: Num) => _((_xrs: List): List => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual([0, 1, 2]); + // iterate._(_n(0))>(l((x0: Num) => l((x1s: List) => + // x1s>(l((x1: Num) => l((x2s: List) => + // x2s>(l((x2: Num) => l((_xrs: List): List => 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('['); }); }); }); diff --git a/test/num.spec.ts b/test/num.spec.ts index d586767..1e4aae8 100644 --- a/test/num.spec.ts +++ b/test/num.spec.ts @@ -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'); }); }); }); diff --git a/test/pair.spec.ts b/test/pair.spec.ts index d8823f9..a08e438 100644 --- a/test/pair.spec.ts +++ b/test/pair.spec.ts @@ -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)'); }); }); }); diff --git a/test/string.spec.ts b/test/string.spec.ts index f26c957..9de3fd0 100644 --- a/test/string.spec.ts +++ b/test/string.spec.ts @@ -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'))(_((x0: Char) => _((x1s: String) => // x1s(_((x1: Char) => _((x2s: String) => - // x2s(_((x2: Char) => _((_xrs: String): String => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual('aaa'); + // x2s(_((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'))(_((x0: Char) => _((x1s: String) => // x1s(_((x1: Char) => _((x2s: String) => - // x2s(_((x2: Char) => _((_xrs: String): String => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual('abc'); + // x2s(_((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"'); }); }); }); diff --git a/test/tsconfig.json b/test/tsconfig.json index 7c1c8cc..b7f5720 100644 --- a/test/tsconfig.json +++ b/test/tsconfig.json @@ -1,6 +1,7 @@ { "extends": "../tsconfig.json", "include": [ + "../src/**/*.ts", "**/*.ts", ], }