diff --git a/src/bool.ts b/src/bool.ts index e85fe07..b29e1e8 100644 --- a/src/bool.ts +++ b/src/bool.ts @@ -1,6 +1,6 @@ -import { Lazy, Q, V, _ } from './core'; +import { L, P, _, fromNative, toNative } from './core'; -export type Bool = Lazy<(t: T) => Lazy<(f: T) => T>>; +export type Bool = L<(t: T) => L<(f: T) => T>>; export const True: Bool = _(t => _(_f => t)) as Bool; @@ -8,23 +8,23 @@ export const True: Bool export const False: Bool = _(_t => _(f => f)); -export const iif: (b: Bool) => Lazy<(t: T) => Lazy<(f: T) => T>> - = b => _(t => _(f => b.then(b => b(t).then(e=>e(f))))); +export const iif: L<(b: Bool) => L<(t: T) => L<(f: T) => T>>> + = _(b => _(t => _(f => b._(t)._(f)))); -export const not: (b: Bool) => Bool - = b => b.then(b => b(False).then(e=>e(True))); +export const not: L<(b: Bool) => Bool> + = _(b => b._(False)._(True)); -export const and: (l: Bool) => Lazy<(r: Bool) => Bool> - = l => _(r => l.then(l => l(r).then(e=>e(False)))); +export const and: L<(l: Bool) => L<(r: Bool) => Bool>> + = _(l => _(r => l._(r)._(False))); -export const or: (l: Bool) => Lazy<(r: Bool) => Bool> - = l => _(r => l.then(l => l(True).then(e=>e(r)))); +export const or: L<(l: Bool) => L<(r: Bool) => Bool>> + = _(l => _(r => l._(True)._(r))); -export const xor: (l: Bool) => Lazy<(r: Bool) => Bool> - = l => _(r => l.then(l => l(not(r)).then(e=>e(r)))); +export const xor: L<(l: Bool) => L<(r: Bool) => Bool>> + = _(l => _(r => l._(not._(r))._(r))); export const fromBoolean: (b: boolean) => Bool = b => b ? True : False; export const toBoolean: (b: Bool) => boolean - = b => b.then(b => b(_(true as unknown as Q)).then(e=>e(_(false as unknown as Q)))).value as unknown as boolean; + = b => toNative(b._(fromNative(true))._(fromNative(false))); diff --git a/src/core.ts b/src/core.ts index 8138ae3..9435256 100644 --- a/src/core.ts +++ b/src/core.ts @@ -1,4 +1,4 @@ -export class Lazy Lazy> { +export class L L> { protected _value?: T; constructor(private _eval: () => T) { } @@ -13,23 +13,25 @@ export class Lazy Lazy> { return this._value = this._eval(); } - public then(f: (v: T) => R): R { - return new Lazy(() => f(this.value).value) as R; + public get _(): T { + return ((p: Parameters[0]) => new L(() => this.value(p).value)) as T; } } -export type Q = (v: unknown) => Lazy; +export type P = L<(v: unknown) => L>; -export type V = Lazy<(v: unknown) => Lazy>; +export const _ = L)>(v: T): L => new L(() => v); -export const _ = Lazy>(v: T): Lazy => new Lazy(() => v); -export const $ = Lazy>(v: Lazy): T => v.value; +export const fromNative: (v: T) => L + = v => new L(() => v as any); +export const toNative: (v: L) => T + = (v: L) => v.value as T; -export const undef: any = new Lazy(() => { +export const undef: any = new L(() => { throw new Error('undefined'); }); -export const id: (v: T) => T - = v => v; -export const cnst: (v: T) => Lazy<(_: unknown) => T> - = v => _(_ => v); +export const id: L<(v: T) => T> + = _(v => v); +export const cnst: L<(v: T) => L<(_: unknown) => T>> + = _(v => _(_ => v)) as L<(v: T) => L<(_: unknown) => T>>; diff --git a/src/list.ts b/src/list.ts index a727db1..5caaec1 100644 --- a/src/list.ts +++ b/src/list.ts @@ -1,50 +1,65 @@ -import { Lazy, Q, V, _, undef } from './core'; -import { fromNumber, Num, toNumber } from './num'; +import { L, P, _, fromNative, toNative, undef } from './core'; +import { Num, fromNumber, toNumber } from './num'; import { Bool, iif } from './bool'; -export type List = Lazy<(z: R) => Lazy<(f: (x: T) => Lazy<(xs: List) => R>) => R>>; +export type List = L<(z: R) => L<(f: L<(x: T) => L<(xs: List) => R>>) => R>>; export const Nil: List = _(z => _(_f => z)) as List; -export const Cons: (x: T) => Lazy<(xs: List) => List> - = (x: T) => _((xs: List) => _(_z => _(f => f(x).then(e=>e(xs)))) as List); +export const Cons: L<(x: T) => L<(xs: List) => List>> + = _((x: T) => _((xs: List) => _(_z => _(f => f._(x)._(xs))) as List)); -export const cons: (x: T) => Lazy<(xs: List) => List> +export const cons: L<(x: T) => L<(xs: List) => List>> = Cons; -export const head: (xs: List) => T - = xs => xs.then(xs => xs(undef).then(e=>e(x=>_(_xs=>x)))); +export const head: L<(xs: List) => T> + = _(xs => xs._(undef)._(_(x => _(_xs => x)))); -export const tail: (xs: List) => List - = xs => xs.then(xs => xs(undef).then(e=>e(_x =>_(xs=>xs)))); +export const tail: L<(xs: List) => List> + = _(xs => xs._(undef)._(_(_x => _(xs => xs)))); -export const foldl: (f: (a: R) => Lazy<(x: T) => R>) => Lazy<(z: R) => Lazy<(xs: List) => R>> - = f => _(z => _(xs => xs.then(xs => xs(z).then(e=>e(x => _(xs => foldl(f).then(e=>e(f(z).then(e=>e(x))).then(e=>e(xs))))))))); +export const foldl: L<(f: L<(a: R) => L<(x: T) => R>>) => L<(z: R) => L<(xs: List) => R>>> + = + _((f: L<(a: R) => L<(x: T) => R>>) => + _((z: R) => + _((xs: List) => xs._(z)._(_(x => + _(xs => foldl._(f)._(f._(z)._(x))._(xs))))))); -export const foldlz: (f: (a: T) => Lazy<(x: T) => T>) => Lazy<(xs: List) => T> - = f => _(xs => xs.then(xs => xs(undef).then(e=>e(x=>_(xs=>foldl(f).then(e=>e(x).then(e=>e(xs)))))))); +export const foldlz: L<(f: L<(a: T) => L<(x: T) => T>>) => L<(xs: List) => T>> + = + _((f: L<(a: T) => L<(x: T) => T>>) => + _((xs:List) => + xs._(undef)._(_(x => + _(xs => foldl._(f)._(x)._(xs)))))); -export const foldr: (f: (x: T) => Lazy<(a: R) => R>) => Lazy<(z: R) => Lazy<(xs: List) => R>> - = f => _(z => _(xs => xs.then(xs => xs(z).then(e=>e(x => _(xs => f(x).then(e=>e(foldr(f).then(e=>e(z).then(e=>e(xs))))))))))); +export const foldr: L<(f: L<(x: T) => L<(a: R) => R>>) => L<(z: R) => L<(xs: List) => R>>> + = + _((f: L<(x: T) => L<(a: R) => R>>) => + _((z: R) => + _((xs: List) => xs._(z)._(_(x => _(xs => f._(x)._(foldr._(f)._(z)._(xs)))))))); -export const foldrz: (f: (x: T) => Lazy<(a: T) => T>) => Lazy<(xs: List) => T> - = _f => _(_z => undef); +export const foldrz: L<(f: L<(x: T) => L<(a: T) => T>>) => L<(xs: List) => T>> + = _(_f => _(_z => undef)); -export const map: (f: (x: T) => R) => Lazy<(xs: List) => List> - = f => _(xs => xs.then(xs => xs(Nil).then(e=>e(x =>_( xs => Cons(f(x)).then(e=>e(map(f).then(e=>e(xs))))))))); +export const map: L<(f: L<(x: T) => R>) => L<(xs: List) => List>> + = + _((f: L<(x: T) => R>) => + _((xs: List) => xs._(Nil)._(_(x => _(xs => Cons._(f._(x))._(map._(f)._(xs))))))); -export const filter: (f: (x: T) => Bool) => Lazy<(xs: List) => List> - = (f: (x: T) => Bool) => _((xs: List) => xs.then(xs => xs(Nil).then(e=>e(x => _(xs => iif>(f(x)).then(e=>e(Cons(x).then(e=>e(filter(f).then(e=>e(xs))))).then(e=>e(filter(f).then(e=>e(xs)))))))))); +export const filter: L<(f: L<(x: T) => Bool>) => L<(xs: List) => List>> + = + _((f: L<(x: T) => Bool>) => + _((xs: List) => xs._(Nil)._(_(x => _(xs => iif._(f._(x))._(Cons._(x)._(filter._(f)._(xs)))._(filter._(f)._(xs))))))); -export const fromArray: (xs: T[]) => List - = xs => xs.length === 0 ? Nil : new Lazy(() => Cons(xs[0]).then(e=>e(fromArray(xs.slice(1)))).value); +export const fromArray: (xs: T[]) => List + = xs => xs.length === 0 ? Nil : Cons._(xs[0])._(new L(() => fromArray(xs.slice(1)).value)); export const fromNumberArray: (xs: number[]) => List - = xs => xs.length === 0 ? Nil : new Lazy(() => Cons(fromNumber(xs[0])).then(e=>e(fromNumberArray(xs.slice(1)))).value); + = xs => xs.length === 0 ? Nil : Cons._(fromNumber(xs[0]))._(new L(() => fromNumberArray(xs.slice(1)).value)); -export const toArray: >(xs: List) => R[] - = >(xs: List) => xs.then(xs => xs(_([] as R[] as unknown as Q)).then(e=>e(x => _(xs => _([x.value, ...toArray(xs)] as unknown as Q))))).value as unknown as R[]; +export const toArray: (xs: List) => P[] + = xs => toNative(xs._(fromNative([]))._(_(x => _(xs => fromNative([x, ...toArray(xs)]))))); export const toNumberArray: (xs: List) => number[] - = xs => xs.then(xs => xs(_([] as number[]as unknown as Q)).then(e=>e(x => _(xs => _([toNumber(x), ...toNumberArray(xs)]as unknown as Q))))).value as unknown as number[]; + = xs => toNative(xs._(fromNative([]))._(_(x => _(xs => fromNative([toNumber(x), ...toNumberArray(xs)]))))); diff --git a/src/num.ts b/src/num.ts index 2ece2aa..077263e 100644 --- a/src/num.ts +++ b/src/num.ts @@ -1,40 +1,40 @@ -import { Bool, not, True } from './bool'; -import { Lazy, Q, V, _, id } from './core'; +import { Bool, False, True } from './bool'; +import { L, P, _, fromNative, id, toNative } from './core'; -export type Num = Lazy<(z: T) => Lazy<(n: (p: Num) => T) => T>>; +export type Num = L<(z: T) => L<(n: L<(p: Num) => T>) => T>>; export const Zero: Num = _(z => _(_n => z)) as Num; -export const Succ: (p: Num) => Num - = p => _(_z => _(n => n(p))); +export const Succ: L<(p: Num) => Num> + = _(p => _(_z => _(n => n._(p)))); -export const ifz: (n: Num) => Lazy<(t: T) => Lazy<(f: T) => T>> - = n => _(t => _(f => n.then(n => n(t).then(e => e(_ => f))))); +export const ifz: L<(n: Num) => L<(t: T) => L<(f: T) => T>>> + = _(n => _(t => _(f => n._(t)._(_(_ => f))))); -export const succ: (n: Num) => Num +export const succ: L<(n: Num) => Num> = Succ; -export const pred: (n: Num) => Num - = n => n.then(n => n(Zero).then(e=>e(id))); +export const pred: L<(n: Num) => Num> + = _(n => n._(Zero)._(id)); -export const even: (n: Num) => Bool - = n => n.then(n => n(True).then(e=>e(odd))); +export const even: L<(n: Num) => Bool> + = _(n => n._(True)._(odd)); -export const odd: (n: Num) => Bool - = n => not(even(n)); +export const odd: L<(n: Num) => Bool> + = _(n => n._(False)._(even)); -export const sum: (l: Num) => Lazy<(r: Num) => Num> - = l => _(r => r.then(r => r(l).then(e=>e(t=>sum(Succ(l)).then(e=>e(t)))))); +export const sum: L<(l: Num) => L<(r: Num) => Num>> + = _(l => _(r => r._(l)._(_(t => sum._(Succ._(l))._(t))))); -export const sub: (l: Num) => Lazy<(r: Num) => Num> - = l => _(r => r.then(r => r(l).then(e=>e(pr => l.then(l => l(Zero).then(e=>e(pl => sub(pl).then(e=>e(pr))))))))); +export const sub: L<(l: Num) => L<(r: Num) => Num>> + = _(l => _(r => r._(l)._(_(pr => l._(Zero)._(_(pl => sub._(pl)._(pr))))))); -export const mul: (l: Num) => Lazy<(r: Num) => Num> - = l => _(r => l.then(l => l(Zero).then(e=>e(pl => sum(r).then(e=>e(mul(pl).then(e=>e(r)))))))); +export const mul: L<(l: Num) => L<(r: Num) => Num>> + = _(l => _(r => l._(Zero)._(_(pl => sum._(r)._(mul._(pl)._(r)))))); export const fromNumber: (n: number) => Num - = n => !n ? Zero : new Lazy(() => Succ(fromNumber(n - 1)).value); + = n => !n ? Zero : Succ._(new L(() => fromNumber(n - 1).value)); export const toNumber: (n: Num) => number - = n => n.then(n => n(_(0 as unknown as Q)).then(e=>e(p => _((1 + toNumber(p)) as unknown as Q)))).value as unknown as number; + = n => toNative(n._(fromNative(0))._(_(p => fromNative(1 + toNumber(p))))); diff --git a/test/bool.spec.ts b/test/bool.spec.ts index 923de6d..b1cf979 100644 --- a/test/bool.spec.ts +++ b/test/bool.spec.ts @@ -1,116 +1,115 @@ import { describe, expect, it } from '@jest/globals'; -import { _, Q } from '../src/core'; -import { True, False, iif, and, not, or, xor, toBoolean, fromBoolean } from '../src/bool'; +import { toBoolean as $, False, True, fromBoolean as _, and, iif, not, or, xor } from '../src/bool'; describe('Bool', () => { describe('toBoolean', () => { it('converts True', () => { - expect(toBoolean(True)).toBe(true); + expect($(True)).toBe(true); }); it('converts False', () => { - expect(toBoolean(False)).toBe(false); + expect($(False)).toBe(false); }); }); describe('fromBoolean', () => { it('converts true', () => { - expect(toBoolean(fromBoolean(true))).toBe(true); + expect($(_(true))).toBe(true); }); it('converts false', () => { - expect(toBoolean(fromBoolean(false))).toBe(false); + expect($(_(false))).toBe(false); }); }); describe('iif', () => { it('returns true argument', () => { - expect(iif).toDeferEvaluationOf(False, expect.skipped(_(true as unknown as Q)), _(false as unknown as Q)); - expect(iif(True).then(e => e(_(true as unknown as Q)).then(e => e(_(false as unknown as Q))))).toEvaluateTo(true); + expect(iif).toDeferEvaluationOf(False, expect.skipped(True), False); + expect($(iif._(True)._(True)._(False))).toBe(true); }); it('returns false argument', () => { - expect(iif).toDeferEvaluationOf(True, _(true as unknown as Q), expect.skipped(_(false as unknown as Q))); - expect(iif(False).then(e => e(_(true as unknown as Q)).then(e => e(_(false as unknown as Q))))).toEvaluateTo(false); + expect(iif).toDeferEvaluationOf(True, True, expect.skipped(False)); + expect($(iif._(False)._(True)._(False))).toBe(false); }); }); describe('not', () => { it('not False is True', () => { expect(not).toDeferEvaluationOf(False); - expect(toBoolean(not(False))).toBe(true); + expect($(not._(False))).toBe(true); }); it('not True is False', () => { expect(not).toDeferEvaluationOf(True); - expect(toBoolean(not(True))).toBe(false); + expect($(not._(True))).toBe(false); }); }); describe('and', () => { it('False and False is False', () => { expect(and).toDeferEvaluationOf(False, expect.skipped(False)); - expect(toBoolean(and(False).then(e => e(False)))).toBe(false); + expect($(and._(False)._(False))).toBe(false); }); it('False and True is False', () => { expect(and).toDeferEvaluationOf(False, expect.skipped(True)); - expect(toBoolean(and(False).then(e => e(True)))).toBe(false); + expect($(and._(False)._(True))).toBe(false); }); it('True and False is False', () => { expect(and).toDeferEvaluationOf(True, False); - expect(toBoolean(and(True).then(e => e(False)))).toBe(false); + expect($(and._(True)._(False))).toBe(false); }); it('True and True is True', () => { expect(and).toDeferEvaluationOf(True, True); - expect(toBoolean(and(True).then(e => e(True)))).toBe(true); + expect($(and._(True)._(True))).toBe(true); }); }); describe('or', () => { it('False or False is False', () => { expect(or).toDeferEvaluationOf(False, False); - expect(toBoolean(or(False).then(e => e(False)))).toBe(false); + expect($(or._(False)._(False))).toBe(false); }); it('False or True is True', () => { expect(or).toDeferEvaluationOf(False, True); - expect(toBoolean(or(False).then(e => e(True)))).toBe(true); + expect($(or._(False)._(True))).toBe(true); }); it('True or False is True', () => { expect(or).toDeferEvaluationOf(True, expect.skipped(False)); - expect(toBoolean(or(True).then(e => e(False)))).toBe(true); + expect($(or._(True)._(False))).toBe(true); }); it('True or True is True', () => { expect(or).toDeferEvaluationOf(True, expect.skipped(True)); - expect(toBoolean(or(True).then(e => e(True)))).toBe(true); + expect($(or._(True)._(True))).toBe(true); }); }); describe('xor', () => { it('False xor False is False', () => { expect(xor).toDeferEvaluationOf(False, False); - expect(toBoolean(xor(False).then(e => e(False)))).toBe(false); + expect($(xor._(False)._(False))).toBe(false); }); it('False xor True is True', () => { expect(xor).toDeferEvaluationOf(False, True); - expect(toBoolean(xor(False).then(e => e(True)))).toBe(true); + expect($(xor._(False)._(True))).toBe(true); }); it('True xor False is True', () => { expect(xor).toDeferEvaluationOf(True, False); - expect(toBoolean(xor(True).then(e => e(False)))).toBe(true); + expect($(xor._(True)._(False))).toBe(true); }); it('True xor True is False', () => { expect(xor).toDeferEvaluationOf(True, True); - expect(toBoolean(xor(True).then(e => e(True)))).toBe(false); + expect($(xor._(True)._(True))).toBe(false); }); }); }); diff --git a/test/core.spec.ts b/test/core.spec.ts index 1b7a58d..4f28893 100644 --- a/test/core.spec.ts +++ b/test/core.spec.ts @@ -1,16 +1,16 @@ import { describe, expect, it } from '@jest/globals'; -import { _, id, cnst, Q } from '../src/core'; +import { _, cnst, fromNative, id, toNative } from '../src/core'; describe('id', () => { it('returns first argument', () => { - expect(id).toDeferEvaluationOf(null); - expect(id(_(null as unknown as Q))).toEvaluateTo(null); + expect(id).toDeferEvaluationOf('first'); + expect(toNative(id._(fromNative('first')))).toBe('first'); }); }); describe('cnst', () => { it('returns first argument after receiving second', () => { - // expect(cnst).toDeferEvaluationOf(null, expect.skipped(null)); - expect(cnst(_(null as unknown as Q)).then(e => e(_('whatever' as unknown as Q)))).toEvaluateTo(null); + expect(cnst).toDeferEvaluationOf('first', expect.skipped(fromNative('second'))); + expect(toNative(cnst._(fromNative('first'))._(fromNative('second')))).toBe('first'); }); }); diff --git a/test/list.spec.ts b/test/list.spec.ts index 45d7e4e..e6518c4 100644 --- a/test/list.spec.ts +++ b/test/list.spec.ts @@ -1,209 +1,208 @@ import { describe, expect, it } from '@jest/globals'; -import { $, _, Lazy, Q } from '../src/core'; -import { toNumber, Zero, succ, Num, Succ, odd, sum } from '../src/num'; -import { Cons, filter, foldl, foldlz, foldr, foldrz, fromArray, fromNumberArray, head, List, map, Nil, tail, toArray, toNumberArray } from '../src/list'; +import { L, toNative } from '../src/core'; +import { toNumber as $n, Num, Succ, Zero, fromNumber as _n, odd, succ, sum } from '../src/num'; +import { toArray as $, toNumberArray as $na, Cons, List, Nil, fromArray as _, fromNumberArray as _na, filter, foldl, foldlz, foldr, foldrz, head, map, tail } from '../src/list'; describe('List', () => { - // const iterate: (n: number) => List> = n => new Lazy(() => Cons(_(n)).then(e => e(iterate(n + 1))).value); - const niterate: (n: Num) => List = n => new Lazy(() => Cons(n).then(e => e(niterate(Succ(n)))).value); + const iterate: (n: Num) => List = n => new L(() => Cons._(n)._(iterate(Succ._(n))).value); describe('toArray', () => { it('converts []', () => { - expect(toArray(Nil)).toEqual([]); + expect($(Nil)).toEqual([]); }); it('converts [0]', () => { - expect(toArray(Cons(_(0 as unknown as Q)).then(e => e(Nil)))).toEqual([0]); + expect($(Cons._(_n(0))._(Nil)).map($n)).toEqual([0]); }); it('converts [0, 1]', () => { - expect(toArray(Cons(_(0 as unknown as Q)).then(e => e(Cons(_(1 as unknown as Q)).then(e => e(Nil)))))).toEqual([0, 1]); + expect($(Cons._(_n(0))._(Cons._(_n(1))._(Nil))).map($n)).toEqual([0, 1]); }); }); describe('fromArray', () => { it('converts []', () => { - expect(toArray(fromArray([]))).toEqual([]); + expect($(_([]))).toEqual([]); }); it('converts [0]', () => { - expect(toArray(fromArray([_(0 as unknown as Q)]))).toEqual([0]); + expect($(_([0].map(_n))).map($n)).toEqual([0]); }); it('converts 2', () => { - expect(toArray(fromArray([_(0 as unknown as Q), _(1 as unknown as Q)]))).toEqual([0, 1]); + expect($(_([0, 1].map(_n))).map($n)).toEqual([0, 1]); }); }); describe('head', () => { it('returns nothing from empty list', () => { - expect(() => head(Nil)).not.toThrow(); - expect(() => $(head(Nil))).toThrow(); + expect(() => head._(Nil)).not.toThrow(); + expect(() => toNative(head._(Nil))).toThrow(); }); it('returns only item', () => { - expect(head).toDeferEvaluationOf(Cons(_(0 as unknown as Q)).then(e => e(Nil))); - expect(head(Cons(_(0 as unknown as Q)).then(e => e(Nil)))).toEvaluateTo(0); + expect(head).toDeferEvaluationOf(_na([0])); + expect($n(head._(_na([0])))).toBe(0); }); it('returns first item', () => { - expect(head).toDeferEvaluationOf(Cons(_(0 as unknown as Q)).then(e => e(Cons(_(1 as unknown as Q)).then(e => e(Nil))))); - expect(head(Cons(_(0 as unknown as Q)).then(e => e(Cons(_(1 as unknown as Q)).then(e => e(Nil)))))).toEvaluateTo(0); + expect(head).toDeferEvaluationOf(_na([0, 1])); + expect($n(head._(_na([0, 1])))).toBe(0); }); it('handles infinite lists', () => { - expect(toNumber(head(niterate(Zero)))).toBe(0); + expect($n(head._(iterate(Zero)))).toBe(0); }); }); describe('tail', () => { it('drops nothing from empty list', () => { - expect(() => tail(Nil)).not.toThrow(); - expect(() => toArray(tail(Nil))).toThrow(); + expect(() => tail._(Nil)).not.toThrow(); + expect(() => $na(tail._(Nil))).toThrow(); }); it('drops only item', () => { - expect(tail).toDeferEvaluationOf(Cons(_(0 as unknown as Q)).then(e => e(Nil))); - expect(toArray(tail(Cons(_(0 as unknown as Q)).then(e => e(Nil))))).toEqual([]); + expect(tail).toDeferEvaluationOf(_na([0])); + expect($na(tail._(_na([0])))).toEqual([]); }); it('drops first item', () => { - expect(tail).toDeferEvaluationOf(Cons(_(0 as unknown as Q)).then(e => e(Cons(_(1 as unknown as Q)).then(e => e(Nil))))); - expect(toArray(tail(Cons(_(0 as unknown as Q)).then(e => e(Cons(_(1 as unknown as Q)).then(e => e(Nil))))))).toEqual([1]); + expect(tail).toDeferEvaluationOf(_na([0, 1])); + expect($na(tail._(_na([0, 1])))).toEqual([1]); }); it('handles infinite lists', () => { - expect(toNumber(head(tail(niterate(Zero))))).toBe(1); + expect($n(head._(tail._(iterate(Zero))))).toBe(1); }); }); describe('foldl', () => { it('folds empty list', () => { - expect(foldl(sum)).toDeferEvaluationOf(Zero, fromNumberArray([])); - expect(toNumber(foldl(sum).then(e => e(Zero).then(e => e(fromNumberArray([])))))).toBe(0); + expect(foldl._(sum)).toDeferEvaluationOf(Zero, _na([])); + expect($n(foldl._(sum)._(Zero)._(_na([])))).toBe(0); }); it('folds single item', () => { - expect(foldl(sum)).toDeferEvaluationOf(Zero, fromNumberArray([1])); - expect(toNumber(foldl(sum).then(e => e(Zero).then(e => e(fromNumberArray([1])))))).toBe(1); + expect(foldl._(sum)).toDeferEvaluationOf(Zero, _na([1])); + expect($n(foldl._(sum)._(Zero)._(_na([1])))).toBe(1); }); it('folds several items', () => { - expect(foldl(sum)).toDeferEvaluationOf(Zero, fromNumberArray([1, 2])); - expect(toNumber(foldl(sum).then(e => e(Zero).then(e => e(fromNumberArray([1, 2])))))).toBe(3); + expect(foldl._(sum)).toDeferEvaluationOf(Zero, _na([1, 2])); + expect($n(foldl._(sum)._(Zero)._(_na([1, 2])))).toBe(3); }); }); describe('foldlz', () => { it('does not fold empty list', () => { - expect(() => foldlz(sum).then(e => e(Nil))).not.toThrow(); - expect(() => toNumber(foldlz(sum).then(e => e(Nil)))).toThrow(); + expect(() => foldlz._(sum)._(Nil)).not.toThrow(); + expect(() => $n(foldlz._(sum)._(Nil))).toThrow(); }); it('folds single item', () => { - expect(foldlz(sum)).toDeferEvaluationOf(fromNumberArray([1])); - expect(toNumber(foldlz(sum).then(e => e(fromNumberArray([1]))))).toBe(1); + expect(foldlz._(sum)).toDeferEvaluationOf(_na([1])); + expect($n(foldlz._(sum)._(_na([1])))).toBe(1); }); it('folds several items', () => { - expect(foldlz(sum)).toDeferEvaluationOf(fromNumberArray([1, 2])); - expect(toNumber(foldlz(sum).then(e => e(fromNumberArray([1, 2]))))).toBe(3); + expect(foldlz._(sum)).toDeferEvaluationOf(_na([1, 2])); + expect($n(foldlz._(sum)._(_na([1, 2])))).toBe(3); }); }); describe('foldr', () => { it('folds empty list', () => { - expect(foldr(sum)).toDeferEvaluationOf(Zero, fromNumberArray([])); - expect(toNumber(foldr(sum).then(e => e(Zero).then(e => e(fromNumberArray([])))))).toBe(0); + expect(foldr._(sum)).toDeferEvaluationOf(Zero, _na([])); + expect($n(foldr._(sum)._(Zero)._(_na([])))).toBe(0); }); it('folds single item', () => { - expect(foldr(sum)).toDeferEvaluationOf(Zero, fromNumberArray([1])); - expect(toNumber(foldr(sum).then(e => e(Zero).then(e => e(fromNumberArray([1])))))).toBe(1); + expect(foldr._(sum)).toDeferEvaluationOf(Zero, _na([1])); + expect($n(foldr._(sum)._(Zero)._(_na([1])))).toBe(1); }); it('folds several items', () => { - expect(foldr(sum)).toDeferEvaluationOf(Zero, fromNumberArray([1, 2])); - expect(toNumber(foldr(sum).then(e => e(Zero).then(e => e(fromNumberArray([1, 2])))))).toBe(3); + expect(foldr._(sum)).toDeferEvaluationOf(Zero, _na([1, 2])); + expect($n(foldr._(sum)._(Zero)._(_na([1, 2])))).toBe(3); }); // it('handles infinite lists', () => { // expect(foldr, Lazy>(x => _(a => // iif> - // (x.then(x => fromBoolean(x === 0))) - // .then(e => e - // (x).then(e => e - // (x.then(x => a.then(a => _(x + a))))))) - // ).then(e => e(_(0 as unknown as Q)).then(e => e(iterate(-5))))).toEvaluateTo(-15); + // (x.call(x => fromBoolean(x === 0))) + // .call( + // (x).call( + // (x.call(x => a.call(a => _(x + a))))))) + // ).call((fromNumber(0)).call((iterate(-5))))).toEvaluateTo(-15); // }); }); describe('foldrz', () => { it('does not fold empty list', () => { - expect(() => foldrz(sum).then(e => e(Nil))).not.toThrow(); - expect(() => toNumber(foldrz(sum).then(e => e(Nil)))).toThrow(); + expect(() => foldrz._(sum)._(Nil)).not.toThrow(); + expect(() => $n(foldrz._(sum)._(Nil))).toThrow(); }); it.failing('folds single item', () => { - expect(foldrz(sum)).toDeferEvaluationOf(fromNumberArray([1])); - expect(toNumber(foldrz(sum).then(e => e(fromNumberArray([1]))))).toBe(1); + expect(foldrz._(sum)).toDeferEvaluationOf(_na([1])); + expect($n(foldrz._(sum)._(_na([1])))).toBe(1); }); it.failing('folds several items', () => { - expect(foldrz(sum)).toDeferEvaluationOf(fromNumberArray([1, 2])); - expect(toNumber(foldrz(sum).then(e => e(fromNumberArray([1, 2]))))).toBe(3); + expect(foldrz._(sum)).toDeferEvaluationOf(_na([1, 2])); + expect($n(foldrz._(sum)._(_na([1, 2])))).toBe(3); }); // it.failing('handles infinite lists', () => { // expect(foldrz>(x => _(a => // iif> - // (x.then(x => fromBoolean(x === 0))) - // .then(e => e - // (x).then(e => e - // (x.then(x => a.then(a => _(x + a))))))) - // ).then(e => e(iterate(-5)))).toEvaluateTo(-10); + // (x.call(x => fromBoolean(x === 0))) + // .call( + // (x).call( + // (x.call(x => a.call(a => _(x + a))))))) + // ).call((iterate(-5)))).toEvaluateTo(-10); // }); }); describe('map', () => { it('maps empty list', () => { - expect(map(succ)).toDeferEvaluationOf(fromNumberArray([])); - expect(toNumberArray(map(succ).then(e => e(fromNumberArray([]))))).toEqual([]); + expect(map._(succ)).toDeferEvaluationOf(_na([])); + expect($na(map._(succ)._(_na([])))).toEqual([]); }); it('maps only item', () => { - expect(map(succ)).toDeferEvaluationOf(fromNumberArray([0])); - expect(toNumberArray(map(succ).then(e => e(fromNumberArray([0]))))).toEqual([1]); + expect(map._(succ)).toDeferEvaluationOf(_na([0])); + expect($na(map._(succ)._(_na([0])))).toEqual([1]); }); it('maps several items', () => { - expect(map(succ)).toDeferEvaluationOf(fromNumberArray([0, 1])); - expect(toNumberArray(map(succ).then(e => e(fromNumberArray([0, 1]))))).toEqual([1, 2]); + expect(map._(succ)).toDeferEvaluationOf(_na([0, 1])); + expect($na(map._(succ)._(_na([0, 1])))).toEqual([1, 2]); }); it('handles infinite lists', () => { - expect(toNumber(head(map(succ).then(e => e(niterate(Zero)))))).toBe(1); + expect($n(head._(map._(succ)._(iterate(Zero))))).toBe(1); }); }); describe('filter', () => { it('filter empty list', () => { - expect(filter(odd)).toDeferEvaluationOf(fromNumberArray([])); - expect(toNumberArray(filter(odd).then(e => e(fromNumberArray([]))))).toEqual([]); + expect(filter._(odd)).toDeferEvaluationOf(_na([])); + expect($na(filter._(odd)._(_na([])))).toEqual([]); }); it('filters only item', () => { - expect(filter(odd)).toDeferEvaluationOf(fromNumberArray([0])); - expect(toNumberArray(filter(odd).then(e => e(fromNumberArray([]))))).toEqual([]); + expect(filter._(odd)).toDeferEvaluationOf(_na([0])); + expect($na(filter._(odd)._(_na([])))).toEqual([]); }); it('filters several items', () => { - expect(filter(odd)).toDeferEvaluationOf(fromNumberArray([0, 1])); - expect(toNumberArray(filter(odd).then(e => e(fromNumberArray([0, 1]))))).toEqual([1]); + expect(filter._(odd)).toDeferEvaluationOf(_na([0, 1])); + expect($na(filter._(odd)._(_na([0, 1])))).toEqual([1]); }); it('handles infinite lists', () => { - expect(toNumber(head(filter(odd).then(e => e(niterate(Zero)))))).toBe(1); + expect($n(head._(filter._(odd)._(iterate(Zero))))).toBe(1); }); }); }); diff --git a/test/num.spec.ts b/test/num.spec.ts index b103434..d8ed243 100644 --- a/test/num.spec.ts +++ b/test/num.spec.ts @@ -1,166 +1,165 @@ import { describe, expect, it } from '@jest/globals'; -import { _, Q } from '../src/core'; -import { Num, Zero, Succ, sum, succ, pred, ifz, fromNumber, toNumber, sub, mul } from '../src/num'; +import { toNumber as $, Num, Succ, Zero, fromNumber as _, ifz, mul, pred, sub, succ, sum } from '../src/num'; describe('Num', () => { describe('toNumber', () => { it('converts 0', () => { - expect(toNumber(Zero)).toBe(0); + expect($(Zero)).toBe(0); }); it('converts 1', () => { - expect(toNumber(Succ(Zero))).toBe(1); + expect($(Succ._(Zero))).toBe(1); }); it('converts 2', () => { - expect(toNumber(Succ(Succ(Zero)))).toBe(2); + expect($(Succ._(Succ._(Zero)))).toBe(2); }); }); describe('fromNumber', () => { it('converts 0', () => { - expect(toNumber(fromNumber(0))).toBe(0); + expect($(_(0))).toBe(0); }); it('converts 1', () => { - expect(toNumber(fromNumber(1))).toBe(1); + expect($(_(1))).toBe(1); }); it('converts 2', () => { - expect(toNumber(fromNumber(2))).toBe(2); + expect($(_(2))).toBe(2); }); }); describe('ifz', () => { it('returns zero branch', () => { - expect(ifz).toDeferEvaluationOf(fromNumber(0), true, false); - expect(ifz(fromNumber(0)).then(e => e(_(true as unknown as Q)).then(e => e(_(false as unknown as Q))))).toEvaluateTo(true); + expect(ifz).toDeferEvaluationOf(_(0), true, false); + expect($(ifz._(_(0))._(_(0))._(_(1)))).toBe(0); }); it('returns non-zero branch', () => { - expect(ifz).toDeferEvaluationOf(fromNumber(1), true, false); - expect(ifz(fromNumber(1)).then(e => e(_(true as unknown as Q)).then(e => e(_(false as unknown as Q))))).toEvaluateTo(false); + expect(ifz).toDeferEvaluationOf(_(1), true, false); + expect($(ifz._(_(1))._(_(0))._(_(1)))).toBe(1); }); it('returns non-zero branch', () => { - expect(ifz).toDeferEvaluationOf(fromNumber(100), true, false); - expect(ifz(fromNumber(10)).then(e => e(_(true as unknown as Q)).then(e => e(_(false as unknown as Q))))).toEvaluateTo(false); + expect(ifz).toDeferEvaluationOf(_(100), true, false); + expect($(ifz._(_(10))._(_(0))._(_(1)))).toBe(1); }); it('deeply lazy', () => { - const alot: Num = fromNumber(1000000); - expect(ifz(Succ(alot)).then(e => e(_(true as unknown as Q)).then(e => e(_(false as unknown as Q))))).toEvaluateTo(false); + const alot: Num = _(1000000); + expect($(ifz._(Succ._(alot))._(_(0))._(_(1)))).toBe(1); expect(alot.evaluated).toBe(false); }); }); describe('succ', () => { it('succ 0 is 1', () => { - expect(succ).toDeferEvaluationOf(fromNumber(0)); - expect(toNumber(succ(fromNumber(0)))).toBe(1); + expect(succ).toDeferEvaluationOf(_(0)); + expect($(succ._(_(0)))).toBe(1); }); it('succ 1 is 2', () => { - expect(succ).toDeferEvaluationOf(fromNumber(0)); - expect(toNumber(succ(fromNumber(1)))).toBe(2); + expect(succ).toDeferEvaluationOf(_(0)); + expect($(succ._(_(1)))).toBe(2); }); it('succ 10 is 11', () => { - expect(succ).toDeferEvaluationOf(fromNumber(10)); - expect(toNumber(succ(fromNumber(10)))).toBe(11); + expect(succ).toDeferEvaluationOf(_(10)); + expect($(succ._(_(10)))).toBe(11); }); }); describe('pred', () => { it('pred 0 is 0', () => { - expect(pred).toDeferEvaluationOf(fromNumber(0)); - expect(toNumber(pred(fromNumber(0)))).toBe(0); + expect(pred).toDeferEvaluationOf(_(0)); + expect($(pred._(_(0)))).toBe(0); }); it('pred 1 is 0', () => { - expect(pred).toDeferEvaluationOf(fromNumber(0)); - expect(toNumber(pred(fromNumber(1)))).toBe(0); + expect(pred).toDeferEvaluationOf(_(0)); + expect($(pred._(_(1)))).toBe(0); }); it('pred 10 is 9', () => { - expect(pred).toDeferEvaluationOf(fromNumber(10)); - expect(toNumber(pred(fromNumber(10)))).toBe(9); + expect(pred).toDeferEvaluationOf(_(10)); + expect($(pred._(_(10)))).toBe(9); }); }); describe('sum', () => { it('0 sum 0 is 0', () => { - expect(sum).toDeferEvaluationOf(fromNumber(0), fromNumber(0)); - expect(toNumber(sum(fromNumber(0)).then(e => e(fromNumber(0))))).toBe(0); + expect(sum).toDeferEvaluationOf(_(0), _(0)); + expect($(sum._(_(0))._(_(0)))).toBe(0); }); it('0 sum 1 is 1', () => { - expect(sum).toDeferEvaluationOf(fromNumber(0), fromNumber(1)); - expect(toNumber(sum(fromNumber(0)).then(e => e(fromNumber(1))))).toBe(1); + expect(sum).toDeferEvaluationOf(_(0), _(1)); + expect($(sum._(_(0))._(_(1)))).toBe(1); }); it('1 sum 0 is 1', () => { - expect(sum).toDeferEvaluationOf(fromNumber(1), fromNumber(0)); - expect(toNumber(sum(fromNumber(1)).then(e => e(fromNumber(0))))).toBe(1); + expect(sum).toDeferEvaluationOf(_(1), _(0)); + expect($(sum._(_(1))._(_(0)))).toBe(1); }); it('3 sum 4 is 7', () => { - expect(sum).toDeferEvaluationOf(fromNumber(3), fromNumber(4)); - expect(toNumber(sum(fromNumber(3)).then(e => e(fromNumber(4))))).toBe(7); + expect(sum).toDeferEvaluationOf(_(3), _(4)); + expect($(sum._(_(3))._(_(4)))).toBe(7); }); }); describe('sub', () => { it('0 sub 0 is 0', () => { - expect(sub).toDeferEvaluationOf(fromNumber(0), fromNumber(0)); - expect(toNumber(sub(fromNumber(0)).then(e => e(fromNumber(0))))).toBe(0); + expect(sub).toDeferEvaluationOf(_(0), _(0)); + expect($(sub._(_(0))._(_(0)))).toBe(0); }); it('0 sub 1 is 0', () => { - expect(sub).toDeferEvaluationOf(fromNumber(0), fromNumber(1)); - expect(toNumber(sub(fromNumber(0)).then(e => e(fromNumber(1))))).toBe(0); + expect(sub).toDeferEvaluationOf(_(0), _(1)); + expect($(sub._(_(0))._(_(1)))).toBe(0); }); it('1 sub 0 is 1', () => { - expect(sub).toDeferEvaluationOf(fromNumber(1), fromNumber(0)); - expect(toNumber(sub(fromNumber(1)).then(e => e(fromNumber(0))))).toBe(1); + expect(sub).toDeferEvaluationOf(_(1), _(0)); + expect($(sub._(_(1))._(_(0)))).toBe(1); }); it('7 sub 4 is 3', () => { - expect(sub).toDeferEvaluationOf(fromNumber(7), fromNumber(4)); - expect(toNumber(sub(fromNumber(7)).then(e => e(fromNumber(4))))).toBe(3); + expect(sub).toDeferEvaluationOf(_(7), _(4)); + expect($(sub._(_(7))._(_(4)))).toBe(3); }); }); describe('mul', () => { it('0 mul 0 is 0', () => { - expect(mul).toDeferEvaluationOf(fromNumber(0), fromNumber(0)); - expect(toNumber(mul(fromNumber(0)).then(e => e(fromNumber(0))))).toBe(0); + expect(mul).toDeferEvaluationOf(_(0), _(0)); + expect($(mul._(_(0))._(_(0)))).toBe(0); }); it('0 mul 10 is 0', () => { - expect(mul).toDeferEvaluationOf(fromNumber(0), expect.skipped(fromNumber(10))); - expect(toNumber(mul(fromNumber(0)).then(e => e(fromNumber(10))))).toBe(0); + expect(mul).toDeferEvaluationOf(_(0), expect.skipped(_(10))); + expect($(mul._(_(0))._(_(10)))).toBe(0); }); it('10 mul 0 is 0', () => { - expect(mul).toDeferEvaluationOf(fromNumber(10), fromNumber(0)); - expect(toNumber(mul(fromNumber(1)).then(e => e(fromNumber(0))))).toBe(0); + expect(mul).toDeferEvaluationOf(_(10), _(0)); + expect($(mul._(_(1))._(_(0)))).toBe(0); }); it('1 mul 10 is 10', () => { - expect(mul).toDeferEvaluationOf(fromNumber(1), fromNumber(10)); - expect(toNumber(mul(fromNumber(1)).then(e => e(fromNumber(10))))).toBe(10); + expect(mul).toDeferEvaluationOf(_(1), _(10)); + expect($(mul._(_(1))._(_(10)))).toBe(10); }); it('10 mul 1 is 10', () => { - expect(mul).toDeferEvaluationOf(fromNumber(10), fromNumber(1)); - expect(toNumber(mul(fromNumber(10)).then(e => e(fromNumber(1))))).toBe(10); + expect(mul).toDeferEvaluationOf(_(10), _(1)); + expect($(mul._(_(10))._(_(1)))).toBe(10); }); it('3 mul 4 is 12', () => { - expect(mul).toDeferEvaluationOf(fromNumber(3), fromNumber(4)); - expect(toNumber(mul(fromNumber(3)).then(e => e(fromNumber(4))))).toBe(12); + expect(mul).toDeferEvaluationOf(_(3), _(4)); + expect($(mul._(_(3))._(_(4)))).toBe(12); }); }); }); diff --git a/test/util.ts b/test/util.ts index a3f4b00..852a69f 100644 --- a/test/util.ts +++ b/test/util.ts @@ -1,8 +1,8 @@ import { expect } from '@jest/globals'; import type { MatcherFunction } from 'expect'; -import { $, _, Lazy, V } from '../src/core'; +import { L, P, _, fromNative } from '../src/core'; -class Deferrable { +class Deferrable { constructor( public readonly when: 'always' | 'deferred' | 'never', public readonly what: T) { } @@ -10,25 +10,25 @@ class Deferrable { const toEvaluateTo: MatcherFunction<[expected: unknown]> = function (actual, expected) { - if (!(actual instanceof Lazy)) { + if (!(actual instanceof L)) { throw new TypeError('Actual must be of type Lazy!'); } - if (this.equals($(actual), expected)) { + if (this.equals(fromNative(actual), expected)) { return { - message: () => `expected ${this.utils.printReceived($(actual))} not to evaluate to ${this.utils.printExpected(expected)}`, + message: () => `expected ${this.utils.printReceived(fromNative(actual))} not to evaluate to ${this.utils.printExpected(expected)}`, pass: true, }; } else { return { - message: () => `expected ${this.utils.printReceived($(actual))} to evaluate to ${this.utils.printExpected(expected)}`, + message: () => `expected ${this.utils.printReceived(fromNative(actual))} to evaluate to ${this.utils.printExpected(expected)}`, pass: false, }; } }; -const toDeferEvaluationOf: MatcherFunction<(unknown | Deferrable)[]> = +const toDeferEvaluationOf: MatcherFunction<(unknown | Deferrable

)[]> = function (actual, ...args) { - while (actual instanceof Lazy) { + while (actual instanceof L) { actual = actual.value; } if (typeof actual !== 'function') { @@ -37,16 +37,16 @@ const toDeferEvaluationOf: MatcherFunction<(unknown | Deferrable)[]> = if (this.isNot) { throw new TypeError('`toDeferEvaluationOf` can not be `not`ted, use `always`/`deferred`/`never` on arguments!'); } - const largs: Deferrable[] = args.map(v => + const largs: Deferrable

[] = args.map(v => v instanceof Deferrable ? v - : v instanceof Lazy ? new Deferrable('deferred', _(v.value)) + : v instanceof L ? new Deferrable('deferred', _(v.value)) : new Deferrable('deferred', _(v as any))); - const cargs: Deferrable[] = []; + const cargs: Deferrable

[] = []; let result = actual; for (const la of largs) { - result = result instanceof Lazy ? result.then(e => e(la.what)) : result(la.what); + result = result instanceof L ? result._(la.what) : result(la.what); cargs.push(la); - const mismatchingArg: Deferrable | undefined = cargs.find(v => v.when === 'always' ? !v.what.evaluated : v.what.evaluated); + const mismatchingArg: Deferrable

| undefined = cargs.find(v => v.when === 'always' ? !v.what.evaluated : v.what.evaluated); if (mismatchingArg) { return { message: () => @@ -57,11 +57,11 @@ const toDeferEvaluationOf: MatcherFunction<(unknown | Deferrable)[]> = }; } } - if (!(result instanceof Lazy)) { + if (!(result instanceof L)) { throw new TypeError('Actual did not resolve to value, more arguments expected.'); } - result.value; - const mismatchingArg: Deferrable | undefined = cargs.find(v => v.when === 'never' && v.what.evaluated); + (() => result.value)(); + const mismatchingArg: Deferrable

| undefined = cargs.find(v => v.when === 'never' && v.what.evaluated); if (mismatchingArg) { return { message: () => `expected ${this.utils.printExpected(actual.name)} not to evaluate ${this.utils.printReceived(`${largs.indexOf(mismatchingArg) + 1}th argument`)}`, @@ -86,9 +86,9 @@ expect.skipped = (v) => new Deferrable('never', _(v.value) as any); declare module 'expect' { interface AsymmetricMatchers { - evaluated(value: T): Deferrable; - deferred(value: T): Deferrable; - skipped(value: T): Deferrable; + evaluated(value: T): Deferrable; + deferred(value: T): Deferrable; + skipped(value: T): Deferrable; toEvaluateTo(value: any): void; toDeferEvaluationOf(...args: any[]): void; }