diff --git a/eslint.config.mjs b/eslint.config.mjs
index e104470..a166a5a 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -34,6 +34,7 @@ export default [
       '@stylistic/semi': ['error', 'always'],
       '@stylistic/indent': 'error',
       '@stylistic/arrow-parens': ['error', 'as-needed', { requireForBlockBody: false }],
+      '@stylistic/max-statements-per-line': 'off',
       '@typescript-eslint/no-unused-vars': [
         'error',
         {
diff --git a/src/bool.ts b/src/bool.ts
index fbb9155..2d93130 100644
--- a/src/bool.ts
+++ b/src/bool.ts
@@ -1,8 +1,8 @@
-import { toNative as $$, L, P, _, fromNative as __, id, pipe } from './core';
+import { toNative as $$, L, _, fromNative as __, id, pipe } from './core';
 import { EQ, GT, LT, Ord } from './ord';
 import { String, fromString as _s } from './string';
 
-export type Bool = L<<T extends P>(t: T) => L<(f: T) => T>>;
+export type Bool = L<<T extends L>(t: T) => L<(f: T) => T>>;
 
 export const True: Bool
   = _(t => _(_f => t)) as Bool;
@@ -10,7 +10,7 @@ export const True: Bool
 export const False: Bool
   = _(_t => _(f => f));
 
-export const iif: L<<T extends P>(b: Bool) => L<(t: T) => L<(f: T) => T>>>
+export const iif: L<<T extends L>(b: Bool) => L<(t: T) => L<(f: T) => T>>>
   = id;
 
 export const not: L<(b: Bool) => Bool>
diff --git a/src/core.ts b/src/core.ts
index 0c40cb0..4687634 100644
--- a/src/core.ts
+++ b/src/core.ts
@@ -1,36 +1,29 @@
-export type L<T extends (v: P) => L<any>> = T & { run: () => T };
+type F = (v: L) => L<any>;
 
-export function ___<T extends (v: P) => L<any>>(run: () => T): L<T> {
-  const r: T = ((p: Parameters<T>[0]) => {
-    let v: any;
-    return ___(() => run()(
-      ___(() => v ??= p.run()),
-    ).run());
-  }) as T;
+export type L<T extends F = F> = T & { run: () => T };
 
-  (r as L<T>).run = run;
+const defer: <T extends F>(run: () => T) => L<T> = <T extends F>(run: () => T) =>
+  Object.assign(((p: Parameters<T>[0]): ReturnType<T> => {
+    let v: F;
+    return defer(() => run()(defer(() => v ??= p.run())).run());
+  }) as T, { run });
 
-  return r as L<T>;
-}
-
-export type P = L<(v: unknown) => L<any>>;
-
-export const _ = <T extends ((v: unknown) => L<any>)>(v: T): L<T> => ___(() => v);
+export const _ = <T extends F>(v: T): L<T> => defer(() => v);
 
 export const fromNative: <T>(v: T) => L<any>
-  = v => ___(() => v as any);
+  = v => defer(() => v as any);
 export const toNative: <T>(v: L<any>) => T
   = <T>(v: L<any>) => v.run() as T;
 
-export const undef: any = ___(() => {
-  throw new Error('undefined');
-});
+export const y = (f: () => L<F>) => defer(() => f().run());
+
+export const undef: any = defer(() => { throw new Error('undefined'); });
 
-export const id: L<<T extends P>(v: T) => T>
+export const id: L<<T extends L>(v: T) => T>
   = _(v => v);
-export const cnst: L<<T extends P>(v: T) => L<(_: unknown) => T>>
-  = _(v => _(_ => v)) as L<<T extends P>(v: T) => L<(_: unknown) => T>>;
-export const pipe: L<<A extends P, B extends P, C extends P>(f: L<(v: B) => C>) => L<(g: L<(v: A) => B>) => L<(v: A) => C>>>
-  = _(<A extends P, B extends P, C extends P>(f: L<(v: B) => C>) =>
+export const cnst: L<<T extends L>(v: T) => L<(_: unknown) => T>>
+  = _(v => _(_ => v)) as L<<T extends L>(v: T) => L<(_: unknown) => T>>;
+export const pipe: L<<A extends L, B extends L, C extends L>(f: L<(v: B) => C>) => L<(g: L<(v: A) => B>) => L<(v: A) => C>>>
+  = _(<A extends L, B extends L, C extends L>(f: L<(v: B) => C>) =>
     _((g: L<(v: A) => B>) =>
       _((v: A) => f(g(v)))));
diff --git a/src/debug.ts b/src/debug.ts
index 4eed77d..c742f48 100644
--- a/src/debug.ts
+++ b/src/debug.ts
@@ -1,7 +1,7 @@
-import { L, P, _ } from './core';
+import { L, _ } from './core';
 import { String, toString } from './string';
 
-export const log: L<<T extends P>(s: String) => L<(p: T) => T>>
+export const log: L<<T extends L>(s: String) => L<(p: T) => T>>
   = _(s => _(p => {
     console.log(toString(s));
     return p;
diff --git a/src/index.ts b/src/index.ts
index af8fdef..04f5982 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,3 +1,7 @@
-import { toNative as $$, _, fromNative as __, id } from './core';
+import { _, fromNative as __ } from './core';
+import { toString as $s, fromString as _s } from './string';
+import { run } from './bf';
 
-console.log($$(id(__('first'))));
+console.log($s(run
+(_s('++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.'))
+(_s(''))));
diff --git a/src/list.ts b/src/list.ts
index 68b1b7e..ec7be7b 100644
--- a/src/list.ts
+++ b/src/list.ts
@@ -1,69 +1,69 @@
-import { toNative as $$, L, P, _, fromNative as __, ___, cnst, id, pipe, undef } from './core';
+import { toNative as $$, L, _, fromNative as __, cnst, id, pipe, undef, y } from './core';
 import { EQ, GT, LT, Ord, eq as eqc } from './ord';
 import { Bool, False, True, and, iif, or } from './bool';
 import { Num, Zero, succ } from './num';
 import { String, fromString as _s } from './string';
 
-export type List<T extends P> = L<<R extends P>(z: R) => L<(f: L<(x: T) => L<(xs: List<T>) => R>>) => R>>;
+export type List<T extends L> = L<<R extends L>(z: R) => L<(f: L<(x: T) => L<(xs: List<T>) => R>>) => R>>;
 
 export const Nil: List<any>
   = _(z => _(_f => z)) as List<any>;
 
-export const Cons: L<<T extends P>(x: T) => L<(xs: List<T>) => List<T>>>
-  = _(<T extends P>(x: T) => _((xs: List<T>) => _(_z => _(f => f(x)(xs))) as List<T>));
+export const Cons: L<<T extends L>(x: T) => L<(xs: List<T>) => List<T>>>
+  = _(<T extends L>(x: T) => _((xs: List<T>) => _(_z => _(f => f(x)(xs))) as List<T>));
 
-export const cons: L<<T extends P>(x: T) => L<(xs: List<T>) => List<T>>>
+export const cons: L<<T extends L>(x: T) => L<(xs: List<T>) => List<T>>>
   = Cons;
 
-export const snoc: L<<T extends P>(xs: List<T>) => L<(x: T) => List<T>>>
-  = _(<T extends P>(xs: List<T>) =>
+export const snoc: L<<T extends L>(xs: List<T>) => L<(x: T) => List<T>>>
+  = _(<T extends L>(xs: List<T>) =>
     _((x: T) => xs(cons(x)(Nil))(_(y => _(ys => cons(y)(snoc(ys)(x)))))));
 
-export const nul: L<<T extends P>(xs: List<T>) => Bool>
+export const nul: L<<T extends L>(xs: List<T>) => Bool>
   = _(xs => xs(True)(cnst(cnst(False))));
 
-export const len: L<<T extends P>(xs: List<T>) => Num>
+export const len: L<<T extends L>(xs: List<T>) => Num>
   = _(xs => xs(Zero)(cnst(pipe(succ)(len))));
 
-export const singleton: L<<T extends P>(v: T) => List<T>>
+export const singleton: L<<T extends L>(v: T) => List<T>>
    = _(x => cons(x)(Nil));
 
-export const append: L<<T extends P>(l: List<T>) => L<(r: List<T>) => List<T>>>
+export const append: L<<T extends L>(l: List<T>) => L<(r: List<T>) => List<T>>>
   = _(l => _(r => l(r)(_(x => _(xs => cons(x)(append(xs)(r)))))));
 
-export const concat: L<<T extends P>(ls: List<List<T>>) => List<T>>
+export const concat: L<<T extends L>(ls: List<List<T>>) => List<T>>
   = _(ls => ls(Nil)(_(x => pipe(append(x))(concat))));
 
-export const repeat: L<<T extends P>(x: T) => List<T>>
+export const repeat: L<<T extends L>(x: T) => List<T>>
   = _(x => cons(x)(repeat(x)));
 
-export const iterate: L<<T extends P>(f: L<(x: T) => T>) => L<(x: T) => List<T>>>
-  = _(<T extends P>(f: L<(x: T) => T>) => _((x: T) => cons(x)(iterate(f)(f(x)))));
+export const iterate: L<<T extends L>(f: L<(x: T) => T>) => L<(x: T) => List<T>>>
+  = _(<T extends L>(f: L<(x: T) => T>) => _((x: T) => cons(x)(iterate(f)(f(x)))));
 
-export const head: L<<T extends P>(xs: List<T>) => T>
+export const head: L<<T extends L>(xs: List<T>) => T>
   = _(xs => xs(undef)(cnst));
 
-export const tail: L<<T extends P>(xs: List<T>) => List<T>>
+export const tail: L<<T extends L>(xs: List<T>) => List<T>>
   = _(xs => xs(undef)(cnst(id)));
 
-export const foldl: L<<T extends P, R extends P>(f: L<(a: R) => L<(x: T) => R>>) => L<(z: R) => L<(xs: List<T>) => R>>>
-  = _(<T extends P, R extends P>(f: L<(a: R) => L<(x: T) => R>>) =>
+export const foldl: L<<T extends L, R extends L>(f: L<(a: R) => L<(x: T) => R>>) => L<(z: R) => L<(xs: List<T>) => R>>>
+  = _(<T extends L, R extends L>(f: L<(a: R) => L<(x: T) => R>>) =>
     _((z: R) =>
       _((xs: List<T>) => xs(z)(pipe(foldl(f))(f(z))))));
 
-export const foldlz: L<<T extends P>(f: L<(a: T) => L<(x: T) => T>>) => L<(xs: List<T>) => T>>
-  = _(<T extends P>(f: L<(a: T) => L<(x: T) => T>>) => _((xs: List<T>) => xs(undef)(foldl(f))));
+export const foldlz: L<<T extends L>(f: L<(a: T) => L<(x: T) => T>>) => L<(xs: List<T>) => T>>
+  = _(<T extends L>(f: L<(a: T) => L<(x: T) => T>>) => _((xs: List<T>) => xs(undef)(foldl(f))));
 
-export const foldr: L<<T extends P, R extends P>(f: L<(x: T) => L<(a: R) => R>>) => L<(z: R) => L<(xs: List<T>) => R>>>
-  = _(<T extends P, R extends P>(f: L<(x: T) => L<(a: R) => R>>) =>
+export const foldr: L<<T extends L, R extends L>(f: L<(x: T) => L<(a: R) => R>>) => L<(z: R) => L<(xs: List<T>) => R>>>
+  = _(<T extends L, R extends L>(f: L<(x: T) => L<(a: R) => R>>) =>
     _((z: R) =>
       _((xs: List<T>) => xs(z)(_(x => pipe(f(x))(foldr(f)(z)))))));
 
-export const foldrz: L<<T extends P>(f: L<(x: T) => L<(a: T) => T>>) => L<(xs: List<T>) => T>>
+export const foldrz: L<<T extends L>(f: L<(x: T) => L<(a: T) => T>>) => L<(xs: List<T>) => T>>
   = undef;
 
-export const cmp: L<<T extends P>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Ord>>>
-  = _(<T extends P>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
+export const cmp: L<<T extends L>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Ord>>>
+  = _(<T extends L>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
     _((l: List<T>) =>
       _((r: List<T>) => l
       (r(EQ)(cnst(cnst(LT))))
@@ -72,73 +72,73 @@ export const cmp: L<<T extends P>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l:
       (cmp(ecmp)(lxs)(rxs))
       (ecmp(lx)(rx)))))))))));
 
-export const lt: L<<T extends P>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
-  = _(<T extends P>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
+export const lt: L<<T extends L>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
+  = _(<T extends L>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
     _((l: List<T>) =>
       _((r: List<T>) =>
         r(False)(_(rx => _(rxs => l(True)(_(lx => _(lxs => ecmp(lx)(rx)(True)(lt(ecmp)(lxs)(rxs))(False))))))))));
 
-export const le: L<<T extends P>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
-  = _(<T extends P>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
+export const le: L<<T extends L>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
+  = _(<T extends L>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
     _((l: List<T>) =>
       _((r: List<T>) =>
         l(True)(_(lx => _(lxs => r(False)(_(rx => _(rxs => ecmp(lx)(rx)(True)(le(ecmp)(lxs)(rxs))(False))))))))));
 
-export const eq: L<<T extends P>(eeq: L<(l: T) => L <(r: T) => Bool>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
-  = _(<T extends P>(eeq: L<(l: T) => L<(r: T) => Bool>>) =>
+export const eq: L<<T extends L>(eeq: L<(l: T) => L <(r: T) => Bool>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
+  = _(<T extends L>(eeq: L<(l: T) => L<(r: T) => Bool>>) =>
     _((l: List<T>) =>
       _((r: List<T>) => l
       (r(True)(cnst(cnst(False))))
       (_(lx => _(lxs => r(False)(_(rx => _(rxs => and(eeq(lx)(rx))(eq(eeq)(lxs)(rxs)))))))))));
 
-export const ge: L<<T extends P>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
-  = _(<T extends P>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
+export const ge: L<<T extends L>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
+  = _(<T extends L>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
     _((l: List<T>) =>
       _((r: List<T>) =>
         r(True)(_(rx => _(rxs => l(False)(_(lx => _(lxs => ecmp(lx)(rx)(False)(ge(ecmp)(lxs)(rxs))(True))))))))));
 
-export const gt: L<<T extends P>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
-  = _(<T extends P>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
+export const gt: L<<T extends L>(ecmp: L<(l: T) => L <(r: T) => Ord>>) => L<(l: List<T>) => L<(r: List<T>) => Bool>>>
+  = _(<T extends L>(ecmp: L<(l: T) => L<(r: T) => Ord>>) =>
     _((l: List<T>) =>
       _((r: List<T>) =>
         l(False)(_(lx => _(lxs => r(True)(_(rx => _(rxs => ecmp(lx)(rx)(False)(gt(ecmp)(lxs)(rxs))(True))))))))));
 
-export const map: L<<T extends P, R extends P>(f: L<(x: T) => R>) => L<(xs: List<T>) => List<R>>>
-  = _(<T extends P, R extends P>(f: L<(x: T) => R>) =>
+export const map: L<<T extends L, R extends L>(f: L<(x: T) => R>) => L<(xs: List<T>) => List<R>>>
+  = _(<T extends L, R extends L>(f: L<(x: T) => R>) =>
     _((xs: List<T>) => xs(Nil)(_(x => pipe(cons(f(x)))(map(f))))));
 
-export const filter: L<<T extends P>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => List<T>>>
-  = _(<T extends P>(f: L<(x: T) => Bool>) =>
+export const filter: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => List<T>>>
+  = _(<T extends L>(f: L<(x: T) => Bool>) =>
     _((xs: List<T>) => xs(Nil)(_(x => pipe(iif(f(x))(cons(x))(id))(filter(f))))));
 
-export const any: L<<T extends P>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>>
-  = _(<T extends P>(f: L<(x: T) => Bool>) =>
+export const any: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>>
+  = _(<T extends L>(f: L<(x: T) => Bool>) =>
     _((xs: List<T>) => xs(False)(_(x => pipe(or(f(x)))(any(f))))));
 
-export const all: L<<T extends P>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>>
-  = _(<T extends P>(f: L<(x: T) => Bool>) =>
+export const all: L<<T extends L>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => Bool>>
+  = _(<T extends L>(f: L<(x: T) => Bool>) =>
     _((xs: List<T>) => xs(True)(_(x => pipe(and(f(x)))(all(f))))));
 
-export const get: L<<T extends P>(i: Num) => L<(xs: List<T>) => T>>
+export const get: L<<T extends L>(i: Num) => L<(xs: List<T>) => T>>
   = _(i => _(xs => xs(undef)(_(x => i(cnst(x))(get)))));
 
-export const update: L<<T extends P>(f: L< (p: T) => T>) => L<(i: Num) => L<(xs: List<T>) => List<T>>>>
-  = _(<T extends P>(f: L< (p: T) => T>) =>
+export const update: L<<T extends L>(f: L< (p: T) => T>) => L<(i: Num) => L<(xs: List<T>) => List<T>>>>
+  = _(<T extends L>(f: L< (p: T) => T>) =>
     _((i: Num) =>
       _((xs: List<T>) =>
         xs(undef)(_(x => _(xs => i(cons(f(x))(xs))(_(pi => cons(x)(update(f)(pi)(xs))))))))));
 
-export const set: L<<T extends P>(v: T) => L<(i: Num) => L<(xs: List<T>) => List<T>>>>
+export const set: L<<T extends L>(v: T) => L<(i: Num) => L<(xs: List<T>) => List<T>>>>
   = pipe(update)(cnst);
 
-export const intersperse: L<<T extends P>(v: T) => L<(xs: List<T>) => List<T>>>
+export const intersperse: L<<T extends L>(v: T) => L<(xs: List<T>) => List<T>>>
   = _(v => _(xs => xs(xs)(_(x => _(rxs => rxs(xs)(cnst(cnst(cons(x)(cons(v)(intersperse(v)(rxs)))))))))));
 
-export const show: L<<T extends P>(eshow: L<(e: T) => String>) => L<(xs: List<T>) => String>>
+export const show: L<<T extends L>(eshow: L<(e: T) => String>) => L<(xs: List<T>) => String>>
   = _(eshow => _(xs => concat(snoc(cons(_s('['))(intersperse(_s(', '))(map(eshow)(xs))))(_s(']')))));
 
-export const fromArray: <T extends P>(xs: T[]) => List<T>
-  = xs => xs.length === 0 ? Nil : cons(xs[0])(___(() => fromArray(xs.slice(1)).run()));
+export const fromArray: <T extends L>(xs: T[]) => List<T>
+  = xs => xs.length === 0 ? Nil : cons(xs[0])(y(() => fromArray(xs.slice(1))));
 
-export const toArray: <T extends P>(xs: List<T>) => P[]
+export const toArray: <T extends L>(xs: List<T>) => L[]
   = xs => $$(xs(__([]))(_(x => _(xs => __([x, ...toArray(xs)])))));
diff --git a/src/num.ts b/src/num.ts
index 70c9dab..363046e 100644
--- a/src/num.ts
+++ b/src/num.ts
@@ -1,9 +1,9 @@
-import { toNative as $$, L, P, _, fromNative as __, ___, cnst, id, pipe } from './core';
+import { toNative as $$, L, _, fromNative as __, cnst, id, pipe, y } from './core';
 import { EQ, GT, LT, Ord } from './ord';
 import { Bool, False, True, iif } from './bool';
 import { Empty, String, append, cons } from './string';
 
-export type Num = L<<T extends P>(z: T) => L<(n: L<(p: Num) => T>) => T>>;
+export type Num = L<<T extends L>(z: T) => L<(n: L<(p: Num) => T>) => T>>;
 
 export const Zero: Num
   = _(z => _(_n => z)) as Num;
@@ -11,7 +11,7 @@ export const Zero: Num
 export const Succ: L<(p: Num) => Num>
   = _(p => _(_z => _(n => n(p))));
 
-export const ifz: L<<T extends P>(n: Num) => L<(t: T) => L<(f: T) => T>>>
+export const ifz: L<<T extends L>(n: Num) => L<(t: T) => L<(f: T) => T>>>
   = _(n => _(t => _(f => n(t)(cnst(f)))));
 
 export const succ: L<(n: Num) => Num>
@@ -65,7 +65,7 @@ export const show: L<(n: Num) => String>
   (append(show(div(n)(fromNumber(10))))(show(mod(n)(fromNumber(10))))));
 
 export const fromNumber: (n: number) => Num
-  = n => !n ? Zero : Succ(___(() => fromNumber(n - 1).run()));
+  = n => !n ? Zero : Succ(y(() => fromNumber(n - 1)));
 
 export const toNumber: (n: Num) => number
   = n => $$(n(__(0))(_(p => __(1 + toNumber(p)))));
diff --git a/src/ord.ts b/src/ord.ts
index f629360..6e39e8e 100644
--- a/src/ord.ts
+++ b/src/ord.ts
@@ -1,8 +1,8 @@
-import { toNative as $$, L, P, _, fromNative as __ } from './core';
+import { toNative as $$, L, _, fromNative as __ } from './core';
 import { Bool, False, True } from './bool';
 import { String, fromString as _s } from './string';
 
-export type Ord = L<<T extends P>(lt: T) => L<(eq: T) => L<(gt: T) => T>>>;
+export type Ord = L<<T extends L>(lt: T) => L<(eq: T) => L<(gt: T) => T>>>;
 
 export const enum NOrd {
   LT,
diff --git a/src/pair.ts b/src/pair.ts
index e04e1cc..01657e4 100644
--- a/src/pair.ts
+++ b/src/pair.ts
@@ -1,82 +1,82 @@
-import { L, P, _ } from './core';
+import { L, _ } from './core';
 import { GT, LT, Ord } from './ord';
 import { Bool, False, True, and } from './bool';
 import { Nil, concat, cons } from './list';
 import { String, fromString as _s } from './string';
 
-export type Pair<F extends P, S extends P> = L<<R extends P>(f: L<(f: F) => L<(s: S) => R>>) => R>;
+export type Pair<F extends L, S extends L> = L<<R extends L>(f: L<(f: F) => L<(s: S) => R>>) => R>;
 
-export const Pair: L<<F extends P, S extends P>(f: F) => L<(s: S) => Pair<F, S>>>
-  = _(<F extends P, S extends P>(f: F) =>
+export const Pair: L<<F extends L, S extends L>(f: F) => L<(s: S) => Pair<F, S>>>
+  = _(<F extends L, S extends L>(f: F) =>
     _((s: S) =>
-      _(<R extends P>(p: L<(f: F) => L<(s: S) => R>>) => p(f)(s))));
+      _(<R extends L>(p: L<(f: F) => L<(s: S) => R>>) => p(f)(s))));
 
-export const fst: L<<F extends P, S extends P>(p: Pair<F, S>) => F>
+export const fst: L<<F extends L, S extends L>(p: Pair<F, S>) => F>
   = _(p => p(_(f => _(_s => f))));
 
-export const snd: L<<F extends P, S extends P>(p: Pair<F, S>) => S>
+export const snd: L<<F extends L, S extends L>(p: Pair<F, S>) => S>
   = _(p => p(_(_f => _(s => s))));
 
-export const first: L<<F extends P, FR extends P, S extends P>(t: L<(f: F) => FR>) => L<(p: Pair<F, S>) => Pair<FR, S>>>
-  = _(<F extends P, FR extends P>(t: L<(f: F) => FR>) =>
-    _(<S extends P>(p: Pair<F, S>) => p(_(f => _(s => Pair(t(f))(s))))));
+export const first: L<<F extends L, FR extends L, S extends L>(t: L<(f: F) => FR>) => L<(p: Pair<F, S>) => Pair<FR, S>>>
+  = _(<F extends L, FR extends L>(t: L<(f: F) => FR>) =>
+    _(<S extends L>(p: Pair<F, S>) => p(_(f => _(s => Pair(t(f))(s))))));
 
-export const second: L<<F extends P, S extends P, SR extends P>(t: L<(s: S) => SR>) => L<(p: Pair<F, S>) => Pair<F, SR>>>
-  = _(<S extends P, SR extends P>(t: L<(s: S) => SR>) =>
-    _(<F extends P>(p: Pair<F, S>) => p(_(f => _(s => Pair(f)(t(s)))))));
+export const second: L<<F extends L, S extends L, SR extends L>(t: L<(s: S) => SR>) => L<(p: Pair<F, S>) => Pair<F, SR>>>
+  = _(<S extends L, SR extends L>(t: L<(s: S) => SR>) =>
+    _(<F extends L>(p: Pair<F, S>) => p(_(f => _(s => Pair(f)(t(s)))))));
 
-export const both: L<<F extends P, FR extends P, S extends P, SR extends P>(tf: L<(f: F) => FR>) => L<(ts: L<(s: S) => SR>) => L<(p: Pair<F, S>) => Pair<FR, SR>>>>
-  = _(<F extends P, FR extends P>(tf: L<(f: F) => FR>) =>
-    _(<S extends P, SR extends P>(ts: L<(s: S) => SR>) =>
+export const both: L<<F extends L, FR extends L, S extends L, SR extends L>(tf: L<(f: F) => FR>) => L<(ts: L<(s: S) => SR>) => L<(p: Pair<F, S>) => Pair<FR, SR>>>>
+  = _(<F extends L, FR extends L>(tf: L<(f: F) => FR>) =>
+    _(<S extends L, SR extends L>(ts: L<(s: S) => SR>) =>
       _((p: Pair<F, S>) => p(_(f => _(s => Pair(tf(f))(ts(s))))))));
 
-export const uncurry: L<<F extends P, S extends P, R extends P>(t: L<(f: F) => L<(s: S) => R>>) => L<(p: Pair<F, S>) => R>>
-  = _(<F extends P, S extends P, R extends P>(t: L<(f: F) => L<(s: S) => R>>) =>
+export const uncurry: L<<F extends L, S extends L, R extends L>(t: L<(f: F) => L<(s: S) => R>>) => L<(p: Pair<F, S>) => R>>
+  = _(<F extends L, S extends L, R extends L>(t: L<(f: F) => L<(s: S) => R>>) =>
     _((p: Pair<F, S>) => p(t)));
 
-export const cmp: L<<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Ord>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Ord>>>>
-  = _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
+export const cmp: L<<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Ord>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Ord>>>>
+  = _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
     _((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
       uncurry(_((lf: F) => _((ls: S) =>
         uncurry(_((rf: F) => _((rs: S) =>
           fcmp(lf)(rf)(LT)(scmp(ls)(rs))(GT)))))))));
 
-export const lt: L<<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
-  = _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
+export const lt: L<<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
+  = _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
     _((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
       uncurry(_((lf: F) => _((ls: S) =>
         uncurry(_((rf: F) => _((rs: S) =>
           fcmp(lf)(rf)(True)(scmp(ls)(rs)(True)(False)(False))(False)))))))));
 
-export const le: L<<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
-  = _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
+export const le: L<<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
+  = _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
     _((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
       uncurry(_((lf: F) => _((ls: S) =>
         uncurry(_((rf: F) => _((rs: S) =>
           fcmp(lf)(rf)(True)(scmp(ls)(rs)(True)(True)(False))(False)))))))));
 
-export const eq: L<<F extends P, S extends P>(feq: L<(l: F) => L<(r: F) => Bool>>) => L<(seq: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
-  = _(<F extends P, S extends P>(feq: L<(l: F) => L<(r: F) => Bool>>) =>
+export const eq: L<<F extends L, S extends L>(feq: L<(l: F) => L<(r: F) => Bool>>) => L<(seq: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
+  = _(<F extends L, S extends L>(feq: L<(l: F) => L<(r: F) => Bool>>) =>
     _((seq: L<(l: S) => L<(r: S) => Bool>>) =>
       uncurry(_((lf: F) => _((ls: S) =>
         uncurry(_((rf: F) => _((rs: S) =>
           and(feq(lf)(rf))(seq(ls)(rs))))))))));
 
-export const ge: L<<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
-  = _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
+export const ge: L<<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
+  = _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
     _((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
       uncurry(_((lf: F) => _((ls: S) =>
         uncurry(_((rf: F) => _((rs: S) =>
           fcmp(lf)(rf)(False)(scmp(ls)(rs)(False)(True)(True))(True)))))))));
 
-export const gt: L<<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
-  = _(<F extends P, S extends P>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
+export const gt: L<<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) => L<(scmp: L<(l: S) => L<(r: S) => Bool>>) => L<(l: Pair<F, S>) => L<(r: Pair<F, S>) => Bool>>>>
+  = _(<F extends L, S extends L>(fcmp: L<(l: F) => L<(r: F) => Ord>>) =>
     _((scmp: L<(l: S) => L<(r: S) => Ord>>) =>
       uncurry(_((lf: F) => _((ls: S) =>
         uncurry(_((rf: F) => _((rs: S) =>
           fcmp(lf)(rf)(False)(scmp(ls)(rs)(False)(False)(True))(True)))))))));
 
-export const show: L<<F extends P, S extends P>(fshow: L<(f: F) => String>) => L<(sshow: L<(s: S) => String>) => L<(p: Pair<F, S>) => String>>>
-  = _(<F extends P>(fshow: L<(f: F) => String>) =>
-    _(<S extends P>(sshow: L<(s: S) => String>) =>
+export const show: L<<F extends L, S extends L>(fshow: L<(f: F) => String>) => L<(sshow: L<(s: S) => String>) => L<(p: Pair<F, S>) => String>>>
+  = _(<F extends L>(fshow: L<(f: F) => String>) =>
+    _(<S extends L>(sshow: L<(s: S) => String>) =>
       uncurry(_((f: F) => _((s: S) => concat(cons(_s('('))(cons(fshow(f))(cons(_s(', '))(cons(sshow(s))(cons(_s(')'))(Nil)))))))))));
diff --git a/src/string.ts b/src/string.ts
index 3cd1e0a..2f5825c 100644
--- a/src/string.ts
+++ b/src/string.ts
@@ -1,4 +1,4 @@
-import { toNative as $$, L, _, fromNative as __, ___ } from './core';
+import { toNative as $$, L, _, fromNative as __, y } from './core';
 import { Ord } from './ord';
 import { Bool } from './bool';
 import { fromNumber as _nn } from './num';
@@ -31,7 +31,7 @@ export const wrap: L<(w: String) => L<(c: String) => String>>
   = _(w => _(c => append(w)(append(c)(w))));
 
 export const fromString: (xs: string) => String
-  = xs => xs.length === 0 ? Nil : Cons(_c(xs[0]))(___(() => fromString(xs.slice(1)).run()));
+  = xs => xs.length === 0 ? Nil : Cons(_c(xs[0]))(y(() => fromString(xs.slice(1))));
 
 export const toString: (xs: String) => string
   = xs => $$(xs(__(''))(_(x => _(xs => __($c(x) + toString(xs))))));
diff --git a/test/list.spec.ts b/test/list.spec.ts
index e5c6bc9..a2d25be 100644
--- a/test/list.spec.ts
+++ b/test/list.spec.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from '@jest/globals';
-import { toNative as $$, _, fromNative as __, ___, undef } from '../src/core';
+import { toNative as $$, _, fromNative as __, undef, y } from '../src/core';
 import { toNOrd as $o, NOrd } from '../src/ord';
 import { toBoolean as $b, iif } from '../src/bool';
 import { toNumber as $n, toNumber as $nn, Num, Succ, Zero, fromNumber as _n, fromNumber as _nn, cmp as cmpn, eq as eqn, even, gt as ngt, show as nshow, odd, succ, sum } from '../src/num';
@@ -11,7 +11,7 @@ describe('List', () => {
   const infinite: List<Num> = iterate(Succ)(Zero);
 
   const _na: (xs: number[]) => List<Num>
-    = xs => xs.length === 0 ? Nil : Cons(_nn(xs[0]))(___(() => _na(xs.slice(1)).run()));
+    = xs => xs.length === 0 ? Nil : Cons(_nn(xs[0]))(y(() => _na(xs.slice(1))));
 
   const $na: (xs: List<Num>) => number[]
     = xs => $$(xs(__([]))(_(x => _(xs => __([$nn(x), ...$na(xs)])))));
@@ -158,7 +158,7 @@ describe('List', () => {
     });
 
     it('handles infinite lists', () => {
-      const dinfinite: List<Num> = cons(infinite)(___(() => dinfinite.run()));
+      const dinfinite: List<Num> = cons(infinite)(y(() => dinfinite));
       expect($n(concat(dinfinite)(undef)(_(x => _(_xs => x))))).toBe(0);
     });
   });
diff --git a/test/num.spec.ts b/test/num.spec.ts
index 6760a79..d586767 100644
--- a/test/num.spec.ts
+++ b/test/num.spec.ts
@@ -1,12 +1,12 @@
 import { describe, expect, it } from '@jest/globals';
-import { ___, undef } from '../src/core';
+import { undef, y } from '../src/core';
 import { toNOrd as $o, NOrd } from '../src/ord';
 import { toBoolean as $b, fromBoolean as _b } from '../src/bool';
 import { toNumber as $n, Num, Succ, Zero, fromNumber as _n, cmp, div, eq, ge, gt, ifz, le, lt, mod, mul, pred, show, sub, succ, sum } from '../src/num';
 import { toString as $s } from '../src/string';
 
 describe('Num', () => {
-  const infinity: Num = ___(() => Succ(infinity).run());
+  const infinity: Num = y(() => Succ(infinity));
 
   describe('toNumber', () => {
     it('converts 0', () => {
diff --git a/test/string.spec.ts b/test/string.spec.ts
index 761f8a6..f26c957 100644
--- a/test/string.spec.ts
+++ b/test/string.spec.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from '@jest/globals';
-import { _, ___, undef } from '../src/core';
+import { _, undef, y } from '../src/core';
 import { NOrd, toNOrd } from '../src/ord';
 import { toBoolean as $b } from '../src/bool';
 import { toNumber as $n, Zero, gt as ngt } from '../src/num';
@@ -7,7 +7,7 @@ import { toChar as $c, fromChar as _c } from '../src/char';
 import { toString as $s, Cons, Empty, String, fromString as _s, append, cmp, empty, eq, ge, gt, le, len, lt, show, wrap } from '../src/string';
 
 describe('String', () => {
-  const infinite: String = Cons(_c('a'))(___(() => infinite.run()));
+  const infinite: String = Cons(_c('a'))(y(() => infinite));
 
   describe('toString', () => {
     it('converts ""', () => {