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

No explicit Lazy

Browse Source
This commit is contained in:
freywar
2024-07-30 21:15:16 +03:00
parent 1c70da5f3b
commit 531c52212d
7 changed files with 139 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/bool.spec.ts
+18 -20
View File
@@ -5,23 +5,21 @@ import { True, False, iif, and, not, or, xor, toBoolean, fromBoolean } from '../
describe('Bool', () => {
describe('toBoolean', () => {
it('converts True', () => {
expect(toBoolean).toDeferEvaluationOf(True);
expect(toBoolean(True)).toEvaluateTo(true);
expect(toBoolean(True)).toBe(true);
});
it('converts False', () => {
expect(toBoolean).toDeferEvaluationOf(False);
expect(toBoolean(False)).toEvaluateTo(false);
expect(toBoolean(False)).toBe(false);
});
});
describe('fromBoolean', () => {
it('converts true', () => {
expect(toBoolean(fromBoolean(true))).toEvaluateTo(true);
expect(toBoolean(fromBoolean(true))).toBe(true);
});
it('converts false', () => {
expect(toBoolean(fromBoolean(false))).toEvaluateTo(false);
expect(toBoolean(fromBoolean(false))).toBe(false);
});
});
@@ -40,79 +38,79 @@ describe('Bool', () => {
describe('not', () => {
it('not False is True', () => {
expect(not).toDeferEvaluationOf(False);
expect(toBoolean(not(False))).toEvaluateTo(true);
expect(toBoolean(not(False))).toBe(true);
});
it('not True is False', () => {
expect(not).toDeferEvaluationOf(True);
expect(toBoolean(not(True))).toEvaluateTo(false);
expect(toBoolean(not(True))).toBe(false);
});
});
describe('and', () => {
it('False and False is False', () => {
expect(and).toDeferEvaluationOf(False, expect.skipped(False));
expect(toBoolean(and(False)(False))).toEvaluateTo(false);
expect(toBoolean(and(False)(False))).toBe(false);
});
it('False and True is False', () => {
expect(and).toDeferEvaluationOf(False, expect.skipped(True));
expect(toBoolean(and(False)(True))).toEvaluateTo(false);
expect(toBoolean(and(False)(True))).toBe(false);
});
it('True and False is False', () => {
expect(and).toDeferEvaluationOf(True, False);
expect(toBoolean(and(True)(False))).toEvaluateTo(false);
expect(toBoolean(and(True)(False))).toBe(false);
});
it('True and True is True', () => {
expect(and).toDeferEvaluationOf(True, True);
expect(toBoolean(and(True)(True))).toEvaluateTo(true);
expect(toBoolean(and(True)(True))).toBe(true);
});
});
describe('or', () => {
it('False or False is False', () => {
expect(or).toDeferEvaluationOf(False, False);
expect(toBoolean(or(False)(False))).toEvaluateTo(false);
expect(toBoolean(or(False)(False))).toBe(false);
});
it('False or True is True', () => {
expect(or).toDeferEvaluationOf(False, True);
expect(toBoolean(or(False)(True))).toEvaluateTo(true);
expect(toBoolean(or(False)(True))).toBe(true);
});
it('True or False is True', () => {
expect(or).toDeferEvaluationOf(True, expect.skipped(False));
expect(toBoolean(or(True)(False))).toEvaluateTo(true);
expect(toBoolean(or(True)(False))).toBe(true);
});
it('True or True is True', () => {
expect(or).toDeferEvaluationOf(True, expect.skipped(True));
expect(toBoolean(or(True)(True))).toEvaluateTo(true);
expect(toBoolean(or(True)(True))).toBe(true);
});
});
describe('xor', () => {
it('False xor False is False', () => {
expect(xor).toDeferEvaluationOf(False, False);
expect(toBoolean(xor(False)(False))).toEvaluateTo(false);
expect(toBoolean(xor(False)(False))).toBe(false);
});
it('False xor True is True', () => {
expect(xor).toDeferEvaluationOf(False, True);
expect(toBoolean(xor(False)(True))).toEvaluateTo(true);
expect(toBoolean(xor(False)(True))).toBe(true);
});
it('True xor False is True', () => {
expect(xor).toDeferEvaluationOf(True, False);
expect(toBoolean(xor(True)(False))).toEvaluateTo(true);
expect(toBoolean(xor(True)(False))).toBe(true);
});
it('True xor True is False', () => {
expect(xor).toDeferEvaluationOf(True, True);
expect(toBoolean(xor(True)(True))).toEvaluateTo(false);
expect(toBoolean(xor(True)(True))).toBe(false);
});
});
});
test/list.spec.ts
+35 -38
View File
@@ -5,37 +5,34 @@ import { toNumber, Zero, sum, succ, Num, Succ, odd } from '../src/num';
import { Cons, filter, foldl, foldlz, foldr, foldrz, fromArray, fromNumberArray, head, List, map, Nil, tail, toArray, toNumberArray } from '../src/list';
describe('List', () => {
const iterate: (n: number) => Lazy<List<number>> = n => new Lazy(() => Cons(_(n))(iterate(n + 1)).value);
const niterate: (n: Lazy<Num>) => Lazy<List<Num>> = n => new Lazy(() => Cons(n)(niterate(Succ(n))).value);
const iterate: (n: number) => List<Lazy<number>> = n => new Lazy(() => Cons(_(n))(iterate(n + 1)).value);
const niterate: (n: Num) => List<Num> = n => new Lazy(() => Cons(n)(niterate(Succ(n))).value);
describe('toArray', () => {
it('converts []', () => {
expect(toArray).toDeferEvaluationOf(Nil);
expect(toArray(Nil)).toEvaluateTo([]);
expect(toArray(Nil)).toEqual([]);
});
it('converts [0]', () => {
expect(toArray).toDeferEvaluationOf(Cons(_(0))(Nil));
expect(toArray(Cons(_(0))(Nil))).toEvaluateTo([0]);
expect(toArray(Cons(_(0))(Nil))).toEqual([0]);
});
it('converts [0, 1]', () => {
expect(toArray).toDeferEvaluationOf(Cons(_(0))(Cons(_(1))(Nil)));
expect(toArray(Cons(_(0))(Cons(_(1))(Nil)))).toEvaluateTo([0, 1]);
expect(toArray(Cons(_(0))(Cons(_(1))(Nil)))).toEqual([0, 1]);
});
});
describe('fromArray', () => {
it('converts []', () => {
expect(toArray(fromArray([]))).toEvaluateTo([]);
expect(toArray(fromArray([]))).toEqual([]);
});
it('converts [0]', () => {
expect(toArray(fromArray([0]))).toEvaluateTo([0]);
expect(toArray(fromArray([0].map(_)))).toEqual([0]);
});
it('converts 2', () => {
expect(toArray(fromArray([0, 1]))).toEvaluateTo([0, 1]);
expect(toArray(fromArray([0, 1].map(_)))).toEqual([0, 1]);
});
});
@@ -63,17 +60,17 @@ describe('List', () => {
describe('tail', () => {
it('drops nothing from empty list', () => {
expect(() => tail(Nil)).not.toThrow();
expect(() => $(toArray(tail(Nil)))).toThrow();
expect(() => toArray(tail(Nil))).toThrow();
});
it('drops only item', () => {
expect(tail).toDeferEvaluationOf(Cons(_(0))(Nil));
expect(toArray(tail(Cons(_(0))(Nil)))).toEvaluateTo([]);
expect(toArray(tail(Cons(_(0))(Nil)))).toEqual([]);
});
it('drops first item', () => {
expect(tail).toDeferEvaluationOf(Cons(_(0))(Cons(_(1))(Nil)));
expect(toArray(tail(Cons(_(0))(Cons(_(1))(Nil))))).toEvaluateTo([1]);
expect(toArray(tail(Cons(_(0))(Cons(_(1))(Nil))))).toEqual([1]);
});
it('handles infinite lists', () => {
@@ -84,56 +81,56 @@ describe('List', () => {
describe('foldl', () => {
it('folds empty list', () => {
expect(foldl(sum)).toDeferEvaluationOf(Zero, fromNumberArray([]));
expect(toNumber(foldl(sum)(Zero)(fromNumberArray([])))).toEvaluateTo(0);
expect(toNumber(foldl(sum)(Zero)(fromNumberArray([])))).toBe(0);
});
it('folds single item', () => {
expect(foldl(sum)).toDeferEvaluationOf(Zero, fromNumberArray([1]));
expect(toNumber(foldl(sum)(Zero)(fromNumberArray([1])))).toEvaluateTo(1);
expect(toNumber(foldl(sum)(Zero)(fromNumberArray([1])))).toBe(1);
});
it('folds several items', () => {
expect(foldl(sum)).toDeferEvaluationOf(Zero, fromNumberArray([1, 2]));
expect(toNumber(foldl(sum)(Zero)(fromNumberArray([1, 2])))).toEvaluateTo(3);
expect(toNumber(foldl(sum)(Zero)(fromNumberArray([1, 2])))).toBe(3);
});
});
describe('foldlz', () => {
it('does not fold empty list', () => {
expect(() => foldlz(sum)(Nil)).not.toThrow();
expect(() => $(toNumber(foldlz(sum)(Nil)))).toThrow();
expect(() => toNumber(foldlz(sum)(Nil))).toThrow();
});
it('folds single item', () => {
expect(foldlz(sum)).toDeferEvaluationOf(fromNumberArray([1]));
expect(toNumber(foldlz(sum)(fromNumberArray([1])))).toEvaluateTo(1);
expect(toNumber(foldlz(sum)(fromNumberArray([1])))).toBe(1);
});
it('folds several items', () => {
expect(foldlz(sum)).toDeferEvaluationOf(fromNumberArray([1, 2]));
expect(toNumber(foldlz(sum)(fromNumberArray([1, 2])))).toEvaluateTo(3);
expect(toNumber(foldlz(sum)(fromNumberArray([1, 2])))).toBe(3);
});
});
describe('foldr', () => {
it('folds empty list', () => {
expect(foldr(sum)).toDeferEvaluationOf(Zero, fromNumberArray([]));
expect(toNumber(foldr(sum)(Zero)(fromNumberArray([])))).toEvaluateTo(0);
expect(toNumber(foldr(sum)(Zero)(fromNumberArray([])))).toBe(0);
});
it('folds single item', () => {
expect(foldr(sum)).toDeferEvaluationOf(Zero, fromNumberArray([1]));
expect(toNumber(foldr(sum)(Zero)(fromNumberArray([1])))).toEvaluateTo(1);
expect(toNumber(foldr(sum)(Zero)(fromNumberArray([1])))).toBe(1);
});
it('folds several items', () => {
expect(foldr(sum)).toDeferEvaluationOf(Zero, fromNumberArray([1, 2]));
expect(toNumber(foldr(sum)(Zero)(fromNumberArray([1, 2])))).toEvaluateTo(3);
expect(toNumber(foldr(sum)(Zero)(fromNumberArray([1, 2])))).toBe(3);
});
it('handles infinite lists', () => {
expect(foldr<number, number>(x => a =>
iif<number>
expect(foldr<Lazy<number>, Lazy<number>>(x => a =>
iif<Lazy<number>>
(x.then(x => fromBoolean(x === 0)))
(x)
(x.then(x => a.then(a => _(x + a))))
@@ -144,22 +141,22 @@ describe('List', () => {
describe('foldrz', () => {
it('does not fold empty list', () => {
expect(() => foldrz(sum)(Nil)).not.toThrow();
expect(() => $(toNumber(foldrz(sum)(Nil)))).toThrow();
expect(() => toNumber(foldrz(sum)(Nil))).toThrow();
});
it.failing('folds single item', () => {
expect(foldrz(sum)).toDeferEvaluationOf(fromNumberArray([1]));
expect(toNumber(foldrz(sum)(fromNumberArray([1])))).toEvaluateTo(1);
expect(toNumber(foldrz(sum)(fromNumberArray([1])))).toBe(1);
});
it.failing('folds several items', () => {
expect(foldrz(sum)).toDeferEvaluationOf(fromNumberArray([1, 2]));
expect(toNumber(foldrz(sum)(fromNumberArray([1, 2])))).toEvaluateTo(3);
expect(toNumber(foldrz(sum)(fromNumberArray([1, 2])))).toBe(3);
});
it.failing('handles infinite lists', () => {
expect(foldrz<number>(x => a =>
iif<number>
expect(foldrz<Lazy<number>>(x => a =>
iif<Lazy<number>>
(x.then(x => fromBoolean(x === 0)))
(x)
(x.then(x => a.then(a => _(x + a))))
@@ -170,42 +167,42 @@ describe('List', () => {
describe('map', () => {
it('maps empty list', () => {
expect(map(succ)).toDeferEvaluationOf(fromNumberArray([]));
expect(toNumberArray(map(succ)(fromNumberArray([])))).toEvaluateTo([]);
expect(toNumberArray(map(succ)(fromNumberArray([])))).toEqual([]);
});
it('maps only item', () => {
expect(map(succ)).toDeferEvaluationOf(fromNumberArray([0]));
expect(toNumberArray(map(succ)(fromNumberArray([0])))).toEvaluateTo([1]);
expect(toNumberArray(map(succ)(fromNumberArray([0])))).toEqual([1]);
});
it('maps several items', () => {
expect(map(succ)).toDeferEvaluationOf(fromNumberArray([0, 1]));
expect(toNumberArray(map(succ)(fromNumberArray([0, 1])))).toEvaluateTo([1, 2]);
expect(toNumberArray(map(succ)(fromNumberArray([0, 1])))).toEqual([1, 2]);
});
it('handles infinite lists', () => {
expect(toNumber(head(map(succ)(niterate(Zero))))).toEvaluateTo(1);
expect(toNumber(head(map(succ)(niterate(Zero))))).toBe(1);
});
});
describe('filter', () => {
it('filter empty list', () => {
expect(filter(odd)).toDeferEvaluationOf(fromNumberArray([]));
expect(toNumberArray(filter(odd)(fromNumberArray([])))).toEvaluateTo([]);
expect(toNumberArray(filter(odd)(fromNumberArray([])))).toEqual([]);
});
it('filters only item', () => {
expect(filter(odd)).toDeferEvaluationOf(fromNumberArray([0]));
expect(toNumberArray(filter(odd)(fromNumberArray([])))).toEvaluateTo([]);
expect(toNumberArray(filter(odd)(fromNumberArray([])))).toEqual([]);
});
it('filters several items', () => {
expect(filter(odd)).toDeferEvaluationOf(fromNumberArray([0, 1]));
expect(toNumberArray(filter(odd)(fromNumberArray([0, 1])))).toEvaluateTo([1]);
expect(toNumberArray(filter(odd)(fromNumberArray([0, 1])))).toEqual([1]);
});
it('handles infinite lists', () => {
expect(toNumber(head(filter(odd)(niterate(Zero))))).toEvaluateTo(1);
expect(toNumber(head(filter(odd)(niterate(Zero))))).toBe(1);
});
});
});
test/num.spec.ts
+28 -31
View File
@@ -1,36 +1,33 @@
import { describe, expect, it } from '@jest/globals';
import { _, Lazy } from '../src/core';
import { _ } from '../src/core';
import { Num, Zero, Succ, sum, succ, pred, ifz, fromNumber, toNumber, sub, mul } from '../src/num';
describe('Num', () => {
describe('toNumber', () => {
it('converts 0', () => {
expect(toNumber).toDeferEvaluationOf(Zero);
expect(toNumber(Zero)).toEvaluateTo(0);
expect(toNumber(Zero)).toBe(0);
});
it('converts 1', () => {
expect(toNumber).toDeferEvaluationOf(Succ(Zero));
expect(toNumber(Succ(Zero))).toEvaluateTo(1);
expect(toNumber(Succ(Zero))).toBe(1);
});
it('converts 2', () => {
expect(toNumber).toDeferEvaluationOf(Succ(Succ(Zero)));
expect(toNumber(Succ(Succ(Zero)))).toEvaluateTo(2);
expect(toNumber(Succ(Succ(Zero)))).toBe(2);
});
});
describe('fromNumber', () => {
it('converts 0', () => {
expect(toNumber(fromNumber(0))).toEvaluateTo(0);
expect(toNumber(fromNumber(0))).toBe(0);
});
it('converts 1', () => {
expect(toNumber(fromNumber(1))).toEvaluateTo(1);
expect(toNumber(fromNumber(1))).toBe(1);
});
it('converts 2', () => {
expect(toNumber(fromNumber(2))).toEvaluateTo(2);
expect(toNumber(fromNumber(2))).toBe(2);
});
});
@@ -51,7 +48,7 @@ describe('Num', () => {
});
it('deeply lazy', () => {
const alot: Lazy<Num> = fromNumber(1000000);
const alot: Num = fromNumber(1000000);
expect(ifz(Succ(alot))(_(true))(_(false))).toEvaluateTo(false);
expect(alot.evaluated).toBe(false);
});
@@ -60,110 +57,110 @@ describe('Num', () => {
describe('succ', () => {
it('succ 0 is 1', () => {
expect(succ).toDeferEvaluationOf(fromNumber(0));
expect(toNumber(succ(fromNumber(0)))).toEvaluateTo(1);
expect(toNumber(succ(fromNumber(0)))).toBe(1);
});
it('succ 1 is 2', () => {
expect(succ).toDeferEvaluationOf(fromNumber(0));
expect(toNumber(succ(fromNumber(1)))).toEvaluateTo(2);
expect(toNumber(succ(fromNumber(1)))).toBe(2);
});
it('succ 10 is 11', () => {
expect(succ).toDeferEvaluationOf(fromNumber(10));
expect(toNumber(succ(fromNumber(10)))).toEvaluateTo(11);
expect(toNumber(succ(fromNumber(10)))).toBe(11);
});
});
describe('pred', () => {
it('pred 0 is 0', () => {
expect(pred).toDeferEvaluationOf(fromNumber(0));
expect(toNumber(pred(fromNumber(0)))).toEvaluateTo(0);
expect(toNumber(pred(fromNumber(0)))).toBe(0);
});
it('pred 1 is 0', () => {
expect(pred).toDeferEvaluationOf(fromNumber(0));
expect(toNumber(pred(fromNumber(1)))).toEvaluateTo(0);
expect(toNumber(pred(fromNumber(1)))).toBe(0);
});
it('pred 10 is 9', () => {
expect(pred).toDeferEvaluationOf(fromNumber(10));
expect(toNumber(pred(fromNumber(10)))).toEvaluateTo(9);
expect(toNumber(pred(fromNumber(10)))).toBe(9);
});
});
describe('sum', () => {
it('0 sum 0 is 0', () => {
expect(sum).toDeferEvaluationOf(fromNumber(0), fromNumber(0));
expect(toNumber(sum(fromNumber(0))(fromNumber(0)))).toEvaluateTo(0);
expect(toNumber(sum(fromNumber(0))(fromNumber(0)))).toBe(0);
});
it('0 sum 1 is 1', () => {
expect(sum).toDeferEvaluationOf(fromNumber(0), fromNumber(1));
expect(toNumber(sum(fromNumber(0))(fromNumber(1)))).toEvaluateTo(1);
expect(toNumber(sum(fromNumber(0))(fromNumber(1)))).toBe(1);
});
it('1 sum 0 is 1', () => {
expect(sum).toDeferEvaluationOf(fromNumber(1), fromNumber(0));
expect(toNumber(sum(fromNumber(1))(fromNumber(0)))).toEvaluateTo(1);
expect(toNumber(sum(fromNumber(1))(fromNumber(0)))).toBe(1);
});
it('3 sum 4 is 7', () => {
expect(sum).toDeferEvaluationOf(fromNumber(3), fromNumber(4));
expect(toNumber(sum(fromNumber(3))(fromNumber(4)))).toEvaluateTo(7);
expect(toNumber(sum(fromNumber(3))(fromNumber(4)))).toBe(7);
});
});
describe('sub', () => {
it('0 sub 0 is 0', () => {
expect(sub).toDeferEvaluationOf(fromNumber(0), fromNumber(0));
expect(toNumber(sub(fromNumber(0))(fromNumber(0)))).toEvaluateTo(0);
expect(toNumber(sub(fromNumber(0))(fromNumber(0)))).toBe(0);
});
it('0 sub 1 is 0', () => {
expect(sub).toDeferEvaluationOf(fromNumber(0), fromNumber(1));
expect(toNumber(sub(fromNumber(0))(fromNumber(1)))).toEvaluateTo(0);
expect(toNumber(sub(fromNumber(0))(fromNumber(1)))).toBe(0);
});
it('1 sub 0 is 1', () => {
expect(sub).toDeferEvaluationOf(fromNumber(1), fromNumber(0));
expect(toNumber(sub(fromNumber(1))(fromNumber(0)))).toEvaluateTo(1);
expect(toNumber(sub(fromNumber(1))(fromNumber(0)))).toBe(1);
});
it('7 sub 4 is 3', () => {
expect(sub).toDeferEvaluationOf(fromNumber(7), fromNumber(4));
expect(toNumber(sub(fromNumber(7))(fromNumber(4)))).toEvaluateTo(3);
expect(toNumber(sub(fromNumber(7))(fromNumber(4)))).toBe(3);
});
});
describe('mul', () => {
it('0 mul 0 is 0', () => {
expect(mul).toDeferEvaluationOf(fromNumber(0), fromNumber(0));
expect(toNumber(mul(fromNumber(0))(fromNumber(0)))).toEvaluateTo(0);
expect(toNumber(mul(fromNumber(0))(fromNumber(0)))).toBe(0);
});
it('0 mul 10 is 0', () => {
expect(mul).toDeferEvaluationOf(fromNumber(0), expect.skipped(fromNumber(10)));
expect(toNumber(mul(fromNumber(0))(fromNumber(10)))).toEvaluateTo(0);
expect(toNumber(mul(fromNumber(0))(fromNumber(10)))).toBe(0);
});
it('10 mul 0 is 0', () => {
expect(mul).toDeferEvaluationOf(fromNumber(10), fromNumber(0));
expect(toNumber(mul(fromNumber(1))(fromNumber(0)))).toEvaluateTo(0);
expect(toNumber(mul(fromNumber(1))(fromNumber(0)))).toBe(0);
});
it('1 mul 10 is 10', () => {
expect(mul).toDeferEvaluationOf(fromNumber(1), fromNumber(10));
expect(toNumber(mul(fromNumber(1))(fromNumber(10)))).toEvaluateTo(10);
expect(toNumber(mul(fromNumber(1))(fromNumber(10)))).toBe(10);
});
it('10 mul 1 is 10', () => {
expect(mul).toDeferEvaluationOf(fromNumber(10), fromNumber(1));
expect(toNumber(mul(fromNumber(10))(fromNumber(1)))).toEvaluateTo(10);
expect(toNumber(mul(fromNumber(10))(fromNumber(1)))).toBe(10);
});
it('3 mul 4 is 12', () => {
expect(mul).toDeferEvaluationOf(fromNumber(3), fromNumber(4));
expect(toNumber(mul(fromNumber(3))(fromNumber(4)))).toEvaluateTo(12);
expect(toNumber(mul(fromNumber(3))(fromNumber(4)))).toBe(12);
});
});
});