Custom engine

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',
         {

src/bf.ts

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

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'))));

src/bool.ts

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

src/byte.show.ts

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

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

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')));

src/char.ts

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

src/core.ts

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

src/debug.ts

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

src/index.ts

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

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(']'))))));

src/list.ts

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

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'];
+})));

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)))))));

src/num.ts

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

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'))));

src/ord.ts

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

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))))))))))));

src/pair.ts

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

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('"')));

src/string.ts

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

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');
     });
   });

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._(True)._(True)._(undef))).toBe(true);
-      expect($b(iif(False)(undef)(False))).toBe(false);
+      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');
     });
   });
 });

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(0))._(_b(true))._(undef))).toBe(true);
-      expect($b(ifz(_n(1))(undef)(_b(false)))).toBe(false);
+      expect($b(ifz._(_n(1))._(undef)._(_b(false)))).toBe(false);
     });
   });
 
   describe('inc', () => {
     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');
     });
   });
 });

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('\'-\'');
     });
   });
 });

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');
   });
 });
 

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<Num> = iterate(Succ)(Zero);
+  const infinite: Term = g('infinite', iterate._(Succ)._(Zero));
 
-  const _na: (xs: number[]) => List<Num>
+  const _na: (xs: number[]) => Term = xs => !xs.length ? Nil : Cons._(_n(xs[0]))._(d(() => _na(xs.slice(1))));
-    = xs => xs.length === 0 ? Nil : Cons(_nn(xs[0]))(y(() => _na(xs.slice(1))));
 
-  const $na: (xs: List<Num>) => number[]
+  const $na: (xs: Term) => number[] = xs => $(xs._(_([]))._(l('x', l('xs', d(bs => _([$n(bs['x']), ...$na(bs['xs'])]))))));
-    = xs => $$(xs(__([]))(_(x => _(xs => __([$nn(x), ...$na(xs)])))));
 
   describe('toArray', () => {
     it('converts []', () => {
@@ -22,11 +24,11 @@ describe('List', () => {
     });
 
     it('converts [0]', () => {
-      expect($a(Cons(_n(0))(Nil)).map($n)).toEqual([0]);
+      expect($a(Cons._(_n(0))._(Nil)).map($n)).toEqual([0]);
     });
 
     it('converts [0, 1]', () => {
-      expect($a(Cons(_n(0))(Cons(_n(1))(Nil))).map($n)).toEqual([0, 1]);
+      expect($a(Cons._(_n(0))._(Cons._(_n(1))._(Nil))).map($n)).toEqual([0, 1]);
     });
   });
 
@@ -46,679 +48,679 @@ describe('List', () => {
 
   describe('cons', () => {
     it('0 cons Nil is [0]', () => {
-      expect($na(cons(_n(0))(Nil))).toEqual([0]);
+      expect($na(cons._(_n(0))._(Nil))).toEqual([0]);
     });
 
     it('0 cons [1] is [0, 1]', () => {
-      expect($na(cons(_n(0))(_na([1])))).toEqual([0, 1]);
+      expect($na(cons._(_n(0))._(_na([1])))).toEqual([0, 1]);
     });
 
     it('0 cons [1, 2] is [0, 1, 2]', () => {
-      expect($na(cons(_n(0))(_na([1, 2])))).toEqual([0, 1, 2]);
+      expect($na(cons._(_n(0))._(_na([1, 2])))).toEqual([0, 1, 2]);
     });
 
     it('handles infinite lists', () => {
-      expect($n(cons(_n(0))(infinite)(undef)(_(x => _(_xs => x))))).toBe(0);
+      expect($n(cons._(_n(0))._(infinite)._(undef)._(l('x', l('_', 'x'))))).toBe(0);
     });
   });
 
   describe('snoc', () => {
     it('Nil snoc 0 is [0]', () => {
-      expect($na(snoc(Nil)(_n(0)))).toEqual([0]);
+      expect($na(snoc._(Nil)._(_n(0)))).toEqual([0]);
     });
 
     it('[1] snoc 0 is [1, 0]', () => {
-      expect($na(snoc(_na([1]))(_n(0)))).toEqual([1, 0]);
+      expect($na(snoc._(_na([1]))._(_n(0)))).toEqual([1, 0]);
     });
 
     it('[1, 2] snoc 0 is [1, 2, 0]', () => {
-      expect($na(snoc(_na([1, 2]))(_n(0)))).toEqual([1, 2, 0]);
+      expect($na(snoc._(_na([1, 2]))._(_n(0)))).toEqual([1, 2, 0]);
     });
 
     it('handles infinite lists', () => {
-      expect($n(snoc(infinite)(_n(0))(undef)(_(x => _(_xs => x))))).toBe(0);
+      expect($n(snoc._(infinite)._(_n(0))._(undef)._(l('x', l('_', 'x'))))).toBe(0);
     });
   });
 
   describe('nul', () => {
     it('nul Nil is True', () => {
-      expect($b(nul(_na([])))).toEqual(true);
+      expect($b(nul._(_na([])))).toEqual(true);
     });
 
     it('nul [1] is False', () => {
-      expect($b(nul(_na([1])))).toEqual(false);
+      expect($b(nul._(_na([1])))).toEqual(false);
     });
 
     it('nul [1, 2] is False', () => {
-      expect($b(nul(_na([1, 2])))).toEqual(false);
+      expect($b(nul._(_na([1, 2])))).toEqual(false);
     });
 
     it('handles infinite lists', () => {
-      expect($b(nul(infinite))).toEqual(false);
+      expect($b(nul._(infinite))).toEqual(false);
     });
   });
 
   describe('len', () => {
     it('len Nil is 0', () => {
-      expect($n(len(_na([])))).toEqual(0);
+      expect($n(len._(_na([])))).toEqual(0);
     });
 
     it('len [1] is 1', () => {
-      expect($n(len(_na([1])))).toEqual(1);
+      expect($n(len._(_na([1])))).toEqual(1);
     });
 
     it('len [1, 2] is 2', () => {
-      expect($n(len(_na([1, 2])))).toEqual(2);
+      expect($n(len._(_na([1, 2])))).toEqual(2);
     });
 
     it('handles infinite lists', () => {
-      expect($b(ngt(len(infinite))(Zero))).toEqual(true);
+      expect($b(ngt._(len._(infinite))._(Zero))).toEqual(true);
     });
 
     it('ignores items', () => {
-      expect($n(len(cons(undef)(cons(undef)(Nil))))).toEqual(2);
+      expect($n(len._(cons._(undef)._(cons._(undef)._(Nil))))).toEqual(2);
     });
   });
 
   describe('singleton', () => {
     it('singleton 0 is [0]', () => {
-      expect($na(singleton(_n(0)))).toEqual([0]);
+      expect($na(singleton._(_n(0)))).toEqual([0]);
     });
   });
 
   describe('append', () => {
     it('Nil append Nil is Nil', () => {
-      expect($na(append(Nil)(Nil))).toEqual([]);
+      expect($na(append._(Nil)._(Nil))).toEqual([]);
     });
 
     it('[0] append [1] is [0, 1]', () => {
-      expect($na(append(_na([0]))(_na([1])))).toEqual([0, 1]);
+      expect($na(append._(_na([0]))._(_na([1])))).toEqual([0, 1]);
     });
 
     it('[0, 1] append [2, 3] is [0, 1, 2, 3]', () => {
-      expect($na(append(_na([0, 1]))(_na([2, 3])))).toEqual([0, 1, 2, 3]);
+      expect($na(append._(_na([0, 1]))._(_na([2, 3])))).toEqual([0, 1, 2, 3]);
     });
 
     it('handles infinite lists', () => {
-      expect($n(append(infinite)(infinite)(undef)(_(x => _(_xs => x))))).toBe(0);
+      expect($n(append._(infinite)._(infinite)._(undef)._(l('x', l('_', 'x'))))).toBe(0);
     });
   });
 
   describe('concat', () => {
     it('concat [Nil, Nil, Nil] is Nil', () => {
-      expect($na(concat(cons(Nil)(cons(Nil)(cons(Nil)(Nil)))))).toEqual([]);
+      expect($na(concat._(cons._(Nil)._(cons._(Nil)._(cons._(Nil)._(Nil)))))).toEqual([]);
     });
 
     it('concat [[0], [1], [2]] is [0, 1, 2]', () => {
-      expect($na(concat(cons(_na([0]))(cons(_na([1]))(cons(_na([2]))(Nil)))))).toEqual([0, 1, 2]);
+      expect($na(concat._(cons._(_na([0]))._(cons._(_na([1]))._(cons._(_na([2]))._(Nil)))))).toEqual([0, 1, 2]);
     });
 
     it('concat [[0, 1], [2, 3], [4, 5]] is [0, 1, 2, 3, 4, 5]', () => {
-      expect($na(concat(cons(_na([0, 1]))(cons(_na([2, 3]))(cons(_na([4, 5]))(Nil)))))).toEqual([0, 1, 2, 3, 4, 5]);
+      expect($na(concat._(cons._(_na([0, 1]))._(cons._(_na([2, 3]))._(cons._(_na([4, 5]))._(Nil)))))).toEqual([0, 1, 2, 3, 4, 5]);
     });
 
     it('handles infinite lists', () => {
-      const dinfinite: List<Num> = cons(infinite)(y(() => dinfinite));
+      const dinfinite: Term = g('dinfinite', cons._(infinite)._('dinfinite'));
-      expect($n(concat(dinfinite)(undef)(_(x => _(_xs => x))))).toBe(0);
+      expect($n(concat._(dinfinite)._(undef)._(l('x', l('_', 'x'))))).toBe(0);
     });
   });
 
   // describe('repeat', () => {
   //   it('repeat 0 is [0, 0, 0, ...]', () => {
   //     expect($na(
-  //       repeat(_n(0))<List<Num>>(_((x0: Num) => _((x1s: List<Num>) =>
+  //       repeat._(_n(0))<List<Num>>(l((x0: Num) => l((x1s: List<Num>) =>
-  //         x1s<List<Num>>(_((x1: Num) => _((x2s: List<Num>) =>
+  //         x1s<List<Num>>(l((x1: Num) => l((x2s: List<Num>) =>
-  //           x2s<List<Num>>(_((x2: Num) => _((_xrs: List<Num>): List<Num> => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual([0, 0, 0]);
+  //           x2s<List<Num>>(l((x2: Num) => l((_xrs: List<Num>): List<Num> => cons._(x0)._(cons._(x1)._(cons._(x2)._(Nil)))))))))))))).toEqual([0, 0, 0]);
   //   });
   // });
 
   // describe('iterate', () => {
   //   it('iterate succ 0 is [0, 1, 2, ...]', () => {
   //     expect($na(
-  //       iterate(_n(0))<List<Num>>(_((x0: Num) => _((x1s: List<Num>) =>
+  //       iterate._(_n(0))<List<Num>>(l((x0: Num) => l((x1s: List<Num>) =>
-  //         x1s<List<Num>>(_((x1: Num) => _((x2s: List<Num>) =>
+  //         x1s<List<Num>>(l((x1: Num) => l((x2s: List<Num>) =>
-  //           x2s<List<Num>>(_((x2: Num) => _((_xrs: List<Num>): List<Num> => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual([0, 1, 2]);
+  //           x2s<List<Num>>(l((x2: Num) => l((_xrs: List<Num>): List<Num> => cons._(x0)._(cons._(x1)._(cons._(x2)._(Nil)))))))))))))).toEqual([0, 1, 2]);
   //   });
   // });
 
   describe('head', () => {
     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)))))
+          ._(l('x', l('a', sum._('x')._(iif._(eqn._(_n(5))._('x'))._(Zero)._('a')))))
-        (Zero)
+          ._(Zero)
-        (infinite)))
+          ._(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)))))
+          ._(l('x', l('a', sum._('x')._(iif._(eqn._(_n(5))._('x'))._(Zero)._('a')))))
-        (infinite)))
+          ._(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)._(_na([0, 1, 2]))._(infinite))).toEqual(NOrd.LT);
-      expect($o(cmp(cmpn)(infinite)(_na([0, 1, 2])))).toEqual(NOrd.GT);
+      expect($o(cmp._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(NOrd.GT);
     });
   });
 
   describe('lt', () => {
     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)._(_na([0, 1, 2]))._(infinite))).toEqual(true);
-      expect($b(lt(cmpn)(infinite)(_na([0, 1, 2])))).toEqual(false);
+      expect($b(lt._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(false);
     });
   });
 
   describe('le', () => {
     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)._(_na([0, 1, 2]))._(infinite))).toEqual(true);
-      expect($b(le(cmpn)(infinite)(_na([0, 1, 2])))).toEqual(false);
+      expect($b(le._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(false);
     });
   });
 
   describe('eq', () => {
     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)._(_na([0, 1, 2]))._(infinite))).toEqual(false);
-      expect($b(eq(eqn)(infinite)(_na([0, 1, 2])))).toEqual(false);
+      expect($b(eq._(eqn)._(infinite)._(_na([0, 1, 2])))).toEqual(false);
     });
   });
 
   describe('ge', () => {
     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)._(_na([0, 1, 2]))._(infinite))).toEqual(false);
-      expect($b(ge(cmpn)(infinite)(_na([0, 1, 2])))).toEqual(true);
+      expect($b(ge._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(true);
     });
   });
 
   describe('gt', () => {
     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)._(_na([0, 1, 2]))._(infinite))).toEqual(false);
-      expect($b(gt(cmpn)(infinite)(_na([0, 1, 2])))).toEqual(true);
+      expect($b(gt._(cmpn)._(infinite)._(_na([0, 1, 2])))).toEqual(true);
     });
   });
 
   describe('map', () => {
     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('[');
     });
   });
 });

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._(_n(7))._(infinity))).toBe(NOrd.LT);
-      expect($o(cmp(infinity)(_n(7)))).toBe(NOrd.GT);
+      expect($o(cmp._(infinity)._(_n(7)))).toBe(NOrd.GT);
     });
   });
 
   describe('lt', () => {
     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._(_n(7))._(infinity))).toBe(true);
-      expect($b(lt(infinity)(_n(7)))).toBe(false);
+      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._(_n(7))._(infinity))).toBe(true);
-      expect($b(le(infinity)(_n(7)))).toBe(false);
+      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._(_n(7))._(infinity))).toBe(false);
-      expect($b(eq(infinity)(_n(7)))).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._(_n(7))._(infinity))).toBe(false);
-      expect($b(ge(infinity)(_n(7)))).toBe(true);
+      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._(_n(7))._(infinity))).toBe(false);
-      expect($b(gt(infinity)(_n(7)))).toBe(true);
+      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');
     });
   });
 });

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 { toBoolean as $b, fromBoolean as _b, cmp as bcmp, eq as beq, not } from '../src/bool';
-import { toNumber as $n, fromNumber as _n, cmp as ncmp, eq as neq, show as nshow, succ } from '../src/num';
+import { toNumber as $n, fromNumber as _n, cmp as ncmp, eq as neq, succ } from '../src/num';
-import { Pair, both, cmp, eq, first, fst, ge, gt, le, lt, second, show, snd } from '../src/pair';
+import { Pair, both, cmp, eq, first, fst, ge, gt, le, lt, second, snd } from '../src/pair';
-import { toString as $s } from '../src/string';
+import { toString } from '../src/string';
+import { show as bshow } from '../src/bool.show';
+import { show as nshow } from '../src/num.show';
+import { show } from '../src/pair.show';
 
 describe('Pair', () => {
   describe('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($b(fst._(both._(not)._(succ)._(Pair._(_b(false))._(_n(0)))))).toBe(true);
-      expect($n(snd(both(not)(succ)(Pair(_b(false))(_n(0)))))).toBe(1);
+      expect($n(snd._(both._(not)._(succ)._(Pair._(_b(false))._(_n(0)))))).toBe(1);
     });
   });
 
   describe('cmp', () => {
     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)');
     });
   });
 });

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'))<String>(_((x0: Char) => _((x1s: String) =>
   //         x1s<String>(_((x1: Char) => _((x2s: String) =>
-  //           x2s<String>(_((x2: Char) => _((_xrs: String): String => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual('aaa');
+  //           x2s<String>(_((x2: Char) => _((_xrs: String): String => cons(x0)._(cons(x1)._(cons(x2)._(Nil)))))))))))))).toEqual('aaa');
   //   });
   // });
 
@@ -51,323 +54,323 @@ describe('String', () => {
   //     expect($na(
   //       iterate(_s('a'))<String>(_((x0: Char) => _((x1s: String) =>
   //         x1s<String>(_((x1: Char) => _((x2s: String) =>
-  //           x2s<String>(_((x2: Char) => _((_xrs: String): String => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual('abc');
+  //           x2s<String>(_((x2: Char) => _((_xrs: String): String => cons(x0)._(cons(x1)._(cons(x2)._(Nil)))))))))))))).toEqual('abc');
   //   });
   // });
 
   describe('empty', () => {
     it('empty "" is True', () => {
-      expect($b(empty(_s('')))).toEqual(true);
+      expect($b(empty._(_s('')))).toEqual(true);
     });
 
     it('empty "a" is False', () => {
-      expect($b(empty(_s('a')))).toEqual(false);
+      expect($b(empty._(_s('a')))).toEqual(false);
     });
 
     it('empty "ab" is False', () => {
-      expect($b(empty(_s('ab')))).toEqual(false);
+      expect($b(empty._(_s('ab')))).toEqual(false);
     });
 
     it('handles infinite lists', () => {
-      expect($b(empty(infinite))).toEqual(false);
+      expect($b(empty._(infinite))).toEqual(false);
     });
   });
 
   describe('len', () => {
     it('len "" is 0', () => {
-      expect($n(len(_s('')))).toEqual(0);
+      expect($n(len._(_s('')))).toEqual(0);
     });
 
     it('len "a" is 1', () => {
-      expect($n(len(_s('a')))).toEqual(1);
+      expect($n(len._(_s('a')))).toEqual(1);
     });
 
     it('len "ab" is 2', () => {
-      expect($n(len(_s('ab')))).toEqual(2);
+      expect($n(len._(_s('ab')))).toEqual(2);
     });
 
     it('handles infinite lists', () => {
-      expect($b(ngt(len(infinite))(Zero))).toEqual(true);
+      expect($b(ngt._(len._(infinite))._(Zero))).toEqual(true);
     });
   });
 
   describe('append', () => {
     it('"" append "" is ""', () => {
-      expect($s(append(Empty)(Empty))).toBe('');
+      expect($s(append._(Empty)._(Empty))).toBe('');
     });
 
     it('"a" append "b" is "ab"', () => {
-      expect($s(append(_s('a'))(_s('b')))).toBe('ab');
+      expect($s(append._(_s('a'))._(_s('b')))).toBe('ab');
     });
 
     it('"abc" append "def" is "abcdef"', () => {
-      expect($s(append(_s('abc'))(_s('def')))).toBe('abcdef');
+      expect($s(append._(_s('abc'))._(_s('def')))).toBe('abcdef');
     });
 
     it('handles infinite strings', () => {
-      expect($c(append(infinite)(infinite)(undef)(_(x => _(_xs => x))))).toBe('a');
+      expect($c(append._(infinite)._(infinite)._(undef)._(l('x', l('_', 'x'))))).toBe('a');
     });
   });
 
   describe('wrap', () => {
     it('"" wrap "" is ""', () => {
-      expect($s(wrap(Empty)(Empty))).toBe('');
+      expect($s(wrap._(Empty)._(Empty))).toBe('');
     });
 
     it('"a" wrap "b" is "aba"', () => {
-      expect($s(wrap(_s('a'))(_s('b')))).toBe('aba');
+      expect($s(wrap._(_s('a'))._(_s('b')))).toBe('aba');
     });
 
     it('handles infinite strings', () => {
-      expect($c(wrap(infinite)(infinite)(undef)(_(x => _(_xs => x))))).toBe('a');
+      expect($c(wrap._(infinite)._(infinite)._(undef)._(l('x', l('_', 'x'))))).toBe('a');
     });
   });
 
   describe('cmp', () => {
     it('"" cmp "" is EQ', () => {
-      expect(toNOrd(cmp(_s(''))(_s('')))).toEqual(NOrd.EQ);
+      expect(toNOrd(cmp._(_s(''))._(_s('')))).toEqual(NOrd.EQ);
     });
 
     it('"" cmp "abc" is LT', () => {
-      expect(toNOrd(cmp(_s(''))(_s('abc')))).toEqual(NOrd.LT);
+      expect(toNOrd(cmp._(_s(''))._(_s('abc')))).toEqual(NOrd.LT);
     });
 
     it('"abc" cmp "" is GT', () => {
-      expect(toNOrd(cmp(_s('abc'))(_s('')))).toEqual(NOrd.GT);
+      expect(toNOrd(cmp._(_s('abc'))._(_s('')))).toEqual(NOrd.GT);
     });
 
     it('"a" cmp "abc" is LT', () => {
-      expect(toNOrd(cmp(_s('a'))(_s('abc')))).toEqual(NOrd.LT);
+      expect(toNOrd(cmp._(_s('a'))._(_s('abc')))).toEqual(NOrd.LT);
     });
 
     it('"abc" cmp "a" is GT', () => {
-      expect(toNOrd(cmp(_s('abc'))(_s('a')))).toEqual(NOrd.GT);
+      expect(toNOrd(cmp._(_s('abc'))._(_s('a')))).toEqual(NOrd.GT);
     });
 
     it('"bca" cmp "abc" is GT', () => {
-      expect(toNOrd(cmp(_s('bca'))(_s('abc')))).toEqual(NOrd.GT);
+      expect(toNOrd(cmp._(_s('bca'))._(_s('abc')))).toEqual(NOrd.GT);
     });
 
     it('"abc" cmp "bca" is LT', () => {
-      expect(toNOrd(cmp(_s('abc'))(_s('bca')))).toEqual(NOrd.LT);
+      expect(toNOrd(cmp._(_s('abc'))._(_s('bca')))).toEqual(NOrd.LT);
     });
 
     it('"abc" cmp "abc" is EQ', () => {
-      expect(toNOrd(cmp(_s('abc'))(_s('abc')))).toEqual(NOrd.EQ);
+      expect(toNOrd(cmp._(_s('abc'))._(_s('abc')))).toEqual(NOrd.EQ);
     });
 
     it('handles infinite strings', () => {
-      expect(toNOrd(cmp(_s('abc'))(infinite))).toEqual(NOrd.GT);
+      expect(toNOrd(cmp._(_s('abc'))._(infinite))).toEqual(NOrd.GT);
-      expect(toNOrd(cmp(infinite)(_s('abc')))).toEqual(NOrd.LT);
+      expect(toNOrd(cmp._(infinite)._(_s('abc')))).toEqual(NOrd.LT);
     });
   });
 
   describe('lt', () => {
     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._(_s('abc'))._(infinite))).toEqual(false);
-      expect($b(lt(infinite)(_s('abc')))).toEqual(true);
+      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._(_s('abc'))._(infinite))).toEqual(false);
-      expect($b(le(infinite)(_s('abc')))).toEqual(true);
+      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._(_s('abc'))._(infinite))).toEqual(false);
-      expect($b(eq(infinite)(_s('abc')))).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._(_s('abc'))._(infinite))).toEqual(true);
-      expect($b(ge(infinite)(_s('abc')))).toEqual(false);
+      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._(_s('abc'))._(infinite))).toEqual(true);
-      expect($b(gt(infinite)(_s('abc')))).toEqual(false);
+      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"');
     });
   });
 });

test/tsconfig.json

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