Implement sequence

src/index.ts

@@ -1 +1 @@
-export {sequence} from "./sequence.js";
+export {sequence} from "./sequence";

src/sequence.ts

@@ -1,100 +1,98 @@
-import {map} from "./sequence/map.js";
-import {collect} from "./sequence/collect.js";
-import {forEach} from "./sequence/forEach.js";
-import {filter} from "./sequence/filter.js";
-import {count} from "./sequence/count.js";
-import {isEmpty} from "./sequence/isEmpty.js";
-import {isNotEmpty} from "./sequence/isNotEmpty.js";
-import {indices} from "./sequence/indices.js";
-import {withIndex} from "./sequence/withIndex.js";
-import {filterIndexed} from "./sequence/filterIndexed.js";
-import {mapIndexed} from "./sequence/mapIndexed.js";
-import {any} from "./sequence/any.js";
-import {none} from "./sequence/none.js";
-import {all} from "./sequence/all.js";
-import {first} from "./sequence/first.js";
-import {firstOrNull} from "./sequence/firstOrNull.js";
-import {last} from "./sequence/last.js";
-import {lastOrNull} from "./sequence/lastOrNull.js";
-import {single} from "./sequence/single.js";
-import {singleOrNull} from "./sequence/singleOrNull.js";
-import {plus} from "./sequence/plus.js";
-import {distinct} from "./sequence/distinct.js";
-import {distinctBy} from "./sequence/distinctBy.js";
-import {drop} from "./sequence/drop.js";
-import {take} from "./sequence/take.js";
-import {slice} from "./sequence/slice.js";
-import {dropWhile} from "./sequence/dropWhile.js";
-import {dropUntil} from "./sequence/dropUntil.js";
-import {takeWhile} from "./sequence/takeWhile.js";
-import {takeUntil} from "./sequence/takeUntil.js";
-import {flatMap} from "./sequence/flatMap.js";
-import {flatMapIndexed} from "./sequence/flatMapIndexed.js";
-import {associate} from "./sequence/associate.js";
-import {associateBy} from "./sequence/associateBy.js";
-import {associateWith} from "./sequence/associateWith.js";
-import {get} from "./sequence/get.js";
-import {getOrNull} from "./sequence/getOrNull.js";
-import {sumBy} from "./sequence/sumBy.js";
-import {averageBy} from "./sequence/averageBy.js";
-import {contains} from "./sequence/contains.js";
-import {containsAll} from "./sequence/containsAll.js";
-import {minBy} from "./sequence/minBy.js";
-import {minByOrNull} from "./sequence/minByOrNull.js";
-import {maxBy} from "./sequence/maxBy.js";
-import {maxByOrNull} from "./sequence/maxByOrNull.js";
-import {minOf} from "./sequence/minOf.js";
-import {minOfOrNull} from "./sequence/minOfOrNull.js";
-import {maxOf} from "./sequence/maxOf.js";
-import {maxOfOrNull} from "./sequence/maxOfOrNull.js";
-import {minWith} from "./sequence/minWith.js";
-import {minWithOrNull} from "./sequence/minWithOrNull.js";
-import {maxWith} from "./sequence/maxWith.js";
-import {maxWithOrNull} from "./sequence/maxWithOrNull.js";
-import {minus} from "./sequence/minus.js";
-import {reduce} from "./sequence/reduce.js";
-import {reduceOrNull} from "./sequence/reduceOrNull.js";
-import {fold} from "./sequence/fold.js";
-import {scan} from "./sequence/scan.js";
-import {partition} from "./sequence/partition.js";
-import {firstIndex} from "./sequence/firstIndex.js";
-import {firstIndexOrNull} from "./sequence/firstIndexOrNull.js";
-import {lastIndex} from "./sequence/lastIndex.js";
-import {lastIndexOrNull} from "./sequence/lastIndexOrNull.js";
-import {sortedWith} from "./sequence/sortedWith.js";
-import {sortedBy} from "./sequence/sortedBy.js";
-import {reversed} from "./sequence/reversed.js";
-import {windowed} from "./sequence/windowed.js";
-import {chunked} from "./sequence/chunked.js";
-import {zip} from "./sequence/zip.js";
-import {unzip} from "./sequence/unzip.js";
-import {sum} from "./sequence/sum.js";
-import {average} from "./sequence/average.js";
-import {min} from "./sequence/min.js";
-import {minOrNull} from "./sequence/minOrNull.js";
-import {max} from "./sequence/max.js";
-import {maxOrNull} from "./sequence/maxOrNull.js";
-import {flatten} from "./sequence/flatten.js";
-import {sorted} from "./sequence/sorted.js";
-import {onEach} from "./sequence/onEach.js";
-import {joinToString} from "./sequence/joinToString.js";
-import {groupBy} from "./sequence/groupBy.js";
+import {map} from "./sequence/map";
+import {toArray} from "./sequence/toArray";
+import {forEach} from "./sequence/forEach";
+import {filter} from "./sequence/filter";
+import {count} from "./sequence/count";
+import {isEmpty} from "./sequence/isEmpty";
+import {isNotEmpty} from "./sequence/isNotEmpty";
+import {indices} from "./sequence/indices";
+import {withIndex} from "./sequence/withIndex";
+import {any} from "./sequence/any";
+import {none} from "./sequence/none";
+import {all} from "./sequence/all";
+import {first} from "./sequence/first";
+import {firstOrNull} from "./sequence/firstOrNull";
+import {last} from "./sequence/last";
+import {lastOrNull} from "./sequence/lastOrNull";
+import {single} from "./sequence/single";
+import {singleOrNull} from "./sequence/singleOrNull";
+import {plus} from "./sequence/plus";
+import {distinct} from "./sequence/distinct";
+import {distinctBy} from "./sequence/distinctBy";
+import {drop} from "./sequence/drop";
+import {take} from "./sequence/take";
+import {slice} from "./sequence/slice";
+import {dropWhile} from "./sequence/dropWhile";
+import {dropUntil} from "./sequence/dropUntil";
+import {takeWhile} from "./sequence/takeWhile";
+import {takeUntil} from "./sequence/takeUntil";
+import {flatMap} from "./sequence/flatMap";
+import {associate} from "./sequence/associate";
+import {associateBy} from "./sequence/associateBy";
+import {associateWith} from "./sequence/associateWith";
+import {get} from "./sequence/get";
+import {getOrNull} from "./sequence/getOrNull";
+import {sumBy} from "./sequence/sumBy";
+import {averageBy} from "./sequence/averageBy";
+import {contains} from "./sequence/contains";
+import {containsAll} from "./sequence/containsAll";
+import {minBy} from "./sequence/minBy";
+import {minByOrNull} from "./sequence/minByOrNull";
+import {maxBy} from "./sequence/maxBy";
+import {maxByOrNull} from "./sequence/maxByOrNull";
+import {minOf} from "./sequence/minOf";
+import {minOfOrNull} from "./sequence/minOfOrNull";
+import {maxOf} from "./sequence/maxOf";
+import {maxOfOrNull} from "./sequence/maxOfOrNull";
+import {minWith} from "./sequence/minWith";
+import {minWithOrNull} from "./sequence/minWithOrNull";
+import {maxWith} from "./sequence/maxWith";
+import {maxWithOrNull} from "./sequence/maxWithOrNull";
+import {minus} from "./sequence/minus";
+import {reduce} from "./sequence/reduce";
+import {reduceOrNull} from "./sequence/reduceOrNull";
+import {fold} from "./sequence/fold";
+import {scan} from "./sequence/scan";
+import {partition} from "./sequence/partition";
+import {sortedWith} from "./sequence/sortedWith";
+import {sortedBy} from "./sequence/sortedBy";
+import {reversed} from "./sequence/reversed";
+import {windowed} from "./sequence/windowed";
+import {chunked} from "./sequence/chunked";
+import {zip} from "./sequence/zip";
+import {unzip} from "./sequence/unzip";
+import {sum} from "./sequence/sum";
+import {average} from "./sequence/average";
+import {min} from "./sequence/min";
+import {minOrNull} from "./sequence/minOrNull";
+import {max} from "./sequence/max";
+import {maxOrNull} from "./sequence/maxOrNull";
+import {flatten} from "./sequence/flatten";
+import {sorted} from "./sequence/sorted";
+import {onEach} from "./sequence/onEach";
+import {joinToString} from "./sequence/joinToString";
+import {groupBy} from "./sequence/groupBy";
+import {averageOrNull} from "./sequence/averageOrNull";
+import {averageByOrNull} from "./sequence/averageByOrNull";
+import {toSet} from "./sequence/toSet";
+import {toMap} from "./sequence/toMap";
+import {mapNotNull} from "./sequence/mapNotNull";
+import {intersect} from "./sequence/intersect";
 
 export type Sequence<T> = {
     [Symbol.iterator](): Iterator<T>
-    collect(): T[]
 
-    onEach(action: (it: T) => void): void
+    toArray(): T[]
+    toSet(): Set<T>
+    toMap<K, V>(this: Sequence<[K, V]>): Map<K, V>
+
+    onEach(action: (it: T) => void): Sequence<T>
     forEach(action: (it: T) => void): void
 
     isEmpty(): boolean
     isNotEmpty(): boolean
     count(predicate?: (it: T) => boolean): number
 
-    firstIndex(predicate?: (it: T) => boolean): number
-    firstIndexOrNull(predicate?: (it: T) => boolean): number | null
-    lastIndex(predicate?: (it: T) => boolean): number
-    lastIndexOrNull(predicate?: (it: T) => boolean): number | null
     indices(): Sequence<number>
     withIndex(): Sequence<[number, T]>
 
@@ -113,6 +111,17 @@ export type Sequence<T> = {
     single(predicate?: (it: T) => boolean): T
     singleOrNull(predicate?: (it: T) => boolean): T | null
 
+    reduce(accumulate: (acc: T, it: T) => T): T
+    reduceOrNull(accumulate: (acc: T, it: T) => T): T | null
+    fold<R>(initial: R, accumulate: (acc: R, it: T) => R): R
+    scan<R>(initial: R, accumulate: (acc: R, it: T) => R): Sequence<R>
+    sum(this: Sequence<number>): number
+    sumBy(transform: (it: T) => number): number
+    average(this: Sequence<number>): number
+    averageOrNull(this: Sequence<number>): number | null
+    averageBy(transform: (it: T) => number): number
+    averageByOrNull(transform: (it: T) => number): number | null
+
     min(this: Sequence<number>): number
     minOrNull(this: Sequence<number>): number | null
     minWith(compare: (a: T, b: T) => number): T
@@ -121,6 +130,7 @@ export type Sequence<T> = {
     minByOrNull(transform: (it: T) => number): T | null
     minOf(transform: (it: T) => number): number
     minOfOrNull(transform: (it: T) => number): number | null
+
     max(this: Sequence<number>): number
     maxOrNull(this: Sequence<number>): number | null
     maxWith(compare: (a: T, b: T) => number): T
@@ -130,23 +140,18 @@ export type Sequence<T> = {
     maxOf(transform: (it: T) => number): number
     maxOfOrNull(transform: (it: T) => number): number | null
 
-    reduce(accumulate: (acc: T, it: T) => T): T
-    reduceOrNull(accumulate: (acc: T, it: T) => T): T | null
-    fold<R>(initial: R, accumulate: (acc: R, it: T) => R): R
-    scan<R>(initial: R, accumulate: (acc: R, it: T) => R): Sequence<R>
-    sum(this: Sequence<number>): number
-    sumBy(transform: (it: T) => number): number
-    average(this: Sequence<number>): number
-    averageBy(transform: (it: T) => number): number
+    joinToString(separator: string, transform?: (it: T) => string): string
 
     plus(items: Iterable<T>): Sequence<T>
     minus(items: Iterable<T>): Sequence<T>
+    intersect(items: Iterable<T>): Sequence<T>
 
     filter<R extends T>(predicate: (it: T) => it is R): Sequence<R>
     filter(predicate: (it: T) => boolean): Sequence<T>
-    filterIndexed<R extends T>(predicate: (index: number, it: T) => it is R): Sequence<R>
-    filterIndexed(predicate: (index: number, it: T) => boolean): Sequence<T>
-    partition(predicate: (it: T) => boolean): [T[], T[]]
+    partition(predicate: (it: T) => boolean): [Sequence<T>, Sequence<T>]
+    distinct(): Sequence<T>
+    distinctBy<K>(transform: (it: T) => K): Sequence<T>
+
     drop(count: number): Sequence<T>
     dropWhile(predicate: (it: T) => boolean): Sequence<T>
     dropUntil(predicate: (it: T) => boolean): Sequence<T>
@@ -154,284 +159,279 @@ export type Sequence<T> = {
     takeWhile(predicate: (it: T) => boolean): Sequence<T>
     takeUntil(predicate: (it: T) => boolean): Sequence<T>
     slice(start: number, end?: number): Sequence<T>
-    distinct(): Sequence<T>
-    distinctBy<K>(transform: (it: T) => K): Sequence<T>
 
     map<R>(transform: (it: T) => R): Sequence<R>
-    mapIndexed<R>(transform: (index: number, it: T) => R): Sequence<R>
+    mapNotNull<R>(transform: (it: T) => R | null): Sequence<R>
     flatten<R>(this: Sequence<Iterable<R>>): Sequence<R>
     flatMap<R>(transform: (it: T) => Iterable<R>): Sequence<R>
-    flatMapIndexed<R>(transform: (index: number, it: T) => Iterable<R>): Sequence<R>
+
+    groupBy<K>(transform: (it: T) => K): Sequence<[K, T[]]>
     associate<K, V>(transform: (it: T) => [K, V]): Sequence<[K, V]>
     associateBy<K>(transform: (it: T) => K): Sequence<[K, T]>
     associateWith<V>(transform: (it: T) => V): Sequence<[T, V]>
     zip<B>(items: Iterable<B>): Sequence<[T, B]>
-    unzip<A, B>(this: Sequence<[A, B]>): [A[], B[]]
+    unzip<A, B>(this: Sequence<[A, B]>): [Sequence<A>, Sequence<B>]
 
     windowed(size: number, step?: number, partial?: boolean): Sequence<T[]>
     chunked(size: number): Sequence<T[]>
 
-    groupBy<K>(transform: (it: T) => K): [K, T[]][]
-
-    reversed(): T[]
-    sorted(this: Sequence<number>): number[]
-    sortedWith(compare: (a: T, b: T) => number): T[]
-    sortedBy(transform: (it: T) => number): T[]
-
-    joinToString(separator: string, transform?: (it: T) => string): string
+    reversed(): Sequence<T>
+    sorted(this: Sequence<number>): Sequence<number>
+    sortedWith(compare: (a: T, b: T) => number): Sequence<T>
+    sortedBy(transform: (it: T) => number): Sequence<T>
 }
 
 export function sequence<T>(value: Iterable<T>): Sequence<T> {
     return wrap(() => value);
 }
 
-export function wrap<T>(factory: () => Iterable<T>): Sequence<T> {
+function wrap<T>(value: Iterable<T> | (() => Iterable<T>)): Sequence<T> {
+    const resolve = () => typeof value === "function" ? value() : value;
     return {
         [Symbol.iterator]() {
-            return factory()[Symbol.iterator]();
+            return resolve()[Symbol.iterator]();
         },
-        collect() {
-            return collect(factory());
+        toArray() {
+            return toArray(resolve());
+        },
+        toSet() {
+            return toSet(resolve());
+        },
+        toMap<K, V>() {
+            return toMap(resolve() as Iterable<[K, V]>);
         },
         onEach(action) {
-            return wrap(() => onEach(factory(), action));
+            return wrap(() => onEach(resolve(), action));
         },
         forEach(action) {
-            forEach(factory(), action);
+            forEach(resolve(), action);
         },
         isEmpty() {
-            return isEmpty(factory());
+            return isEmpty(resolve());
         },
         isNotEmpty() {
-            return isNotEmpty(factory());
+            return isNotEmpty(resolve());
         },
         count(predicate) {
-            return count(factory(), predicate);
-        },
-        firstIndex(predicate) {
-            return firstIndex(factory(), predicate);
-        },
-        firstIndexOrNull(predicate) {
-            return firstIndexOrNull(factory(), predicate);
-        },
-        lastIndex(predicate) {
-            return lastIndex(factory(), predicate);
-        },
-        lastIndexOrNull(predicate) {
-            return lastIndexOrNull(factory(), predicate);
+            return count(resolve(), predicate);
         },
         indices() {
-            return wrap(() => indices(factory()));
+            return wrap(() => indices(resolve()));
         },
         withIndex() {
-            return wrap(() => withIndex(factory()));
+            return wrap(() => withIndex(resolve()));
         },
         contains(item) {
-            return contains(factory(), item);
+            return contains(resolve(), item);
         },
         containsAll(items) {
-            return containsAll(factory(), items);
+            return containsAll(resolve(), items);
         },
         any(predicate) {
-            return any(factory(), predicate);
+            return any(resolve(), predicate);
         },
         all(predicate) {
-            return all(factory(), predicate);
+            return all(resolve(), predicate);
         },
         none(predicate) {
-            return none(factory(), predicate);
+            return none(resolve(), predicate);
         },
         get(index) {
-            return get(factory(), index);
+            return get(resolve(), index);
         },
         getOrNull(index) {
-            return getOrNull(factory(), index);
+            return getOrNull(resolve(), index);
         },
         first(predicate) {
-            return first(factory(), predicate);
+            return first(resolve(), predicate);
         },
         firstOrNull(predicate) {
-            return firstOrNull(factory(), predicate);
+            return firstOrNull(resolve(), predicate);
         },
         last(predicate) {
-            return last(factory(), predicate);
+            return last(resolve(), predicate);
         },
         lastOrNull(predicate) {
-            return lastOrNull(factory(), predicate);
+            return lastOrNull(resolve(), predicate);
         },
         single(predicate) {
-            return single(factory(), predicate);
+            return single(resolve(), predicate);
         },
         singleOrNull(predicate) {
-            return singleOrNull(factory(), predicate);
-        },
-        min() {
-            return min(factory() as any);
-        },
-        minOrNull() {
-            return minOrNull(factory() as any);
-        },
-        minWith(compare) {
-            return minWith(factory(), compare);
-        },
-        minWithOrNull(compare) {
-            return minWithOrNull(factory(), compare);
-        },
-        minBy(transform) {
-            return minBy(factory(), transform);
-        },
-        minByOrNull(transform) {
-            return minByOrNull(factory(), transform);
-        },
-        minOf(transform) {
-            return minOf(factory(), transform);
-        },
-        minOfOrNull(transform) {
-            return minOfOrNull(factory(), transform);
-        },
-        max() {
-            return max(factory() as any);
-        },
-        maxOrNull() {
-            return maxOrNull(factory() as any);
-        },
-        maxWith(compare) {
-            return maxWith(factory(), compare);
-        },
-        maxWithOrNull(compare) {
-            return maxWithOrNull(factory(), compare);
-        },
-        maxBy(transform) {
-            return maxBy(factory(), transform);
-        },
-        maxByOrNull(transform) {
-            return maxByOrNull(factory(), transform);
-        },
-        maxOf(transform) {
-            return maxOf(factory(), transform);
-        },
-        maxOfOrNull(transform) {
-            return maxOfOrNull(factory(), transform);
+            return singleOrNull(resolve(), predicate);
         },
         reduce(accumulate) {
-            return reduce(factory(), accumulate);
+            return reduce(resolve(), accumulate);
         },
         reduceOrNull(accumulate) {
-            return reduceOrNull(factory(), accumulate);
+            return reduceOrNull(resolve(), accumulate);
         },
         fold(initial, accumulate) {
-            return fold(factory(), initial, accumulate);
+            return fold(resolve(), initial, accumulate);
         },
         scan(initial, accumulate) {
-            return wrap(() => scan(factory(), initial, accumulate));
+            return wrap(() => scan(resolve(), initial, accumulate));
         },
         sum() {
-            return sum(factory() as any);
+            return sum(resolve() as Iterable<number>);
         },
         sumBy(transform) {
-            return sumBy(factory(), transform);
+            return sumBy(resolve(), transform);
         },
         average() {
-            return average(factory() as any);
+            return average(resolve() as Iterable<number>);
+        },
+        averageOrNull() {
+            return averageOrNull(resolve() as Iterable<number>);
         },
         averageBy(transform) {
-            return averageBy(factory(), transform);
+            return averageBy(resolve(), transform);
         },
-        plus(items) {
-            return wrap(() => plus(factory(), items));
+        averageByOrNull(transform) {
+            return averageByOrNull(resolve(), transform);
         },
-        minus(items) {
-            return wrap(() => minus(factory(), items));
+        min() {
+            return min(resolve() as Iterable<number>);
         },
-        filter(predicate: (it: T) => boolean) {
-            return wrap(() => filter(factory(), predicate));
+        minOrNull() {
+            return minOrNull(resolve() as Iterable<number>);
         },
-        filterIndexed(predicate: (index: number, it: T) => boolean) {
-            return wrap(() => filterIndexed(factory(), predicate));
+        minWith(compare) {
+            return minWith(resolve(), compare);
         },
-        partition(predicate) {
-            return partition(factory(), predicate);
+        minWithOrNull(compare) {
+            return minWithOrNull(resolve(), compare);
         },
-        drop(count) {
-            return wrap(() => drop(factory(), count));
+        minBy(transform) {
+            return minBy(resolve(), transform);
         },
-        dropWhile(predicate) {
-            return wrap(() => dropWhile(factory(), predicate));
+        minByOrNull(transform) {
+            return minByOrNull(resolve(), transform);
         },
-        dropUntil(predicate) {
-            return wrap(() => dropUntil(factory(), predicate));
+        minOf(transform) {
+            return minOf(resolve(), transform);
         },
-        take(count) {
-            return wrap(() => take(factory(), count));
+        minOfOrNull(transform) {
+            return minOfOrNull(resolve(), transform);
         },
-        takeWhile(predicate) {
-            return wrap(() => takeWhile(factory(), predicate));
+        max() {
+            return max(resolve() as Iterable<number>);
         },
-        takeUntil(predicate) {
-            return wrap(() => takeUntil(factory(), predicate));
+        maxOrNull() {
+            return maxOrNull(resolve() as Iterable<number>);
         },
-        slice(start, end) {
-            return wrap(() => slice(factory(), start, end));
+        maxWith(compare) {
+            return maxWith(resolve(), compare);
         },
-        distinct() {
-            return wrap(() => distinct(factory()));
+        maxWithOrNull(compare) {
+            return maxWithOrNull(resolve(), compare);
         },
-        distinctBy(transform) {
-            return wrap(() => distinctBy(factory(), transform));
+        maxBy(transform) {
+            return maxBy(resolve(), transform);
         },
-        map(transform) {
-            return wrap(() => map(factory(), transform));
+        maxByOrNull(transform) {
+            return maxByOrNull(resolve(), transform);
         },
-        mapIndexed(transform) {
-            return wrap(() => mapIndexed(factory(), transform));
+        maxOf(transform) {
+            return maxOf(resolve(), transform);
         },
-        flatten() {
-            return wrap(() => flatten(factory() as any));
-        },
-        flatMap(transform) {
-            return wrap(() => flatMap(factory(), transform));
-        },
-        flatMapIndexed(transform) {
-            return wrap(() => flatMapIndexed(factory(), transform));
-        },
-        associate(transform) {
-            return wrap(() => associate(factory(), transform));
-        },
-        associateBy(transform) {
-            return wrap(() => associateBy(factory(), transform));
-        },
-        associateWith(transform) {
-            return wrap(() => associateWith(factory(), transform));
-        },
-        zip(items) {
-            return wrap(() => zip(factory(), items));
-        },
-        unzip() {
-            return unzip(factory() as any);
-        },
-        windowed(size, step, partial) {
-            return wrap(() => windowed(factory(), size, step, partial));
-        },
-        chunked(size) {
-            return wrap(() => chunked(factory(), size));
-        },
-        groupBy(transform) {
-            return groupBy(factory(), transform);
-        },
-        reversed() {
-            return reversed(factory());
-        },
-        sorted() {
-            return sorted(factory() as any);
-        },
-        sortedWith(compare) {
-            return sortedWith(factory(), compare);
-        },
-        sortedBy(transform) {
-            return sortedBy(factory(), transform);
+        maxOfOrNull(transform) {
+            return maxOfOrNull(resolve(), transform);
         },
         joinToString(separator, transform) {
-            return joinToString(factory(), separator, transform);
+            return joinToString(resolve(), separator, transform);
+        },
+        plus(items) {
+            return wrap(() => plus(resolve(), items));
+        },
+        minus(items) {
+            return wrap(() => minus(resolve(), items));
+        },
+        intersect(items) {
+            return wrap(() => intersect(resolve(), items));
+        },
+        filter(predicate: (it: T) => boolean) {
+            return wrap(() => filter(resolve(), predicate));
+        },
+        partition(predicate) {
+            const [a, b] = partition(resolve(), predicate);
+            return [wrap(a), wrap(b)];
+        },
+        distinct() {
+            return wrap(() => distinct(resolve()));
+        },
+        distinctBy(transform) {
+            return wrap(() => distinctBy(resolve(), transform));
+        },
+        drop(count) {
+            return wrap(() => drop(resolve(), count));
+        },
+        dropWhile(predicate) {
+            return wrap(() => dropWhile(resolve(), predicate));
+        },
+        dropUntil(predicate) {
+            return wrap(() => dropUntil(resolve(), predicate));
+        },
+        take(count) {
+            return wrap(() => take(resolve(), count));
+        },
+        takeWhile(predicate) {
+            return wrap(() => takeWhile(resolve(), predicate));
+        },
+        takeUntil(predicate) {
+            return wrap(() => takeUntil(resolve(), predicate));
+        },
+        slice(start, end) {
+            return wrap(() => slice(resolve(), start, end));
+        },
+        map(transform) {
+            return wrap(() => map(resolve(), transform));
+        },
+        mapNotNull(transform) {
+            return wrap(() => mapNotNull(resolve(), transform));
+        },
+        flatten<R>() {
+            return wrap(() => flatten(resolve() as Iterable<Iterable<R>>));
+        },
+        flatMap(transform) {
+            return wrap(() => flatMap(resolve(), transform));
+        },
+        groupBy(transform) {
+            return wrap(groupBy(resolve(), transform));
+        },
+        associate(transform) {
+            return wrap(() => associate(resolve(), transform));
+        },
+        associateBy(transform) {
+            return wrap(() => associateBy(resolve(), transform));
+        },
+        associateWith(transform) {
+            return wrap(() => associateWith(resolve(), transform));
+        },
+        zip(items) {
+            return wrap(() => zip(resolve(), items));
+        },
+        unzip<A, B>() {
+            const [a, b] = unzip(resolve() as Iterable<[A, B]>);
+            return [wrap(a), wrap(b)];
+        },
+        windowed(size, step, partial) {
+            return wrap(() => windowed(resolve(), size, step, partial));
+        },
+        chunked(size) {
+            return wrap(() => chunked(resolve(), size));
+        },
+        reversed() {
+            return wrap(reversed(resolve()));
+        },
+        sorted() {
+            return wrap(sorted(resolve() as Iterable<number>));
+        },
+        sortedWith(compare) {
+            return wrap(sortedWith(resolve(), compare));
+        },
+        sortedBy(transform) {
+            return wrap(sortedBy(resolve(), transform));
         },
     };
 }

src/sequence/average.ts

@@ -1,3 +1,5 @@
+import {error} from "../util/error";
+
 export function average(value: Iterable<number>): number {
     let count = 0;
     let sum = 0;
@@ -5,5 +7,5 @@ export function average(value: Iterable<number>): number {
         count++;
         sum += it;
     }
-    return count !== 0 ? sum / count : 0;
+    return count !== 0 ? sum / count : error();
 }

src/sequence/averageBy.ts

@@ -1,3 +1,5 @@
+import {error} from "../util/error";
+
 export function averageBy<T>(value: Iterable<T>, transform: (it: T) => number): number {
     let count = 0;
     let sum = 0;
@@ -5,5 +7,5 @@ export function averageBy<T>(value: Iterable<T>, transform: (it: T) => number):
         count++;
         sum += transform(it);
     }
-    return count !== 0 ? sum / count : 0;
+    return count !== 0 ? sum / count : error();
 }

src/sequence/averageByOrNull.ts

@@ -0,0 +1,9 @@
+export function averageByOrNull<T>(value: Iterable<T>, transform: (it: T) => number): number | null {
+    let count = 0;
+    let sum = 0;
+    for (const it of value) {
+        count++;
+        sum += transform(it);
+    }
+    return count !== 0 ? sum / count : null;
+}

src/sequence/averageOrNull.ts

@@ -0,0 +1,9 @@
+export function averageOrNull(value: Iterable<number>): number | null {
+    let count = 0;
+    let sum = 0;
+    for (const it of value) {
+        count++;
+        sum += it;
+    }
+    return count !== 0 ? sum / count : null;
+}

src/sequence/chunked.ts

@@ -1,4 +1,7 @@
+import {error} from "../util/error";
+
 export function* chunked<T>(value: Iterable<T>, size: number): Iterable<T[]> {
+    if (size < 1) error();
     let buffer: T[] = [];
     for (const it of value) {
         buffer.push(it);

src/sequence/collect.ts

@@ -1,3 +0,0 @@
-export function collect<T>(value: Iterable<T>): T[] {
-    return [...value];
-}

src/sequence/containsAll.ts

@@ -1,7 +1,7 @@
 export function containsAll<T>(value: Iterable<T>, items: Iterable<T>): boolean {
-    const set = new Set(items);
-    for (const it of value) {
-        set.delete(it);
+    const set = new Set(value);
+    for (const it of items) {
+        if (!set.has(it)) return false;
     }
-    return set.size === 0;
+    return true;
 }

src/sequence/drop.ts

@@ -1,7 +1,13 @@
+import {error} from "../util/error";
+
 export function* drop<T>(value: Iterable<T>, count: number): Iterable<T> {
+    if (count < 0) error();
     let dropped = 0;
     for (const it of value) {
-        if (dropped === count) yield it;
-        else dropped++;
+        if (dropped < count) {
+            dropped++;
+            continue;
+        }
+        yield it;
     }
 }

src/sequence/dropUntil.ts

@@ -1,12 +1,11 @@
 export function* dropUntil<T>(value: Iterable<T>, predicate: (it: T) => boolean): Iterable<T> {
     const iterator = value[Symbol.iterator]();
-    let {value: it, done} = iterator.next();
-    while (!done) {
-        if (predicate(it)) break;
-        ({value: it, done} = iterator.next());
+    let next = iterator.next();
+    while (!next.done && !predicate(next.value)) {
+        next = iterator.next();
     }
-    while (!done) {
-        yield it;
-        ({value: it, done} = iterator.next());
+    while (!next.done) {
+        yield next.value;
+        next = iterator.next();
     }
 }

src/sequence/dropWhile.ts

@@ -1,12 +1,11 @@
 export function* dropWhile<T>(value: Iterable<T>, predicate: (it: T) => boolean): Iterable<T> {
     const iterator = value[Symbol.iterator]();
-    let {value: it, done} = iterator.next();
-    while (!done) {
-        if (!predicate(it)) break;
-        ({value: it, done} = iterator.next());
+    let next = iterator.next();
+    while (!next.done && predicate(next.value)) {
+        next = iterator.next();
     }
-    while (!done) {
-        yield it;
-        ({value: it, done} = iterator.next());
+    while (!next.done) {
+        yield next.value;
+        next = iterator.next();
     }
 }

src/sequence/filterIndexed.ts

@@ -1,6 +0,0 @@
-export function* filterIndexed<T>(value: Iterable<T>, predicate: (index: number, it: T) => boolean): Iterable<T> {
-    let index = 0;
-    for (const it of value) {
-        if (predicate(index++, it)) yield it;
-    }
-}

src/sequence/first.ts

@@ -1,4 +1,4 @@
-import {error} from "../util/error.js";
+import {error} from "../util/error";
 
 export function first<T>(value: Iterable<T>, predicate?: (it: T) => boolean): T {
     for (const it of value) {

src/sequence/firstIndex.ts

@@ -1,10 +0,0 @@
-import {error} from "../util/error.js";
-
-export function firstIndex<T>(value: Iterable<T>, predicate?: (it: T) => boolean): number {
-    let index = 0;
-    for (const it of value) {
-        if (!predicate || predicate(it)) return index;
-        index++;
-    }
-    error();
-}

src/sequence/firstIndexOrNull.ts

@@ -1,8 +0,0 @@
-export function firstIndexOrNull<T>(value: Iterable<T>, predicate?: (it: T) => boolean): number | null {
-    let index = 0;
-    for (const it of value) {
-        if (!predicate || predicate(it)) return index;
-        index++;
-    }
-    return null;
-}

src/sequence/flatMapIndexed.ts

@@ -1,6 +0,0 @@
-export function* flatMapIndexed<T, R>(value: Iterable<T>, transform: (index: number, it: T) => Iterable<R>): Iterable<R> {
-    let index = 0;
-    for (const it of value) {
-        yield* transform(index++, it);
-    }
-}

src/sequence/get.ts

@@ -1,6 +1,7 @@
-import {error} from "../util/error.js";
+import {error} from "../util/error";
 
 export function get<T>(value: Iterable<T>, index: number): T {
+    if (index < 0) error();
     let i = 0;
     for (const it of value) {
         if (i++ === index) return it;

src/sequence/getOrNull.ts

@@ -1,4 +1,5 @@
 export function getOrNull<T>(value: Iterable<T>, index: number): T | null {
+    if (index < 0) return null;
     let i = 0;
     for (const it of value) {
         if (i++ === index) return it;

src/sequence/indices.ts

@@ -1,4 +1,4 @@
-export function* indices(value: Iterable<unknown>): Iterable<number> {
+export function* indices<T>(value: Iterable<T>): Iterable<number> {
     let index = 0;
     for (const _ of value) {
         yield index++;

src/sequence/intersect.ts

@@ -0,0 +1,6 @@
+export function* intersect<T>(value: Iterable<T>, items: Iterable<T>): Iterable<T> {
+    const set = new Set(items);
+    for (const it of value) {
+        if (set.has(it)) yield it;
+    }
+}

src/sequence/last.ts

@@ -1,13 +1,10 @@
-import {error} from "../util/error.js";
+import {error} from "../util/error";
 
 export function last<T>(value: Iterable<T>, predicate?: (it: T) => boolean): T {
-    let last!: T;
-    let found = false;
+    let last: T | undefined;
     for (const it of value) {
-        if (predicate && !predicate(it)) continue;
-        last = it;
-        found = true;
+        if (!predicate || predicate(it)) last = it;
     }
-    if (!found) error();
+    if (last === undefined) error();
     return last;
 }

src/sequence/lastIndex.ts

@@ -1,12 +0,0 @@
-import {error} from "../util/error.js";
-
-export function lastIndex<T>(value: Iterable<T>, predicate?: (it: T) => boolean): number {
-    let last: number | undefined;
-    let index = 0;
-    for (const it of value) {
-        if (!predicate || predicate(it)) last = index;
-        index++;
-    }
-    if (last === undefined) error();
-    return last;
-}

src/sequence/lastIndexOrNull.ts

@@ -1,10 +0,0 @@
-export function lastIndexOrNull<T>(value: Iterable<T>, predicate?: (it: T) => boolean): number | null {
-    let last: number | undefined;
-    let index = 0;
-    for (const it of value) {
-        if (!predicate || predicate(it)) last = index;
-        index++;
-    }
-    if (last === undefined) return null;
-    return last;
-}

src/sequence/lastOrNull.ts

@@ -1,11 +1,8 @@
 export function lastOrNull<T>(value: Iterable<T>, predicate?: (it: T) => boolean): T | null {
-    let last!: T;
-    let found = false;
+    let last: T | undefined;
     for (const it of value) {
-        if (predicate && !predicate(it)) continue;
-        last = it;
-        found = true;
+        if (!predicate || predicate(it)) last = it;
     }
-    if (!found) return null;
+    if (last === undefined) return null;
     return last;
 }

src/sequence/mapIndexed.ts

@@ -1,6 +0,0 @@
-export function* mapIndexed<T, R>(value: Iterable<T>, transform: (index: number, it: T) => R): Iterable<R> {
-    let index = 0;
-    for (const it of value) {
-        yield transform(index++, it);
-    }
-}

src/sequence/mapNotNull.ts

@@ -0,0 +1,6 @@
+export function* mapNotNull<T, R>(value: Iterable<T>, transform: (it: T) => R | null): Iterable<R> {
+    for (const it of value) {
+        const transformed = transform(it);
+        if (transformed !== null) yield transformed;
+    }
+}

src/sequence/max.ts

@@ -1,13 +1,10 @@
-import {error} from "../util/error.js";
+import {error} from "../util/error";
 
 export function max(value: Iterable<number>): number {
-    let max!: number;
-    let found = false;
+    let max: number | undefined;
     for (const it of value) {
-        if (found && it <= max) continue;
-        max = it;
-        found = true;
+        if (max === undefined || it > max) max = it;
     }
-    if (!found) error();
+    if (max === undefined) error();
     return max;
 }

src/sequence/maxBy.ts

@@ -1,16 +1,15 @@
-import {error} from "../util/error.js";
+import {error} from "../util/error";
 
 export function maxBy<T>(value: Iterable<T>, transform: (it: T) => number): T {
-    let maxIt!: T;
-    let max!: number;
-    let found = false;
+    let max!: T;
+    let maxVal: number | undefined;
     for (const it of value) {
         const val = transform(it);
-        if (found && val <= max) continue;
-        maxIt = it;
-        max = val;
-        found = true;
+        if (maxVal === undefined || val > maxVal) {
+            max = it;
+            maxVal = val;
         }
-    if (!found) error();
-    return maxIt;
+    }
+    if (maxVal === undefined) error();
+    return max;
 }

src/sequence/maxByOrNull.ts

@@ -1,14 +1,13 @@
 export function maxByOrNull<T>(value: Iterable<T>, transform: (it: T) => number): T | null {
-    let maxIt!: T;
-    let max!: number;
-    let found = false;
+    let max!: T;
+    let maxVal: number | undefined;
     for (const it of value) {
         const val = transform(it);
-        if (found && val <= max) continue;
-        maxIt = it;
-        max = val;
-        found = true;
+        if (maxVal === undefined || val > maxVal) {
+            max = it;
+            maxVal = val;
         }
-    if (!found) return null;
-    return maxIt;
+    }
+    if (maxVal === undefined) return null;
+    return max;
 }

src/sequence/maxOf.ts

@@ -1,14 +1,11 @@
-import {error} from "../util/error.js";
+import {error} from "../util/error";
 
 export function maxOf<T>(value: Iterable<T>, transform: (it: T) => number): number {
-    let max!: number;
-    let found = false;
+    let max: number | undefined;
     for (const it of value) {
         const val = transform(it);
-        if (found && val <= max) continue;
-        max = val;
-        found = true;
+        if (max === undefined || val > max) max = val;
     }
-    if (!found) error();
+    if (max === undefined) error();
     return max;
 }

src/sequence/maxOfOrNull.ts

@@ -1,12 +1,9 @@
 export function maxOfOrNull<T>(value: Iterable<T>, transform: (it: T) => number): number | null {
-    let max!: number;
-    let found = false;
+    let max: number | undefined;
     for (const it of value) {
         const val = transform(it);
-        if (found && val <= max) continue;
-        max = val;
-        found = true;
+        if (max === undefined || val > max) max = val;
     }
-    if (!found) return null;
+    if (max === undefined) return null;
     return max;
 }

src/sequence/maxOrNull.ts

@@ -1,11 +1,8 @@
 export function maxOrNull(value: Iterable<number>): number | null {
-    let max!: number;
-    let found = false;
+    let max: number | undefined;
     for (const it of value) {
-        if (found && it <= max) continue;
-        max = it;
-        found = true;
+        if (max === undefined || it > max) max = it;
     }
-    if (!found) return null;
+    if (max === undefined) return null;
     return max;
 }

src/sequence/maxWith.ts

@@ -1,13 +1,10 @@
-import {error} from "../util/error.js";
+import {error} from "../util/error";
 
 export function maxWith<T>(value: Iterable<T>, compare: (a: T, b: T) => number): T {
-    let max!: T;
-    let found = false;
+    let max: T | undefined;
     for (const it of value) {
-        if (found && compare(it, max) <= 0) continue;
-        max = it;
-        found = true;
+        if (max === undefined || compare(it, max) > 0) max = it;
     }
-    if (!found) error();
+    if (max === undefined) error();
     return max;
 }

src/sequence/maxWithOrNull.ts

@@ -1,11 +1,8 @@
 export function maxWithOrNull<T>(value: Iterable<T>, compare: (a: T, b: T) => number): T | null {
-    let max!: T;
-    let found = false;
+    let max: T | undefined;
     for (const it of value) {
-        if (found && compare(it, max) <= 0) continue;
-        max = it;
-        found = true;
+        if (max === undefined || compare(it, max) > 0) max = it;
     }
-    if (!found) return null;
+    if (max === undefined) return null;
     return max;
 }

src/sequence/min.ts

@@ -1,13 +1,10 @@
-import {error} from "../util/error.js";
+import {error} from "../util/error";
 
 export function min(value: Iterable<number>): number {
-    let min!: number;
-    let found = false;
+    let min: number | undefined;
     for (const it of value) {
-        if (found && it >= min) continue;
-        min = it;
-        found = true;
+        if (min === undefined || it < min) min = it;
     }
-    if (!found) error();
+    if (min === undefined) error();
     return min;
 }

src/sequence/minBy.ts

@@ -1,16 +1,15 @@
-import {error} from "../util/error.js";
+import {error} from "../util/error";
 
 export function minBy<T>(value: Iterable<T>, transform: (it: T) => number): T {
     let minIt!: T;
-    let min!: number;
-    let found = false;
+    let minVal: number | undefined;
     for (const it of value) {
         const val = transform(it);
-        if (found && val >= min) continue;
+        if (minVal === undefined || val < minVal) {
             minIt = it;
-        min = val;
-        found = true;
+            minVal = val;
         }
-    if (!found) error();
+    }
+    if (minVal === undefined) error();
     return minIt;
 }

src/sequence/minByOrNull.ts

@@ -1,14 +1,13 @@
 export function minByOrNull<T>(value: Iterable<T>, transform: (it: T) => number): T | null {
     let minIt!: T;
-    let min!: number;
-    let found = false;
+    let minVal: number | undefined;
     for (const it of value) {
         const val = transform(it);
-        if (found && val >= min) continue;
+        if (minVal === undefined || val < minVal) {
             minIt = it;
-        min = val;
-        found = true;
+            minVal = val;
         }
-    if (!found) return null;
+    }
+    if (minVal === undefined) return null;
     return minIt;
 }

src/sequence/minOf.ts

@@ -1,14 +1,11 @@
-import {error} from "../util/error.js";
+import {error} from "../util/error";
 
 export function minOf<T>(value: Iterable<T>, transform: (it: T) => number): number {
-    let min!: number;
-    let found = false;
+    let min: number | undefined;
     for (const it of value) {
         const val = transform(it);
-        if (found && val >= min) continue;
-        min = val;
-        found = true;
+        if (min === undefined || val < min) min = val;
     }
-    if (!found) error();
+    if (min === undefined) error();
     return min;
 }

src/sequence/minOfOrNull.ts

@@ -1,12 +1,9 @@
 export function minOfOrNull<T>(value: Iterable<T>, transform: (it: T) => number): number | null {
-    let min!: number;
-    let found = false;
+    let min: number | undefined;
     for (const it of value) {
         const val = transform(it);
-        if (found && val >= min) continue;
-        min = val;
-        found = true;
+        if (min === undefined || val < min) min = val;
     }
-    if (!found) return null;
+    if (min === undefined) return null;
     return min;
 }

src/sequence/minOrNull.ts

@@ -1,11 +1,8 @@
 export function minOrNull(value: Iterable<number>): number | null {
-    let min!: number;
-    let found = false;
+    let min: number | undefined;
     for (const it of value) {
-        if (found && it <= min) continue;
-        min = it;
-        found = true;
+        if (min === undefined || it < min) min = it;
     }
-    if (!found) return null;
+    if (min === undefined) return null;
     return min;
 }

src/sequence/minWith.ts

@@ -1,14 +1,10 @@
-import {error} from "../util/error.js";
+import {error} from "../util/error";
 
 export function minWith<T>(value: Iterable<T>, compare: (a: T, b: T) => number): T {
-    const iterator = value[Symbol.iterator]();
-    let {value: it, done} = iterator.next();
-    if (done) error();
-    let min = it;
-    ({value: it, done} = iterator.next());
-    while (!done) {
-        if (compare(it, min) < 0) min = it;
-        ({value: it, done} = iterator.next());
+    let min: T | undefined;
+    for (const it of value) {
+        if (min === undefined || compare(it, min) < 0) min = it;
     }
+    if (min === undefined) error();
     return min;
 }

src/sequence/minWithOrNull.ts

@@ -1,12 +1,8 @@
 export function minWithOrNull<T>(value: Iterable<T>, compare: (a: T, b: T) => number): T | null {
-    const iterator = value[Symbol.iterator]();
-    let {value: it, done} = iterator.next();
-    if (done) return null;
-    let min = it;
-    ({value: it, done} = iterator.next());
-    while (!done) {
-        if (compare(it, min) < 0) min = it;
-        ({value: it, done} = iterator.next());
+    let min: T | undefined;
+    for (const it of value) {
+        if (min === undefined || compare(it, min) < 0) min = it;
     }
+    if (min === undefined) return null;
     return min;
 }

src/sequence/partition.ts

@@ -1,9 +1,30 @@
-export function partition<T>(value: Iterable<T>, predicate: (it: T) => boolean): [T[], T[]] {
+export function partition<T>(value: Iterable<T>, predicate: (it: T) => boolean): [() => Iterable<T>, () => Iterable<T>] {
+    const iterator = value[Symbol.iterator]();
+    let finished = false;
     const t: T[] = [];
     const f: T[] = [];
-    for (const it of value) {
-        if (predicate(it)) t.push(it);
-        else f.push(it);
+
+    function next() {
+        const {value, done} = iterator.next();
+        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];
 }

src/sequence/plus.ts

@@ -1,8 +1,8 @@
-export function* plus<T>(value1: Iterable<T>, value2: Iterable<T>): Iterable<T> {
-    for (const it of value1) {
+export function* plus<T>(value: Iterable<T>, items: Iterable<T>): Iterable<T> {
+    for (const it of value) {
         yield it;
     }
-    for (const it of value2) {
+    for (const it of items) {
         yield it;
     }
 }

src/sequence/reduce.ts

@@ -1,14 +1,14 @@
-import {error} from "../util/error.js";
+import {error} from "../util/error";
 
 export function reduce<T>(value: Iterable<T>, accumulate: (acc: T, it: T) => T): T {
     const iterator = value[Symbol.iterator]();
-    let {value: it, done} = iterator.next();
-    if (done) error();
-    let acc = it
-    ({value: it, done} = iterator.next());
-    while (!done) {
-        acc = accumulate(acc, it);
-        ({value: it, done} = iterator.next());
+    const first = iterator.next();
+    if (first.done) error();
+    let acc = first.value;
+    let next = iterator.next();
+    while (!next.done) {
+        acc = accumulate(acc, next.value);
+        next = iterator.next();
     }
     return acc;
 }

src/sequence/reduceOrNull.ts

@@ -1,12 +1,12 @@
 export function reduceOrNull<T>(value: Iterable<T>, accumulate: (acc: T, it: T) => T): T | null {
     const iterator = value[Symbol.iterator]();
-    let {value: it, done} = iterator.next();
-    if (done) return null;
-    let acc = it
-    ({value: it, done} = iterator.next());
-    while (!done) {
-        acc = accumulate(acc, it);
-        ({value: it, done} = iterator.next());
+    const first = iterator.next();
+    if (first.done) return null;
+    let acc = first.value;
+    let next = iterator.next();
+    while (!next.done) {
+        acc = accumulate(acc, next.value);
+        next = iterator.next();
     }
     return acc;
 }

src/sequence/reversed.ts

@@ -1,3 +1,3 @@
-export function reversed<T>(iterable: Iterable<T>): T[] {
-    return [...iterable].reverse();
+export function reversed<T>(value: Iterable<T>): T[] {
+    return [...value].reverse();
 }

src/sequence/single.ts

@@ -1,14 +1,13 @@
-import {error} from "../util/error.js";
+import {error} from "../util/error";
 
 export function single<T>(value: Iterable<T>, predicate?: (it: T) => boolean): T {
-    let last!: T;
-    let found = false;
+    let last: T | undefined;
     for (const it of value) {
-        if (predicate && !predicate(it)) continue;
-        if (found) error();
+        if (!predicate || predicate(it)) {
+            if (last !== undefined) error();
             last = it;
-        found = true;
         }
-    if (!found) error();
+    }
+    if (last === undefined) error();
     return last;
 }

src/sequence/singleOrNull.ts

@@ -1,12 +1,11 @@
 export function singleOrNull<T>(value: Iterable<T>, predicate?: (it: T) => boolean): T | null {
-    let last!: T;
-    let found = false;
+    let last: T | undefined;
     for (const it of value) {
-        if (predicate && !predicate(it)) continue;
-        if (found) return null;
+        if (!predicate || predicate(it)) {
+            if (last !== undefined) return null;
             last = it;
-        found = true;
         }
-    if (!found) return null;
+    }
+    if (last === undefined) return null;
     return last;
 }

src/sequence/slice.ts

@@ -1,7 +1,16 @@
-export function* slice<T>(value: Iterable<T>, start: number, endInclusive?: number): Iterable<T> {
+import {error} from "../util/error";
+
+export function* slice<T>(value: Iterable<T>, start: number, end?: number): Iterable<T> {
+    if (start < 0) error();
+    if (end !== undefined) {
+        if (end < 0) error();
+        if (start > end) error();
+    }
     let index = 0;
     for (const it of value) {
-        if (endInclusive !== undefined && index > endInclusive) return;
-        if (index++ >= start) yield it;
+        if (index >= start) yield it;
+        index++;
+        if (index === end) return;
     }
+    if (end !== undefined) error();
 }

src/sequence/sorted.ts

@@ -1,3 +1,3 @@
-export function sorted(iterable: Iterable<number>): number[] {
-    return [...iterable].sort((a, b) => a - b);
+export function sorted(value: Iterable<number>): number[] {
+    return [...value].sort((a, b) => a - b);
 }

src/sequence/sortedBy.ts

@@ -1,3 +1,3 @@
-export function sortedBy<T>(iterable: Iterable<T>, transform: (it: T) => number): T[] {
-    return [...iterable].sort((a, b) => transform(a) - transform(b));
+export function sortedBy<T>(value: Iterable<T>, transform: (it: T) => number): T[] {
+    return [...value].sort((a, b) => transform(a) - transform(b));
 }

src/sequence/sortedWith.ts

@@ -1,3 +1,3 @@
-export function sortedWith<T>(iterable: Iterable<T>, compare: (a: T, b: T) => number): T[] {
-    return [...iterable].sort(compare);
+export function sortedWith<T>(value: Iterable<T>, compare: (a: T, b: T) => number): T[] {
+    return [...value].sort(compare);
 }

src/sequence/take.ts

@@ -1,7 +1,11 @@
+import {error} from "../util/error";
+
 export function* take<T>(value: Iterable<T>, count: number): Iterable<T> {
+    if (count < 0) error();
     let taken = 0;
     for (const it of value) {
-        if (taken++ === count) return;
         yield it;
+        taken++;
+        if (taken === count) return;
     }
 }

src/sequence/toArray.ts

@@ -0,0 +1,3 @@
+export function toArray<T>(value: Iterable<T>): T[] {
+    return [...value];
+}

src/sequence/toMap.ts

@@ -0,0 +1,3 @@
+export function toMap<K, V>(value: Iterable<[K, V]>): Map<K, V> {
+    return new Map(value);
+}

src/sequence/toSet.ts

@@ -0,0 +1,3 @@
+export function toSet<T>(value: Iterable<T>): Set<T> {
+    return new Set(value);
+}

src/sequence/unzip.ts

@@ -1,12 +1,29 @@
-export function unzip<A, B>(value: Iterable<[A, B]>): [A[], B[]] {
-    const a: A[] = [];
-    const b: B[] = [];
+export function unzip<A, B>(value: Iterable<[A, B]>): [() => Iterable<A>, () => Iterable<B>] {
     const iterator = value[Symbol.iterator]();
-    let {value: it, done} = iterator.next();
-    while (!done) {
-        a.push(it[0]);
-        b.push(it[1]);
-        ({value: it, done} = iterator.next());
+    let finished = false;
+    const cache: [A, B][] = [];
+
+    function next() {
+        const {value, done} = iterator.next();
+        if (done) finished = true;
+        else cache.push(value);
     }
-    return [a, b];
+
+    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];
 }

src/sequence/windowed.ts

@@ -1,4 +1,8 @@
+import {error} from "../util/error";
+
 export function* windowed<T>(value: Iterable<T>, size: number, step: number = 1, partial: boolean = false): Iterable<T[]> {
+    if (size < 1) error();
+    if (step < 1) error();
     const buffer: T[] = [];
     for (const it of value) {
         buffer.push(it);
@@ -7,9 +11,10 @@ export function* windowed<T>(value: Iterable<T>, size: number, step: number = 1,
             buffer.splice(0, step);
         }
     }
-    if (!partial) return;
+    if (partial) {
         while (buffer.length !== 0) {
             yield [...buffer];
             buffer.splice(0, step);
         }
+    }
 }

src/sequence/zip.ts

@@ -1,9 +1,11 @@
 export function* zip<T, B>(value: Iterable<T>, items: Iterable<B>): Iterable<[T, B]> {
     const iteratorA = value[Symbol.iterator]();
     const iteratorB = items[Symbol.iterator]();
-    let {value: itA, done: doneA} = iteratorA.next();
-    let {value: itB, done: doneB} = iteratorB.next();
-    while (!doneA && !doneB) {
-        yield [itA, itB];
+    let a = iteratorA.next();
+    let b = iteratorB.next();
+    while (!a.done && !b.done) {
+        yield [a.value, b.value];
+        a = iteratorA.next();
+        b = iteratorB.next();
     }
 }

tsconfig.json

@@ -1,11 +1,13 @@
 {
   "compilerOptions": {
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
     "target": "ESNext",
-    "rootDir": "./src/",
-    "outDir": "./dist/",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
     "declaration": true,
-    "strict": true
-  }
+    "outDir": "./dist/"
+  },
+  "include": [
+    "./src/"
+  ]
 }