Module
A linq-like lazy-evaluation enumerable/iteration library that aims to support deno, node & browser
Latest
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990import { Lazy } from '../lib/mod.ts';import { assertEquals } from './deps/std/testing/asserts.ts';
const test = Deno.test;
test('append', () => { let orig = [1, 2, 3, 4]; assertEquals(Lazy.from(orig).append(5).toArray(), [...orig, 5]);
orig = [4, 3, 2, 1]; assertEquals(Lazy.from(orig).append(-1).toArray(), [...orig, -1]);
orig = [9, 8, 7, 6, 5, 4, 3, 2, 1]; assertEquals(Lazy.from(orig).append(0).toArray(), [...orig, 0]);});
test('apply', () => { class LazyNumberToString extends Lazy<string> { public constructor( private readonly _iterable: Iterable<number>, private readonly _adjust: (element: number) => string, ) { super(); }
public *[Symbol.iterator](): Iterator<string> { for (const element of this._iterable) { yield this._adjust(element); } } }
class LazySquare extends Lazy<number> { public constructor(private readonly _iterable: Iterable<number>) { super(); }
public *[Symbol.iterator](): Iterator<number> { for (const element of this._iterable) { yield element ** 2; } } }
class LazyToString<TSource> extends Lazy<string> { public constructor(private readonly _iterable: Iterable<TSource>) { super(); }
public *[Symbol.iterator](): Iterator<string> { for (const element of this._iterable) { yield `${element}`; } } } const iterableToString = <TSource>(t: Iterable<TSource>) => new LazyToString(t);
const orig = [1, 2, 3, 4]; assertEquals( Lazy.from(orig) .apply<LazyNumberToString, string>( t => new LazyNumberToString(t, e => e.toString()), ) .toArray(), ['1', '2', '3', '4'], ); assertEquals( Lazy.from(orig) .apply(t => new LazySquare(t)) .toArray(), [1, 4, 9, 16], ); assertEquals( Lazy.from(orig) .apply<LazyToString<number>, string>(iterableToString) .toArray(), ['1', '2', '3', '4'], );});
test('batchIn', () => { const orig = [1, 2, 3, 4, 5, 6, 7, 8, 9];
assertEquals(Lazy.from(orig).batchIn(1).toArray(), [ [1], [2], [3], [4], [5], [6], [7], [8], [9], ]); assertEquals(Lazy.from(orig).batchIn(2).toArray(), [ [1, 2], [3, 4], [5, 6], [7, 8], [9], ]); assertEquals(Lazy.from(orig).batchIn(3).toArray(), [ [1, 2, 3], [4, 5, 6], [7, 8, 9], ]); assertEquals(Lazy.from(orig).batchIn(4).toArray(), [ [1, 2, 3, 4], [5, 6, 7, 8], [9], ]); assertEquals(Lazy.from(orig).batchIn(5).toArray(), [ [1, 2, 3, 4, 5], [6, 7, 8, 9], ]); assertEquals(Lazy.from(orig).batchIn(6).toArray(), [ [1, 2, 3, 4, 5, 6], [7, 8, 9], ]); assertEquals(Lazy.from(orig).batchIn(7).toArray(), [ [1, 2, 3, 4, 5, 6, 7], [8, 9], ]); assertEquals(Lazy.from(orig).batchIn(8).toArray(), [ [1, 2, 3, 4, 5, 6, 7, 8], [9], ]); assertEquals(Lazy.from(orig).batchIn(9).toArray(), [ [1, 2, 3, 4, 5, 6, 7, 8, 9], ]); assertEquals(Lazy.from(orig).batchIn(10).toArray(), [ [1, 2, 3, 4, 5, 6, 7, 8, 9], ]);
assertEquals(Lazy.from(orig).batchIn(1, false).toArray(), [ [1], [2], [3], [4], [5], [6], [7], [8], [9], ]); assertEquals(Lazy.from(orig).batchIn(2, false).toArray(), [ [1, 2], [3, 4], [5, 6], [7, 8], ]); assertEquals(Lazy.from(orig).batchIn(3, false).toArray(), [ [1, 2, 3], [4, 5, 6], [7, 8, 9], ]); assertEquals(Lazy.from(orig).batchIn(4, false).toArray(), [ [1, 2, 3, 4], [5, 6, 7, 8], ]); assertEquals(Lazy.from(orig).batchIn(5, false).toArray(), [[1, 2, 3, 4, 5]]); assertEquals(Lazy.from(orig).batchIn(6, false).toArray(), [ [1, 2, 3, 4, 5, 6], ]); assertEquals(Lazy.from(orig).batchIn(7, false).toArray(), [ [1, 2, 3, 4, 5, 6, 7], ]); assertEquals(Lazy.from(orig).batchIn(8, false).toArray(), [ [1, 2, 3, 4, 5, 6, 7, 8], ]); assertEquals(Lazy.from(orig).batchIn(9, false).toArray(), [ [1, 2, 3, 4, 5, 6, 7, 8, 9], ]); assertEquals(Lazy.from(orig).batchIn(10, false).toArray(), []);});
test('cache', () => { const orig = [1, 2, 3, 4, 5];
assertEquals(Lazy.from(orig).cache().toArray(), orig);
let calls = 0; const chain = Lazy.from(orig).select(i => { calls++; return i * 2; });
// Without caching. assertEquals(chain.toArray(), [2, 4, 6, 8, 10]); assertEquals(calls, 5); chain.toArray(); assertEquals(calls, 10);
calls = 0; const cached = chain.cache();
// With caching. assertEquals(cached.toArray(), [2, 4, 6, 8, 10]); assertEquals(calls, 5); cached.toArray(); assertEquals(calls, 5);});
test('concat', () => { let first = [1, 2, 3, 4]; let second = [5, 6, 7, 8]; assertEquals(Lazy.from(first).concat(second).toArray(), [ ...first, ...second, ]);
first = [9, 8, 7, 6]; second = [1, 2, 3, 4]; assertEquals(Lazy.from(first).concat(second).toArray(), [ ...first, ...second, ]);
assertEquals(Lazy.from([1]).concat([2], [3]).toArray(), [1, 2, 3]);
assertEquals(Lazy.from<number>([]).concat([], [], [1], []).toArray(), [1]);});
test('defaultIfEmpty', () => { let orig = [1, 2, 3]; assertEquals(Lazy.from(orig).defaultIfEmpty(9).toArray(), orig);
orig = []; assertEquals(Lazy.from(orig).defaultIfEmpty(9).toArray(), [9]);});
test('distinct', () => { let orig = [1, 2, 3, 1, 2, 3]; assertEquals(Lazy.from(orig).distinct().toArray(), [1, 2, 3]);
orig = [1, 2, 3, 1, 8, 9]; assertEquals(Lazy.from(orig).distinct().toArray(), [1, 2, 3, 8, 9]);
const objs = [ { value: 1 }, { value: 2 }, { value: 3 }, { value: 2 }, { value: 1 }, ]; assertEquals( Lazy.from(objs) .distinct(o => o.value) .toArray(), [{ value: 1 }, { value: 2 }, { value: 3 }], );});
test('except', () => { const orig = [1, 2, 3, 4, 5]; assertEquals(Lazy.from(orig).except([2, 4]).toArray(), [1, 3, 5]); assertEquals(Lazy.from(orig).except([1]).toArray(), [2, 3, 4, 5]); assertEquals(Lazy.from(orig).except([4, 5]).toArray(), [1, 2, 3]);});
test('groupBy', () => { const objs = [ { key: 1, value: 'a' }, { key: 2, value: 'b' }, { key: 3, value: 'c' }, { key: 3, value: 'd' }, { key: 2, value: 'e' }, { key: 1, value: 'f' }, { key: 4, value: 'g' }, ];
assertEquals( Lazy.from(objs) .groupBy(f => f.key) .toArray(), [ { key: 1, elements: [ { key: 1, value: 'a' }, { key: 1, value: 'f' }, ], }, { key: 2, elements: [ { key: 2, value: 'b' }, { key: 2, value: 'e' }, ], }, { key: 3, elements: [ { key: 3, value: 'c' }, { key: 3, value: 'd' }, ], }, { key: 4, elements: [{ key: 4, value: 'g' }] }, ], ); assertEquals( Lazy.from(objs) .groupBy( f => f.key, f => f.value, ) .toArray(), [ { key: 1, elements: ['a', 'f'] }, { key: 2, elements: ['b', 'e'] }, { key: 3, elements: ['c', 'd'] }, { key: 4, elements: ['g'] }, ], ); assertEquals( Lazy.from(objs) .groupBy( f => f.key, f => f.value, (key, f) => ({ k: key, values: Array.from(f) }), ) .toArray(), [ { k: 1, values: ['a', 'f'] }, { k: 2, values: ['b', 'e'] }, { k: 3, values: ['c', 'd'] }, { k: 4, values: ['g'] }, ], );});
test('groupJoin', () => { const first = [ { key: 1, value: 5 }, { key: 2, value: 4 }, { key: 3, value: 3 }, { key: 4, value: 2 }, { key: 5, value: 1 }, { key: 8, value: 1 }, ]; const second = [ { key: 1, value: 'a' }, { key: 2, value: 'b' }, { key: 3, value: 'c' }, { key: 4, value: 'd' }, { key: 5, value: 'e' }, { key: 1, value: 'f' }, { key: 2, value: 'g' }, { key: 3, value: 'h' }, { key: 4, value: 'i' }, { key: 9, value: 'j' }, ]; assertEquals( Lazy.from(first) .groupJoin( second, f => f.key, s => s.key, (f, s) => ({ key: f.key, firstValue: f.value, secondValues: Array.from(s).map(v => v.value), }), ) .toArray(), [ { key: 1, firstValue: 5, secondValues: ['a', 'f'] }, { key: 2, firstValue: 4, secondValues: ['b', 'g'] }, { key: 3, firstValue: 3, secondValues: ['c', 'h'] }, { key: 4, firstValue: 2, secondValues: ['d', 'i'] }, { key: 5, firstValue: 1, secondValues: ['e'] }, ], );});
test('itersect', () => { const orig = [1, 2, 3, 4, 5]; assertEquals(Lazy.from(orig).intersect([1, 2, 3]).toArray(), [1, 2, 3]); assertEquals(Lazy.from(orig).intersect([2, 3, 4]).toArray(), [2, 3, 4]); assertEquals(Lazy.from(orig).intersect([3, 4, 5]).toArray(), [3, 4, 5]); assertEquals(Lazy.from(orig).intersect([1, 3, 5, 7, 9]).toArray(), [1, 3, 5]);});
test('join', () => { const first = [ { key: 1, value1: 'a1' }, { key: 2, value1: 'b1' }, { key: 3, value1: 'c1' }, { key: 4, value1: 'd1' }, { key: 5, value1: 'e1' }, ]; const second = [ { k: 1, value2: 'a2' }, { k: 2, value2: 'b2' }, { k: 3, value2: 'c2' }, { k: 4, value2: 'd2' }, { k: 5, value2: 'e2' }, ];
assertEquals( Lazy.from(first) .join( second, v => v.key, v => v.k, (f, s) => ({ ky: f.key, value1: f.value1, value2: s.value2 }), ) .toArray(), [ { ky: 1, value1: 'a1', value2: 'a2' }, { ky: 2, value1: 'b1', value2: 'b2' }, { ky: 3, value1: 'c1', value2: 'c2' }, { ky: 4, value1: 'd1', value2: 'd2' }, { ky: 5, value1: 'e1', value2: 'e2' }, ], );});
test('orderBy', () => { const orig = [2, 1, 5, 3, 4, 10, 20]; assertEquals( Lazy.from(orig) .orderBy(v => v) .toArray(), [1, 10, 2, 20, 3, 4, 5], ); assertEquals( Lazy.from(orig) .orderBy( v => v, (a, b) => a - b, ) .toArray(), [1, 2, 3, 4, 5, 10, 20], );
const objs = [ { value: 2 }, { value: 5 }, { value: 15 }, { value: 1 }, { value: 3 }, { value: 7 }, ]; assertEquals( Lazy.from(objs) .orderBy(v => v.value) .toArray(), [ { value: 1 }, { value: 15 }, { value: 2 }, { value: 3 }, { value: 5 }, { value: 7 }, ], );
assertEquals( Lazy.from([undefined, 1, 2, 35, undefined, 3, 4, undefined, 5]) .orderBy(v => v) .toArray(), [1, 2, 3, 35, 4, 5, undefined, undefined, undefined], );});
test('orderByDecending', () => { const orig = [2, 1, 5, 3, 4, 10, 20]; assertEquals( Lazy.from(orig) .orderByDecending(v => v) .toArray(), [5, 4, 3, 20, 2, 10, 1], );
const objs = [ { value: 2 }, { value: 5 }, { value: 15 }, { value: 1 }, { value: 3 }, { value: 7 }, ]; assertEquals( Lazy.from(objs) .orderByDecending(v => v.value) .toArray(), [ { value: 7 }, { value: 5 }, { value: 3 }, { value: 2 }, { value: 15 }, { value: 1 }, ], );
assertEquals( Lazy.from([undefined, 1, 35, 2, undefined, 3, 4, undefined, 5]) .orderByDecending(v => v) .toArray(), [5, 4, 35, 3, 2, 1, undefined, undefined, undefined], );});
test('orderNumericallyBy', () => { const orig = [2, 1, 5, 3, 4, 10, 20]; assertEquals( Lazy.from(orig) .orderNumericallyBy(v => v) .toArray(), [1, 2, 3, 4, 5, 10, 20], );
const objs = [ { value: 2 }, { value: 5 }, { value: 15 }, { value: 1 }, { value: 3 }, { value: 7 }, ]; assertEquals( Lazy.from(objs) .orderNumericallyBy(v => v.value) .toArray(), [ { value: 1 }, { value: 2 }, { value: 3 }, { value: 5 }, { value: 7 }, { value: 15 }, ], );});
test('orderNumericallyByDecending', () => { const orig = [2, 1, 5, 3, 4, 10, 20]; assertEquals( Lazy.from(orig) .orderNumericallyByDecending(v => v) .toArray(), [20, 10, 5, 4, 3, 2, 1], );
const objs = [ { value: 2 }, { value: 5 }, { value: 15 }, { value: 1 }, { value: 3 }, { value: 7 }, ]; assertEquals( Lazy.from(objs) .orderNumericallyByDecending(v => v.value) .toArray(), [ { value: 15 }, { value: 7 }, { value: 5 }, { value: 3 }, { value: 2 }, { value: 1 }, ], );});
test('prepend', () => { let orig = [1, 2, 3, 4]; assertEquals(Lazy.from(orig).prepend(5).toArray(), [5, ...orig]);
orig = [4, 3, 2, 1]; assertEquals(Lazy.from(orig).prepend(-1).toArray(), [-1, ...orig]);
orig = [9, 8, 7, 6, 5, 4, 3, 2, 1]; assertEquals(Lazy.from(orig).prepend(0).toArray(), [0, ...orig]);});
test('reverse', () => { const orig = [1, 2, 3, 4, 5]; assertEquals(Lazy.from(orig).reverse().toArray(), [5, 4, 3, 2, 1]); assertEquals(Lazy.from(orig).reverse().reverse().toArray(), orig);});
test('select', () => { let orig = [ { value: 1 }, { value: 2 }, { value: 3 }, { value: 4 }, { value: 5 }, ]; assertEquals( Lazy.from(orig) .select(v => v.value) .toArray(), [1, 2, 3, 4, 5], );
orig = [{ value: 5 }, { value: 4 }, { value: 3 }, { value: 2 }, { value: 1 }]; assertEquals( Lazy.from(orig) .select((v, i) => ({ v: v.value, i })) .toArray(), [ { v: 5, i: 0 }, { v: 4, i: 1 }, { v: 3, i: 2 }, { v: 2, i: 3 }, { v: 1, i: 4 }, ], );});
test('selectMany', () => { let orig = [ { value: [1] }, { value: [2] }, { value: [3] }, { value: [4] }, { value: [5] }, ]; assertEquals( Lazy.from(orig) .selectMany(v => v.value) .toArray(), [1, 2, 3, 4, 5], );
orig = [ { value: [5, 6] }, { value: [4] }, { value: [3] }, { value: [2] }, { value: [1] }, ]; assertEquals( Lazy.from(orig) .selectMany((v, i) => Lazy.from(v.value).select(v2 => ({ v: v2, i }))) .toArray(), [ { v: 5, i: 0 }, { v: 6, i: 0 }, { v: 4, i: 1 }, { v: 3, i: 2 }, { v: 2, i: 3 }, { v: 1, i: 4 }, ], );
const arrarr = [ [1, 2, 3], [4, 5, 6], [7, 8, 9], ]; assertEquals( Lazy.from(arrarr) .selectMany(v => v) .toArray(), [1, 2, 3, 4, 5, 6, 7, 8, 9], );});
test('skip', () => { const orig = [1, 2, 3, 4, 5, 6, 7, 8, 9]; assertEquals(Lazy.from(orig).skip(0).toArray(), [1, 2, 3, 4, 5, 6, 7, 8, 9]); assertEquals(Lazy.from(orig).skip(1).toArray(), [2, 3, 4, 5, 6, 7, 8, 9]); assertEquals(Lazy.from(orig).skip(2).toArray(), [3, 4, 5, 6, 7, 8, 9]); assertEquals(Lazy.from(orig).skip(3).toArray(), [4, 5, 6, 7, 8, 9]); assertEquals(Lazy.from(orig).skip(4).toArray(), [5, 6, 7, 8, 9]); assertEquals(Lazy.from(orig).skip(5).toArray(), [6, 7, 8, 9]); assertEquals(Lazy.from(orig).skip(10).toArray(), []);});
test('skipLast', () => { const orig = [1, 2, 3, 4, 5, 6, 7, 8, 9]; assertEquals(Lazy.from(orig).skipLast(0).toArray(), [ 1, 2, 3, 4, 5, 6, 7, 8, 9, ]); assertEquals(Lazy.from(orig).skipLast(1).toArray(), [1, 2, 3, 4, 5, 6, 7, 8]); assertEquals(Lazy.from(orig).skipLast(2).toArray(), [1, 2, 3, 4, 5, 6, 7]); assertEquals(Lazy.from(orig).skipLast(3).toArray(), [1, 2, 3, 4, 5, 6]); assertEquals(Lazy.from(orig).skipLast(4).toArray(), [1, 2, 3, 4, 5]); assertEquals(Lazy.from(orig).skipLast(5).toArray(), [1, 2, 3, 4]); assertEquals(Lazy.from(orig).skipLast(10).toArray(), []);});
test('skipWhile', () => { const orig = [1, 2, 3, 4, 5, 6, 7, 8, 9]; assertEquals( Lazy.from(orig) .skipWhile(v => v !== 1) .toArray(), [1, 2, 3, 4, 5, 6, 7, 8, 9], ); assertEquals( Lazy.from(orig) .skipWhile(v => v !== 2) .toArray(), [2, 3, 4, 5, 6, 7, 8, 9], ); assertEquals( Lazy.from(orig) .skipWhile(v => v !== 3) .toArray(), [3, 4, 5, 6, 7, 8, 9], ); assertEquals( Lazy.from(orig) .skipWhile(v => v !== 4) .toArray(), [4, 5, 6, 7, 8, 9], ); assertEquals( Lazy.from(orig) .skipWhile(v => v !== 5) .toArray(), [5, 6, 7, 8, 9], ); assertEquals( Lazy.from(orig) .skipWhile(v => v !== 6) .toArray(), [6, 7, 8, 9], ); assertEquals( Lazy.from(orig) .skipWhile(v => v !== 10) .toArray(), [], );});
test('take', () => { const orig = [1, 2, 3, 4, 5, 6, 7, 8, 9]; assertEquals(Lazy.from(orig).take(-1).toArray(), []); assertEquals(Lazy.from(orig).take(0).toArray(), []); assertEquals(Lazy.from(orig).take(1).toArray(), [1]); assertEquals(Lazy.from(orig).take(2).toArray(), [1, 2]); assertEquals(Lazy.from(orig).take(3).toArray(), [1, 2, 3]); assertEquals(Lazy.from(orig).take(4).toArray(), [1, 2, 3, 4]); assertEquals(Lazy.from(orig).take(5).toArray(), [1, 2, 3, 4, 5]);});
test('takeLast', () => { const orig = [1, 2, 3, 4, 5, 6, 7, 8, 9]; assertEquals(Lazy.from(orig).takeLast(-1).toArray(), []); assertEquals(Lazy.from(orig).takeLast(0).toArray(), []); assertEquals(Lazy.from(orig).takeLast(1).toArray(), [9]); assertEquals(Lazy.from(orig).takeLast(2).toArray(), [8, 9]); assertEquals(Lazy.from(orig).takeLast(3).toArray(), [7, 8, 9]); assertEquals(Lazy.from(orig).takeLast(4).toArray(), [6, 7, 8, 9]); assertEquals(Lazy.from(orig).takeLast(5).toArray(), [5, 6, 7, 8, 9]);});
test('takeWhile', () => { const orig = [1, 2, 3, 4, 5, 6, 7, 8, 9]; assertEquals( Lazy.from(orig) .takeWhile(v => v !== 4) .toArray(), [1, 2, 3], ); assertEquals( Lazy.from(orig) .takeWhile(v => v !== 5) .toArray(), [1, 2, 3, 4], ); assertEquals( Lazy.from(orig) .takeWhile(v => v !== 6) .toArray(), [1, 2, 3, 4, 5], ); assertEquals( Lazy.from(orig) .takeWhile(v => v !== 7) .toArray(), [1, 2, 3, 4, 5, 6], ); assertEquals( Lazy.from(orig) .takeWhile(v => v !== 8) .toArray(), [1, 2, 3, 4, 5, 6, 7], ); assertEquals( Lazy.from(orig) .takeWhile(v => v !== 9) .toArray(), [1, 2, 3, 4, 5, 6, 7, 8], ); assertEquals( Lazy.from(orig) .takeWhile(() => false) .toArray(), [], );});
test('union', () => { assertEquals(Lazy.from([1, 2, 3]).union([3, 4, 5]).toArray(), [ 1, 2, 3, 4, 5, ]); assertEquals(Lazy.from([1, 2, 3]).union([2, 3, 4, 5]).toArray(), [ 1, 2, 3, 4, 5, ]); assertEquals(Lazy.from([1, 2, 3]).union([3, 3, 4, 5]).toArray(), [ 1, 2, 3, 4, 5, ]); assertEquals(Lazy.from([1, 2, 3, 2]).union([3, 4, 5]).toArray(), [ 1, 2, 3, 4, 5, ]);});
test('where', () => { assertEquals( Lazy.from([1, 2, 3, 4, 5]) .where(v => v === 1) .toArray(), [1], ); assertEquals( Lazy.from([1, 2, 3, 4, 5]) .where(v => v === 2) .toArray(), [2], ); assertEquals( Lazy.from([1, 2, 3, 4, 5]) .where(v => v === 3) .toArray(), [3], ); assertEquals( Lazy.from([1, 2, 3, 4, 5]) .where(v => v % 2 === 0) .toArray(), [2, 4], ); assertEquals( Lazy.from([ { key: 1, value: 'a' }, { key: 2, value: 'b' }, { key: 3, value: 'c' }, { key: 4, value: 'd' }, { key: 5, value: 'e' }, ]) .where(v => v.value === 'a' || v.value === 'e') .toArray(), [ { key: 1, value: 'a' }, { key: 5, value: 'e' }, ], );
assertEquals( Lazy.from([1, 2, 3, 4, 5]) .where((_, i) => i === 0) .toArray(), [1], ); assertEquals( Lazy.from([1, 2, 3, 4, 5]) .where((_, i) => i === 2) .toArray(), [3], ); assertEquals( Lazy.from([1, 2, 3, 4, 5]) .where((_, i) => i === 4) .toArray(), [5], ); assertEquals( Lazy.from([1, 2, 3, 4, 5]) .where((v, i) => v < i) .toArray(), [], ); assertEquals( Lazy.from([1, 2, 3, 4, 5]) .where((v, i) => v > i) .toArray(), [1, 2, 3, 4, 5], );
assertEquals( Lazy.from([1, 2, 3, 4, 5]) .where((v): v is 1 | 3 | 5 => v % 2 === 1) .toArray(), [1, 3, 5], ); assertEquals( Lazy.from([1, 2, 3, 4, 5]) .where((v): v is 2 | 4 => v % 2 === 0) .toArray(), [2, 4], );});
test('zip', () => { assertEquals(Lazy.from([1, 2, 3, 4]).zip([4, 3, 2, 1]).toArray(), [ [1, 4], [2, 3], [3, 2], [4, 1], ]); assertEquals(Lazy.from([1, 2, 3, 4]).zip([4, 3, 2, 1, 0]).toArray(), [ [1, 4], [2, 3], [3, 2], [4, 1], ]); assertEquals(Lazy.from([1, 2, 3, 4, 5]).zip([4, 3, 2, 1]).toArray(), [ [1, 4], [2, 3], [3, 2], [4, 1], ]); assertEquals(Lazy.from([1, 2, 3, 4]).zip(['4', '3', '2', '1']).toArray(), [ [1, '4'], [2, '3'], [3, '2'], [4, '1'], ]);
assertEquals( Lazy.from([1, 2, 3, 4]) .zip([4, 3, 2, 1], (first, second) => ({ first, second })) .toArray(), [ { first: 1, second: 4 }, { first: 2, second: 3 }, { first: 3, second: 2 }, { first: 4, second: 1 }, ], ); assertEquals( Lazy.from([1, 2, 3, 4]) .zip([4, 3, 2, 1, 0], (first, second) => ({ first, second })) .toArray(), [ { first: 1, second: 4 }, { first: 2, second: 3 }, { first: 3, second: 2 }, { first: 4, second: 1 }, ], ); assertEquals( Lazy.from([1, 2, 3, 4, 5]) .zip([4, 3, 2, 1], (first, second) => ({ first, second })) .toArray(), [ { first: 1, second: 4 }, { first: 2, second: 3 }, { first: 3, second: 2 }, { first: 4, second: 1 }, ], );});