freywar
/
jlc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Curried lambdas

Browse Source
master
Freywar Ulvnaudgari 2 years ago
parent fbe9ba511f
commit 69c5070f9a
9 changed files with 266 additions and 252 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 26
      src/bool.ts
  2. 26
      src/core.ts
  3. 71
      src/list.ts
  4. 44
      src/num.ts
  5. 47
      test/bool.spec.ts
  6. 10
      test/core.spec.ts
  7. 145
      test/list.spec.ts
  8. 111
      test/num.spec.ts
  9. 38
      test/util.ts

26
src/bool.ts
Unescape View File

@ -1,6 +1,6 @@
import { Lazy, Q, V, _ } from './core';
import { L, P, _, fromNative, toNative } from './core';
export type Bool = Lazy<<T extends V>(t: T) => Lazy<(f: T) => T>>;
export type Bool = L<<T extends P>(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: <T extends V>(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<<T extends P>(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)));

26
src/core.ts
Unescape View File

@ -1,4 +1,4 @@
export class Lazy<T extends (v: unknown) => Lazy<any>> {
export class L<T extends (v: unknown) => L<any>> {
protected _value?: T;
constructor(private _eval: () => T) { }
@ -13,23 +13,25 @@ export class Lazy<T extends (v: unknown) => Lazy<any>> {
return this._value = this._eval();
}
public then<R extends V>(f: (v: T) => R): R {
return new Lazy(() => f(this.value).value) as R;
public get _(): T {
return ((p: Parameters<T>[0]) => new L(() => this.value(p).value)) as T;
}
}
export type Q = (v: unknown) => Lazy<any>;
export type P = L<(v: unknown) => L<any>>;
export type V = Lazy<(v: unknown) => Lazy<any>>;
export const _ = <T extends ((v: unknown) => L<any>)>(v: T): L<T> => new L(() => v);
export const _ = <T extends (v: unknown) => Lazy<any>>(v: T): Lazy<T> => new Lazy(() => v);
export const $ = <T extends (v: unknown) => Lazy<any>>(v: Lazy<T>): T => v.value;
export const fromNative: <T>(v: T) => L<any>
= v => new L(() => v as any);
export const toNative: <T>(v: L<any>) => T
= <T>(v: L<any>) => v.value as T;
export const undef: any = new Lazy(() => {
export const undef: any = new L(() => {
throw new Error('undefined');
});
export const id: <T extends V>(v: T) => T
= v => v;
export const cnst: <T extends V> (v: T) => Lazy<(_: unknown) => T>
= v => _(_ => v);
export const id: L<<T extends P>(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>>;

71
src/list.ts
Unescape View File

@ -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<T extends V> = Lazy<<R extends V>(z: R) => Lazy<(f: (x: T) => Lazy<(xs: List<T>) => R>) => R>>;
export type List<T extends P> = L<<R extends P>(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: <T extends V>(x: T) => Lazy<(xs: List<T>) => List<T>>
= <T extends V>(x: T) => _((xs: List<T>) => _(_z => _(f => f(x).then(e=>e(xs)))) as List<T>);
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: <T extends V>(x: T) => Lazy<(xs: List<T>) => List<T>>
export const cons: L<<T extends P>(x: T) => L<(xs: List<T>) => List<T>>>
= Cons;
export const head: <T extends V>(xs: List<T>) => T
= xs => xs.then(xs => xs(undef).then(e=>e(x=>_(_xs=>x))));
export const head: L<<T extends P>(xs: List<T>) => T>
= _(xs => xs._(undef)._(_(x => _(_xs => x))));
export const tail: <T extends V>(xs: List<T>) => List<T>
= xs => xs.then(xs => xs(undef).then(e=>e(_x =>_(xs=>xs))));
export const tail: L<<T extends P>(xs: List<T>) => List<T>>
= _(xs => xs._(undef)._(_(_x => _(xs => xs))));
export const foldl: <T extends V, R extends V>(f: (a: R) => Lazy<(x: T) => R>) => Lazy<(z: R) => Lazy<(xs: List<T>) => 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<<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>>) =>
_((z: R) =>
_((xs: List<T>) => xs._(z)._(_(x =>
_(xs => foldl._(f)._(f._(z)._(x))._(xs)))))));
export const foldlz: <T extends V>(f: (a: T) => Lazy<(x: T) => T>) => Lazy<(xs: List<T>) => 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<<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)._(_(x =>
_(xs => foldl._(f)._(x)._(xs))))));
export const foldr: <T extends V, R extends V>(f: (x: T) => Lazy<(a: R) => R>) => Lazy<(z: R) => Lazy<(xs: List<T>) => 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<<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>>) =>
_((z: R) =>
_((xs: List<T>) => xs._(z)._(_(x => _(xs => f._(x)._(foldr._(f)._(z)._(xs))))))));
export const foldrz: <T extends V>(f: (x: T) => Lazy<(a: T) => T>) => Lazy<(xs: List<T>) => T>
= _f => _(_z => undef);
export const foldrz: L<<T extends P>(f: L<(x: T) => L<(a: T) => T>>) => L<(xs: List<T>) => T>>
= _(_f => _(_z => undef));
export const map: <T extends V, R extends V>(f: (x: T) => R) => Lazy<(xs: List<T>) => List<R>>
= 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<<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>) =>
_((xs: List<T>) => xs._(Nil)._(_(x => _(xs => Cons._(f._(x))._(map._(f)._(xs)))))));
export const filter: <T extends V>(f: (x: T) => Bool) => Lazy<(xs: List<T>) => List<T>>
= <T extends V>(f: (x: T) => Bool) => _((xs: List<T>) => xs.then(xs => xs(Nil).then(e=>e(x => _(xs => iif<List<T>>(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<<T extends P>(f: L<(x: T) => Bool>) => L<(xs: List<T>) => List<T>>>
=
_(<T extends P>(f: L<(x: T) => Bool>) =>
_((xs: List<T>) => xs._(Nil)._(_(x => _(xs => iif._(f._(x))._(Cons._(x)._(filter._(f)._(xs)))._(filter._(f)._(xs)))))));
export const fromArray: <T extends V>(xs: T[]) => List<T>
= xs => xs.length === 0 ? Nil : new Lazy(() => Cons(xs[0]).then(e=>e(fromArray(xs.slice(1)))).value);
export const fromArray: <T extends P>(xs: T[]) => List<T>
= xs => xs.length === 0 ? Nil : Cons._(xs[0])._(new L(() => fromArray(xs.slice(1)).value));
export const fromNumberArray: (xs: number[]) => List<Num>
= 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: <R extends Q, T extends Lazy<R>>(xs: List<T>) => R[]
= <R extends Q, T extends Lazy<R>>(xs: List<T>) => xs.then(xs => xs(_([] as R[] as unknown as Q)).then(e=>e(x => _(xs => _([x.value, ...toArray<R, T>(xs)] as unknown as Q))))).value as unknown as R[];
export const toArray: <T extends P>(xs: List<T>) => P[]
= xs => toNative(xs._(fromNative([]))._(_(x => _(xs => fromNative([x, ...toArray(xs)])))));
export const toNumberArray: (xs: List<Num>) => 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)])))));

44
src/num.ts
Unescape View File

@ -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<<T extends V>(z: T) => Lazy<(n: (p: Num) => T) => T>>;
export type Num = L<<T extends P>(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: <T extends V>(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<<T extends P>(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)))));

47
test/bool.spec.ts
Unescape View File

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

10
test/core.spec.ts
Unescape View File

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

145
test/list.spec.ts
Unescape View File

@ -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<Lazy<number>> = n => new Lazy(() => Cons(_(n)).then(e => e(iterate(n + 1))).value);
const niterate: (n: Num) => List<Num> = n => new Lazy(() => Cons(n).then(e => e(niterate(Succ(n)))).value);
const iterate: (n: Num) => List<Num> = 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<number>, Lazy<number>>(x => _(a =>
// iif<Lazy<number>>
// (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<Lazy<number>>(x => _(a =>
// iif<Lazy<number>>
// (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);
});
});
});

111
test/num.spec.ts
Unescape View File

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

38
test/util.ts
Unescape View File

@ -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<T extends V> {
class Deferrable<T extends P> {
constructor(
public readonly when: 'always' | 'deferred' | 'never',
public readonly what: T) { }
@ -10,25 +10,25 @@ class Deferrable<T extends V> {
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<V>)[]> =
const toDeferEvaluationOf: MatcherFunction<(unknown | Deferrable<P>)[]> =
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<V>)[]> =
if (this.isNot) {
throw new TypeError('`toDeferEvaluationOf` can not be `not`ted, use `always`/`deferred`/`never` on arguments!');
}
const largs: Deferrable<V>[] = args.map(v =>
const largs: Deferrable<P>[] = 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<V>[] = [];
const cargs: Deferrable<P>[] = [];
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<V> | undefined = cargs.find(v => v.when === 'always' ? !v.what.evaluated : v.what.evaluated);
const mismatchingArg: Deferrable<P> | 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<V>)[]> =
};
}
}
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<V> | undefined = cargs.find(v => v.when === 'never' && v.what.evaluated);
(() => result.value)();
const mismatchingArg: Deferrable<P> | 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<T extends V>(value: T): Deferrable<T>;
deferred<T extends V>(value: T): Deferrable<T>;
skipped<T extends V>(value: T): Deferrable<T>;
evaluated<T extends P>(value: T): Deferrable<T>;
deferred<T extends P>(value: T): Deferrable<T>;
skipped<T extends P>(value: T): Deferrable<T>;
toEvaluateTo(value: any): void;
toDeferEvaluationOf(...args: any[]): void;
}

Write Preview
Loading…
Cancel
Save