Infendro/sequence.ts
1
0
Fork 0
Code Issues Pull Requests Actions Packages Wiki Activity

Refactor partition and unzip into terminal functions

Browse Source
This commit is contained in:
Infendro
2026-04-29 18:15:02 +02:00
parent a5866c08ff
commit e6d39a650e
3 changed files with 16 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/sequence.ts
View File

@@ -148,7 +148,7 @@ export type Sequence<T> = {
filter<R extends T>(predicate: (it: T) => it is R): Sequence<R> filter<R extends T>(predicate: (it: T) => it is R): Sequence<R>
filter(predicate: (it: T) => boolean): Sequence<T> filter(predicate: (it: T) => boolean): Sequence<T>
partition(predicate: (it: T) => boolean): [Sequence<T>, Sequence<T>] partition(predicate: (it: T) => boolean): [T[], T[]]
distinct(): Sequence<T> distinct(): Sequence<T>
distinctBy<K>(transform: (it: T) => K): Sequence<T> distinctBy<K>(transform: (it: T) => K): Sequence<T>
@@ -170,7 +170,7 @@ export type Sequence<T> = {
associateBy<K>(transform: (it: T) => K): Sequence<[K, T]> associateBy<K>(transform: (it: T) => K): Sequence<[K, T]>
associateWith<V>(transform: (it: T) => V): Sequence<[T, V]> associateWith<V>(transform: (it: T) => V): Sequence<[T, V]>
zip<B>(items: Iterable<B>): Sequence<[T, B]> zip<B>(items: Iterable<B>): Sequence<[T, B]>
unzip<A, B>(this: Sequence<[A, B]>): [Sequence<A>, Sequence<B>] unzip<A, B>(this: Sequence<[A, B]>): [A[], B[]]
windowed(size: number, step?: number, partial?: boolean): Sequence<T[]> windowed(size: number, step?: number, partial?: boolean): Sequence<T[]>
chunked(size: number): Sequence<T[]> chunked(size: number): Sequence<T[]>
@@ -354,8 +354,7 @@ function wrap<T>(value: Iterable<T> | (() => Iterable<T>)): Sequence<T> {
return wrap(() => filter(resolve(), predicate)); return wrap(() => filter(resolve(), predicate));
}, },
partition(predicate) { partition(predicate) {
const [a, b] = partition(resolve(), predicate); return partition(resolve(), predicate);
return [wrap(a), wrap(b)];
}, },
distinct() { distinct() {
return wrap(() => distinct(resolve())); return wrap(() => distinct(resolve()));
@@ -412,8 +411,7 @@ function wrap<T>(value: Iterable<T> | (() => Iterable<T>)): Sequence<T> {
return wrap(() => zip(resolve(), items)); return wrap(() => zip(resolve(), items));
}, },
unzip<A, B>() { unzip<A, B>() {
const [a, b] = unzip(resolve() as Iterable<[A, B]>); return unzip(resolve() as Iterable<[A, B]>);
return [wrap(a), wrap(b)];
}, },
windowed(size, step, partial) { windowed(size, step, partial) {
return wrap(() => windowed(resolve(), size, step, partial)); return wrap(() => windowed(resolve(), size, step, partial));

31
src/sequence/partition.ts
View File

@@ -1,30 +1,9 @@
export function partition<T>(value: Iterable<T>, predicate: (it: T) => boolean): [() => Iterable<T>, () => Iterable<T>] { export function partition<T>(value: Iterable<T>, predicate: (it: T) => boolean): [T[], T[]] {
const iterator = value[Symbol.iterator]();
let finished = false;
const t: T[] = []; const t: T[] = [];
const f: T[] = []; const f: T[] = [];
for (const it of value) {
function next() { if (predicate(it)) t.push(it);
const {value, done} = iterator.next(); else f.push(it);
if (done) finished = true;
else (predicate(value) ? t : f).push(value);
} }
return [t, f];
function* T(): Iterable<T> {
let i = 0;
while (!finished || i < t.length) {
if (i < t.length) yield t[i++];
else next();
}
}
function* F(): Iterable<T> {
let i = 0;
while (!finished || i < f.length) {
if (i < f.length) yield f[i++];
else next();
}
}
return [T, F];
} }

34
src/sequence/unzip.ts
View File

@@ -1,29 +1,9 @@
export function unzip<A, B>(value: Iterable<[A, B]>): [() => Iterable<A>, () => Iterable<B>] { export function unzip<A, B>(value: Iterable<[A, B]>): [A[], B[]] {
const iterator = value[Symbol.iterator](); const resultA: A[] = [];
let finished = false; const resultB: B[] = [];
const cache: [A, B][] = []; for (const [a, b] of value) {
resultA.push(a);
function next() { resultB.push(b);
const {value, done} = iterator.next();
if (done) finished = true;
else cache.push(value);
} }
return [resultA, resultB];
function* A(): Iterable<A> {
let i = 0;
while (!finished || i < cache.length) {
if (i < cache.length) yield cache[i++][0];
else next();
}
}
function* B(): Iterable<B> {
let i = 0;
while (!finished || i < cache.length) {
if (i < cache.length) yield cache[i++][1];
else next();
}
}
return [A, B];
} }