iterutil

Iterator / AsyncIterator utility pack for JavaScript and TypeScript. Each module is designed to work independently, avoiding internal inter-dependencies as much as possible.

Usage

To apply single operation to an iterable, use modules under the root.

import { map } from "@core/iterutil/map";

const iter = map([1, 2, 3], (v) => v * 2);
console.log(Array.from(iter)); // [2, 4, 6]

To apply single asynchronous operation to an (async) iterable, use modules under the async submodule.

import { map } from "@core/iterutil/async/map";

const iter = map([1, 2, 3], (v) => Promise.resolve(v * 2));
console.log(await Array.fromAsync(iter)); // [2, 4, 6]

To apply multiple operations to an iterable, use the modules under the pipe submodule with the @core/pipe package.

import { pipe } from "@core/pipe";
import { cycle } from "@core/iterutil/pipe/cycle";
import { filter } from "@core/iterutil/pipe/filter";
import { map } from "@core/iterutil/pipe/map";
import { take } from "@core/iterutil/pipe/take";

const iter = pipe(
  [1, 2, 3],
  map((v) => v * 2),
  cycle,
  take(10),
  filter((v) => v % 2 === 0),
);
console.log(Array.from(iter)); // [2, 4, 6, 2, 4, 6, 2, 4, 6, 2]

To apply multiple asynchronous operations to an (async) iterable, use the modules under the pipe/async submodule with the @core/pipe package.

import { pipe } from "@core/pipe";
import { cycle } from "@core/iterutil/pipe/async/cycle";
import { filter } from "@core/iterutil/pipe/async/filter";
import { map } from "@core/iterutil/pipe/async/map";
import { take } from "@core/iterutil/pipe/async/take";

const iter = pipe(
  [1, 2, 3],
  map((v) => Promise.resolve(v * 2)),
  cycle,
  take(10),
  filter((v) => Promise.resolve(v % 2 === 0)),
);
console.log(await Array.fromAsync(iter)); // [2, 4, 6, 2, 4, 6, 2, 4, 6, 2]

chain

Chains multiple iterables together.

import { chain } from "@core/iterutil/chain";

const iter = chain([1, 2], ["a", "b"], [true, false]);
console.log(Array.from(iter)); // [1, 2, "a", "b", true, false]

import { chain } from "@core/iterutil/async/chain";

const iter = chain([1, 2], ["a", "b"], [true, false]);
console.log(await Array.fromAsync(iter)); // [1, 2, "a", "b", true, false]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { chain } from "@core/iterutil/pipe/chain";

const iter = pipe(
  [1, 2],
  chain(["a", "b"], [true, false]),
);
console.log(Array.from(iter)); // [1, 2, "a", "b", true, false]

import { pipe } from "@core/pipe";
import { chain } from "@core/iterutil/pipe/async/chain";

const iter = pipe(
  [1, 2],
  chain(["a", "b"], [true, false]),
);
console.log(await Array.fromAsync(iter)); // [1, 2, "a", "b", true, false]

chunked

Chunks an iterable into arrays of a given size.

import { chunked } from "@core/iterutil/chunked";

const iter = chunked([1, 2, 3, 4, 5], 2);
console.log(Array.from(iter)); // [[1, 2], [3, 4], [5]]

import { chunked } from "@core/iterutil/async/chunked";

const iter = chunked([1, 2, 3, 4, 5], 2);
console.log(await Array.fromAsync(iter)); // [[1, 2], [3, 4], [5]]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { chunked } from "@core/iterutil/pipe/chunked";

const iter = pipe(
  [1, 2, 3, 4, 5],
  chunked(2),
);
console.log(Array.from(iter)); // [[1, 2], [3, 4], [5]]

import { pipe } from "@core/pipe";
import { chunked } from "@core/iterutil/pipe/async/chunked";

const iter = pipe(
  [1, 2, 3, 4, 5],
  chunked(2),
);
console.log(await Array.fromAsync(iter)); // [[1, 2], [3, 4], [5]]

compact

Removes all nullish (null or undefined) values from an iterable.

import { compact } from "@core/iterutil/compact";

const iter = compact([1, undefined, 2, null, 3]);
console.log(Array.from(iter)); // [1, 2, 3]

import { compact } from "@core/iterutil/async/compact";

const iter = compact([1, undefined, 2, null, 3]);
console.log(await Array.fromAsync(iter)); // [1, 2, 3]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { compact } from "@core/iterutil/pipe/compact";

const iter = pipe(
  [1, undefined, 2, null, 3],
  compact,
);
console.log(Array.from(iter)); // [1, 2, 3]

import { pipe } from "@core/pipe";
import { compact } from "@core/iterutil/pipe/async/compact";

const iter = pipe(
  [1, undefined, 2, null, 3],
  compact,
);
console.log(await Array.fromAsync(iter)); // [1, 2, 3]

compress

Compresses an iterable by selecting elements using a selector iterable.

import { compress } from "@core/iterutil/compress";

const iter = compress(
  [1, 2, 3, 4, 5],
  [true, false, true, false, true],
);
console.log(Array.from(iter)); // [1, 3, 5]

import { compress } from "@core/iterutil/async/compress";

const iter = compress(
  [1, 2, 3, 4, 5],
  [true, false, true, false, true],
);
console.log(await Array.fromAsync(iter)); // [1, 3, 5]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { compress } from "@core/iterutil/pipe/compress";

const iter = pipe(
  [1, 2, 3, 4, 5],
  compress([true, false, true, false, true]),
);
console.log(Array.from(iter)); // [1, 3, 5]

import { pipe } from "@core/pipe";
import { compress } from "@core/iterutil/pipe/async/compress";

const iter = pipe(
  [1, 2, 3, 4, 5],
  compress([true, false, true, false, true]),
);
console.log(await Array.fromAsync(iter)); // [1, 3, 5]

count

Generates an infinite sequence of numbers starting from start with a step of step.

import { count } from "@core/iterutil/count";
import { take } from "@core/iterutil/take";

const iter = count(1, 2);
console.log(Array.from(take(iter, 5))); // [1, 3, 5, 7, 9]

cycle

Returns an infinite iterable that cycles through the given iterable.

import { cycle } from "@core/iterutil/cycle";
import { take } from "@core/iterutil/take";

const iter = cycle([1, 2, 3]);
console.log(Array.from(take(iter, 5))); // [1, 2, 3, 1, 2]

import { cycle } from "@core/iterutil/async/cycle";
import { take } from "@core/iterutil/async/take";

const iter = cycle([1, 2, 3]);
console.log(await Array.fromAsync(take(iter, 5))); // [1, 2, 3, 1, 2]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { cycle } from "@core/iterutil/pipe/cycle";
import { take } from "@core/iterutil/pipe/take";

const iter = pipe(
  [1, 2, 3],
  cycle,
  take(5),
);
console.log(Array.from(iter)); // [1, 2, 3, 1, 2]

import { pipe } from "@core/pipe";
import { cycle } from "@core/iterutil/pipe/async/cycle";
import { take } from "@core/iterutil/pipe/async/take";

const iter = pipe(
  [1, 2, 3],
  cycle,
  take(5),
);
console.log(await Array.fromAsync(iter)); // [1, 2, 3, 1, 2]

drop

Drops the first limit items from the iterable.

import { drop } from "@core/iterutil/drop";

const iter = drop([1, 2, 3, 4, 5], 2);
console.log(Array.from(iter)); // [3, 4, 5]

import { drop } from "@core/iterutil/async/drop";

const iter = drop([1, 2, 3, 4, 5], 2);
console.log(await Array.fromAsync(iter)); // [3, 4, 5]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { drop } from "@core/iterutil/pipe/drop";

const iter = pipe(
  [1, 2, 3, 4, 5],
  drop(2),
);
console.log(Array.from(iter)); // [3, 4, 5]

import { pipe } from "@core/pipe";
import { drop } from "@core/iterutil/pipe/async/drop";

const iter = pipe(
  [1, 2, 3, 4, 5],
  drop(2),
);
console.log(await Array.fromAsync(iter)); // [3, 4, 5]

dropWhile

Drops elements from the iterable while the predicate returns true.

import { dropWhile } from "@core/iterutil/drop-while";

const iter = dropWhile(
  [1, 2, 3, 4, 5],
  (v) => v < 3,
);
console.log(Array.from(iter)); // [3, 4, 5]

import { dropWhile } from "@core/iterutil/async/drop-while";

const iter = dropWhile(
  [1, 2, 3, 4, 5],
  (v) => v < 3,
);
console.log(await Array.fromAsync(iter)); // [3, 4, 5]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { dropWhile } from "@core/iterutil/pipe/drop-while";

const iter = pipe(
  [1, 2, 3, 4, 5],
  dropWhile((v) => v < 3),
);
console.log(Array.from(iter)); // [3, 4, 5]

import { pipe } from "@core/pipe";
import { dropWhile } from "@core/iterutil/pipe/async/drop-while";

const iter = pipe(
  [1, 2, 3, 4, 5],
  dropWhile((v) => v < 3),
);
console.log(await Array.fromAsync(iter)); // [3, 4, 5]

enumerate

Enumerates an iterable.

import { enumerate } from "@core/iterutil/enumerate";

const iter = enumerate(["a", "b", "c"]);
console.log(Array.from(iter)); // [[0, "a"], [1, "b"], [2, "c"]]

import { enumerate } from "@core/iterutil/async/enumerate";

const iter = enumerate(["a", "b", "c"]);
console.log(await Array.fromAsync(iter)); // [[0, "a"], [1, "b"], [2, "c"]]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { enumerate } from "@core/iterutil/pipe/enumerate";

const iter = pipe(["a", "b", "c"], enumerate);
console.log(Array.from(iter)); // [[0, "a"], [1, "b"], [2, "c"]]

import { pipe } from "@core/pipe";
import { enumerate } from "@core/iterutil/pipe/async/enumerate";

const iter = pipe(["a", "b", "c"], enumerate);
console.log(await Array.fromAsync(iter)); // [[0, "a"], [1, "b"], [2, "c"]]

every

Returns true if every element in the iterable satisfies the provided testing function.

import { every } from "@core/iterutil/every";

console.log(every([1, 2, 3], (v) => v > 0)); // true
console.log(every([1, 2, 3], (v) => v > 1)); // false

import { every } from "@core/iterutil/async/every";

console.log(await every([1, 2, 3], (v) => v > 0)); // true
console.log(await every([1, 2, 3], (v) => v > 1)); // false

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { every } from "@core/iterutil/pipe/every";

console.log(pipe([1, 2, 3], every((v) => v > 0))); // true
console.log(pipe([1, 2, 3], every((v) => v > 1))); // false

import { pipe } from "@core/pipe";
import { every } from "@core/iterutil/pipe/async/every";

console.log(await pipe([1, 2, 3], every((v) => v > 0))); // true
console.log(await pipe([1, 2, 3], every((v) => v > 1))); // false

filter

Filters an iterable based on a function.

import { filter } from "@core/iterutil/filter";

const iter = filter(
  [1, 2, 3, 4, 5],
  (v) => v % 2 === 0,
);
console.log(Array.from(iter)); // [2, 4]

import { filter } from "@core/iterutil/async/filter";

const iter = filter(
  [1, 2, 3, 4, 5],
  (v) => v % 2 === 0,
);
console.log(await Array.fromAsync(iter)); // [2, 4]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { filter } from "@core/iterutil/pipe/filter";

const iter = pipe(
  [1, 2, 3, 4, 5],
  filter((v) => v % 2 === 0),
);
console.log(Array.from(iter)); // [2, 4]

import { pipe } from "@core/pipe";
import { filter } from "@core/iterutil/pipe/async/filter";

const iter = pipe(
  [1, 2, 3, 4, 5],
  filter((v) => v % 2 === 0),
);
console.log(await Array.fromAsync(iter)); // [2, 4]

find

Returns the first element in the iterable that satisfies the provided testing function. Otherwise, undefined is returned.

import { find } from "@core/iterutil/find";

const value = find(
  [1, 2, 3, 4, 5],
  (v) => v % 2 === 0,
);
console.log(value); // 2

import { find } from "@core/iterutil/async/find";

const value = await find(
  [1, 2, 3, 4, 5],
  (v) => v % 2 === 0,
);
console.log(value); // 2

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { find } from "@core/iterutil/pipe/find";

const value = pipe(
  [1, 2, 3, 4, 5],
  find((v) => v % 2 === 0),
);
console.log(value); // 2

import { pipe } from "@core/pipe";
import { find } from "@core/iterutil/pipe/async/find";

const value = await pipe(
  [1, 2, 3, 4, 5],
  find((v) => v % 2 === 0),
);
console.log(value); // 2

first

Returns the first element of an iterable. If the iterable is empty, returns undefined.

import { first } from "@core/iterutil/first";

const result = first([1, 2, 3]);
console.log(result); // 1

import { first } from "@core/iterutil/async/first";

const result = await first([1, 2, 3]);
console.log(result); // 1

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { first } from "@core/iterutil/pipe/first";

const result = pipe([1, 2, 3], first);
console.log(result); // 1

import { pipe } from "@core/pipe";
import { first } from "@core/iterutil/pipe/async/first";

const result = await pipe([1, 2, 3], first);
console.log(result); // 1

flatMap

Maps each value in an iterable to an iterable, then flattens the result.

import { flatMap } from "@core/iterutil/flat-map";

const iter = flatMap(
  [1, 2, 3],
  (v) => [v, v],
);
console.log(Array.from(iter)); // [1, 1, 2, 2, 3, 3]

import { flatMap } from "@core/iterutil/async/flat-map";

const iter = flatMap(
  [1, 2, 3],
  (v) => [v, v],
);
console.log(await Array.fromAsync(iter)); // [1, 1, 2, 2, 3, 3]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { flatMap } from "@core/iterutil/pipe/flat-map";

const iter = pipe(
  [1, 2, 3],
  flatMap((v) => [v, v]),
);
console.log(Array.from(iter)); // [1, 1, 2, 2, 3, 3]

import { pipe } from "@core/pipe";
import { flatMap } from "@core/iterutil/pipe/async/flat-map";

const iter = pipe(
  [1, 2, 3],
  flatMap((v) => [v, v]),
);
console.log(await Array.fromAsync(iter)); // [1, 1, 2, 2, 3, 3]

flatten

Flattens an iterable of iterables into a single iterable.

import { flatten } from "@core/iterutil/flatten";

const iter = flatten([[1, 2], [3, 4], [5]]);
console.log(Array.from(iter)); // [1, 2, 3, 4, 5]

import { flatten } from "@core/iterutil/async/flatten";

const iter = flatten([[1, 2], [3, 4], [5]]);
console.log(await Array.fromAsync(iter)); // [1, 2, 3, 4, 5]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { flatten } from "@core/iterutil/pipe/flatten";

const iter = pipe(
  [[1, 2], [3, 4], [5]],
  flatten,
);
console.log(Array.from(iter)); // [1, 2, 3, 4, 5]

import { pipe } from "@core/pipe";
import { flatten } from "@core/iterutil/pipe/async/flatten";

const iter = pipe(
  [[1, 2], [3, 4], [5]],
  flatten,
);
console.log(await Array.fromAsync(iter)); // [1, 2, 3, 4, 5]

forEach

Calls a function for each value in an iterable.

import { forEach } from "@core/iterutil/for-each";
forEach([1, 2, 3], (v) => console.log(v));
// 1
// 2
// 3

import { forEach } from "@core/iterutil/async/for-each";
await forEach([1, 2, 3], (v) => console.log(v));
// 1
// 2
// 3

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { forEach } from "@core/iterutil/pipe/for-each";
pipe(
  [1, 2, 3],
  forEach((v) => console.log(v)),
);
// 1
// 2
// 3

import { pipe } from "@core/pipe";
import { forEach } from "@core/iterutil/pipe/async/for-each";
await pipe(
  [1, 2, 3],
  forEach((v) => console.log(v)),
);
// 1
// 2
// 3

iter

Converts an iterable to an iterator.

import { iter } from "@core/iterutil/iter";

const it = iter([1, 2, 3, 4, 5]);
console.log(it.next()); // { value: 1, done: false }
console.log(it.next()); // { value: 2, done: false }

for (const value of it) {
  console.log(value);
}
// 3
// 4
// 5

import { iter } from "@core/iterutil/async/iter";

const it = iter([1, 2, 3, 4, 5]);
console.log(await it.next()); // { value: 1, done: false }
console.log(await it.next()); // { value: 2, done: false }

for await (const value of it) {
  console.log(value);
}
// 3
// 4
// 5

last

Returns the last element of an iterable.

import { last } from "@core/iterutil/last";

console.log(last([1, 2, 3])); // 3
console.log(last([])); // undefined

import { last } from "@core/iterutil/async/last";

console.log(await last([1, 2, 3])); // 3
console.log(await last([])); // undefined

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { last } from "@core/iterutil/pipe/last";

console.log(pipe([1, 2, 3], last)); // 3
console.log(pipe([], last)); // undefined

import { pipe } from "@core/pipe";
import { last } from "@core/iterutil/pipe/async/last";

console.log(await pipe([1, 2, 3], last)); // 3
console.log(await pipe([], last)); // undefined

map

Maps an iterable with a function.

import { map } from "@core/iterutil/map";

const iter = map(
  [1, 2, 3],
  (v) => v * 2,
);
console.log(Array.from(iter)); // [2, 4, 6]

import { map } from "@core/iterutil/async/map";

const iter = map(
  [1, 2, 3],
  (v) => v * 2,
);
console.log(await Array.fromAsync(iter)); // [2, 4, 6]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { map } from "@core/iterutil/pipe/map";

const iter = pipe(
  [1, 2, 3],
  map((v) => v * 2),
);
console.log(Array.from(iter)); // [2, 4, 6]

import { pipe } from "@core/pipe";
import { map } from "@core/iterutil/pipe/async/map";

const iter = pipe(
  [1, 2, 3],
  map((v) => v * 2),
);
console.log(await Array.fromAsync(iter)); // [2, 4, 6]

nth

Returns the n-th element of an iterable. If the length of the iterable is less, returns undefined.

import { nth } from "@core/iterutil/nth";

const result = nth([1, 2, 3], 1);
console.log(result); // 2

import { nth } from "@core/iterutil/async/nth";

const result = await nth([1, 2, 3], 1);
console.log(result); // 2

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { nth } from "@core/iterutil/pipe/nth";

const result = pipe([1, 2, 3], nth(1));
console.log(result); // 2

import { pipe } from "@core/pipe";
import { nth } from "@core/iterutil/pipe/async/nth";

const result = await pipe([1, 2, 3], nth(1));
console.log(result); // 2

pairwise

Returns an iterable that pairs adjacent elements from the input iterable.

import { pairwise } from "@core/iterutil/pairwise";

const iter = pairwise([1, 2, 3, 4, 5]);
console.log(Array.from(iter)); // [[1, 2], [2, 3], [3, 4], [4, 5]]

import { pairwise } from "@core/iterutil/async/pairwise";

const iter = pairwise([1, 2, 3, 4, 5]);
console.log(await Array.fromAsync(iter)); // [[1, 2], [2, 3], [3, 4], [4, 5]]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { pairwise } from "@core/iterutil/pipe/pairwise";

const iter = pipe(
  [1, 2, 3, 4, 5],
  pairwise,
);
console.log(Array.from(iter)); // [[1, 2], [2, 3], [3, 4], [4, 5]]

import { pipe } from "@core/pipe";
import { pairwise } from "@core/iterutil/pipe/async/pairwise";

const iter = pipe(
  [1, 2, 3, 4, 5],
  pairwise,
);
console.log(await Array.fromAsync(iter)); // [[1, 2], [2, 3], [3, 4], [4, 5]]

partition

Partitions an iterable into two arrays based on a selector function.

import { partition } from "@core/iterutil/partition";

const [even, odd] = partition(
  [1, 2, 3, 4, 5],
  (v) => v % 2 === 0,
);
console.log(even); // [2, 4]
console.log(odd); // [1, 3, 5]

import { partition } from "@core/iterutil/async/partition";

const [even, odd] = await partition(
  [1, 2, 3, 4, 5],
  (v) => v % 2 === 0,
);
console.log(even); // [2, 4]
console.log(odd); // [1, 3, 5]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { partition } from "@core/iterutil/pipe/partition";

const [even, odd] = pipe(
  [1, 2, 3, 4, 5],
  partition((v) => v % 2 === 0),
);
console.log(even); // [2, 4]
console.log(odd); // [1, 3, 5]

import { pipe } from "@core/pipe";
import { partition } from "@core/iterutil/pipe/async/partition";

const [even, odd] = await pipe(
  [1, 2, 3, 4, 5],
  partition((v) => v % 2 === 0),
);
console.log(even); // [2, 4]
console.log(odd); // [1, 3, 5]

range

Generates a range of numbers.

import { range } from "@core/iterutil/range";

console.log(Array.from(range(1, 3))); // [1, 2, 3]
console.log(Array.from(range(1, 6, 2))); // [1, 3, 5]

reduce

Reduces an iterable into a single value.

import { reduce } from "@core/iterutil/reduce";

const sum = reduce(
  [1, 2, 3, 4, 5],
  (acc, v) => acc + v,
);
console.log(sum); // 15

const joined = reduce(
  [1, 2, 3, 4, 5],
  (acc, v) => acc + v,
  "",
);
console.log(joined); // 12345

import { reduce } from "@core/iterutil/async/reduce";

const sum = await reduce(
  [1, 2, 3, 4, 5],
  (acc, v) => acc + v,
);
console.log(sum); // 15

const joined = await reduce(
  [1, 2, 3, 4, 5],
  (acc, v) => acc + v,
  "",
);
console.log(joined); // 12345

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { reduce } from "@core/iterutil/pipe/reduce";

const sum = pipe(
  [1, 2, 3, 4, 5],
  reduce((acc, v) => acc + v),
);
console.log(sum); // 15

const joined = pipe(
  [1, 2, 3, 4, 5],
  reduce((acc, v) => acc + v, ""),
);
console.log(joined); // 12345

import { pipe } from "@core/pipe";
import { reduce } from "@core/iterutil/pipe/async/reduce";

const sum = await pipe(
  [1, 2, 3, 4, 5],
  reduce((acc, v) => acc + v),
);
console.log(sum); // 15

const joined = await pipe(
  [1, 2, 3, 4, 5],
  reduce((acc, v) => acc + v, ""),
);
console.log(joined); // 12345

repeat

Returns an finite iterable that repeats through the given iterable.

import { repeat } from "@core/iterutil/repeat";

const iter = repeat([1, 2, 3], 2);
console.log(Array.from(iter)); // [1, 2, 3, 1, 2, 3]

import { repeat } from "@core/iterutil/async/repeat";

const iter = repeat([1, 2, 3], 2);
console.log(await Array.fromAsync(iter)); // [1, 2, 3, 1, 2, 3]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { repeat } from "@core/iterutil/pipe/repeat";

const iter = pipe(
  [1, 2, 3],
  repeat(2),
);
console.log(Array.from(iter)); // [1, 2, 3, 1, 2, 3]

import { pipe } from "@core/pipe";
import { repeat } from "@core/iterutil/pipe/async/repeat";

const iter = pipe(
  [1, 2, 3],
  repeat(2),
);
console.log(await Array.fromAsync(iter)); // [1, 2, 3, 1, 2, 3]

repeatable

Transform an async iterable into a repeatable async iterable. It caches the values of the original iterable so that it can be replayed. Useful for replaying the costly async iterable.

import { repeatable } from "@core/iterutil/async/repeatable";
import { assertEquals } from "@std/assert";

const origin = (async function* () {
  yield 1;
  yield 2;
  yield 3;
})();
const iter = repeatable(origin);
assertEquals(await Array.fromAsync(iter), [1, 2, 3]);
assertEquals(await Array.fromAsync(iter), [1, 2, 3]); // iter can be replayed
assertEquals(await Array.fromAsync(origin), []); // origin is already consumed

some

Returns true if at least one element in the iterable satisfies the provided

import { some } from "@core/iterutil/some";

console.log(some([1, 2, 3], (v) => v % 2 === 0)); // true
console.log(some([1, 3, 5], (v) => v % 2 === 0)); // false

import { some } from "@core/iterutil/async/some";

console.log(await some([1, 2, 3], (v) => v % 2 === 0)); // true
console.log(await some([1, 3, 5], (v) => v % 2 === 0)); // false

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { some } from "@core/iterutil/pipe/some";

console.log(pipe([1, 2, 3], some((v) => v % 2 === 0))); // true
console.log(pipe([1, 3, 5], some((v) => v % 2 === 0))); // false

import { pipe } from "@core/pipe";
import { some } from "@core/iterutil/pipe/async/some";

console.log(await pipe([1, 2, 3], some((v) => v % 2 === 0))); // true
console.log(await pipe([1, 3, 5], some((v) => v % 2 === 0))); // false

take

Takes the first limit items from the iterable.

import { take } from "@core/iterutil/take";

const iter = take([1, 2, 3, 4, 5], 2);
console.log(Array.from(iter)); // [1, 2]

import { take } from "@core/iterutil/async/take";

const iter = take([1, 2, 3, 4, 5], 2);
console.log(await Array.fromAsync(iter)); // [1, 2]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { take } from "@core/iterutil/pipe/take";

const iter = pipe(
  [1, 2, 3, 4, 5],
  take(2),
);
console.log(Array.from(iter)); // [1, 2]

import { pipe } from "@core/pipe";
import { take } from "@core/iterutil/pipe/async/take";

const iter = pipe(
  [1, 2, 3, 4, 5],
  take(2),
);
console.log(await Array.fromAsync(iter)); // [1, 2]

takeWhile

Takes elements from the iterable while the predicate is true.

import { takeWhile } from "@core/iterutil/take-while";

const iter = takeWhile(
  [1, 2, 3, 4, 5],
  (v) => v < 4,
);
console.log(Array.from(iter)); // [1, 2, 3]

import { takeWhile } from "@core/iterutil/async/take-while";

const iter = takeWhile(
  [1, 2, 3, 4, 5],
  (v) => v < 4,
);
console.log(await Array.fromAsync(iter)); // [1, 2, 3]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { takeWhile } from "@core/iterutil/pipe/take-while";

const iter = pipe(
  [1, 2, 3, 4, 5],
  takeWhile((v) => v < 4),
);
console.log(Array.from(iter)); // [1, 2, 3]

import { pipe } from "@core/pipe";
import { takeWhile } from "@core/iterutil/pipe/async/take-while";

const iter = pipe(
  [1, 2, 3, 4, 5],
  takeWhile((v) => v < 4),
);
console.log(await Array.fromAsync(iter)); // [1, 2, 3]

toAsyncIterable

Converts an iterable to an async iterable.

import { toAsyncIterable } from "@core/iterutil/async/to-async-iterable";

const iter = toAsyncIterable([1, 2, 3]);
console.log(await Array.fromAsync(iter)); // [1, 2, 3]

uniq

Returns an iterable that yields the unique elements of the input iterable.

import { uniq } from "@core/iterutil/uniq";

const iter1 = uniq([1, 2, 2, 3, 3, 3]);
console.log(Array.from(iter1)); // [1, 2, 3]

const iter2 = uniq(
  [1, 2, 3, 4, 5, 6, 7, 8, 9],
  (v) => v % 4,
);
console.log(Array.from(iter2)); // [1, 2, 3, 4]

import { uniq } from "@core/iterutil/async/uniq";

const iter1 = uniq([1, 2, 2, 3, 3, 3]);
console.log(await Array.fromAsync(iter1)); // [1, 2, 3]

const iter2 = uniq(
  [1, 2, 3, 4, 5, 6, 7, 8, 9],
  (v) => v % 4,
);
console.log(await Array.fromAsync(iter2)); // [1, 2, 3, 4]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { uniq } from "@core/iterutil/pipe/uniq";

const iter1 = pipe(
  [1, 2, 2, 3, 3, 3],
  uniq(),
);
console.log(Array.from(iter1)); // [1, 2, 3]

const iter2 = pipe(
  [1, 2, 3, 4, 5, 6, 7, 8, 9],
  uniq((v) => v % 4),
);
console.log(Array.from(iter2)); // [1, 2, 3, 4]

import { pipe } from "@core/pipe";
import { uniq } from "@core/iterutil/pipe/async/uniq";

const iter1 = pipe(
  [1, 2, 2, 3, 3, 3],
  uniq(),
);
console.log(await Array.fromAsync(iter1)); // [1, 2, 3]

const iter2 = pipe(
  [1, 2, 3, 4, 5, 6, 7, 8, 9],
  uniq((v) => v % 4),
);
console.log(await Array.fromAsync(iter2)); // [1, 2, 3, 4]

zip

Zips multiple iterables into a single iterable.

import { zip } from "@core/iterutil/zip";

const iter = zip([1, 2, 3], ["a", "b", "c"]);
console.log(Array.from(iter)); // [[1, "a"], [2, "b"], [3, "c"]]

import { zip } from "@core/iterutil/async/zip";

const iter = zip([1, 2, 3], ["a", "b", "c"]);
console.log(await Array.fromAsync(iter)); // [[1, "a"], [2, "b"], [3, "c"]]

Use pipe and pipe/async modules for @core/pipe package like.

import { pipe } from "@core/pipe";
import { zip } from "@core/iterutil/pipe/zip";

const iter = pipe(
  [1, 2, 3],
  zip(["a", "b", "c"]),
);
console.log(Array.from(iter)); // [[1, "a"], [2, "b"], [3, "c"]]

import { pipe } from "@core/pipe";
import { zip } from "@core/iterutil/pipe/async/zip";

const iter = pipe(
  [1, 2, 3],
  zip(["a", "b", "c"]),
);
console.log(await Array.fromAsync(iter)); // [[1, "a"], [2, "b"], [3, "c"]]

License

The code follows MIT license written in LICENSE. Contributors need to agree that any modifications sent in this repository follow the license.

Name	Name	Last commit message	Last commit date
Latest commit lambdalisue Merge pull request #23 from jsr-core/repeatable Oct 14, 2024 18c3d76 · Oct 14, 2024 History 74 Commits
.github	.github	feat(async): add `repeatable` helper function	Oct 14, 2024
async	async	Merge pull request #23 from jsr-core/repeatable	Oct 14, 2024
pipe	pipe	fix(filter): Sort overloads to correct order	Aug 20, 2024
.gitignore	.gitignore	chore: add tests for Node	Aug 19, 2024
.gitmessage	.gitmessage	chore: Initial commit	Aug 7, 2024
.npmrc	.npmrc	chore: add tests for Node	Aug 19, 2024
LICENSE	LICENSE	chore: Initial commit	Aug 7, 2024
README.md	README.md	feat(async): add `repeatable` helper function	Oct 14, 2024
README_test.ts	README_test.ts	test: use `@cross/test` instead	Aug 19, 2024
chain.ts	chain.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
chain_test.ts	chain_test.ts	test: use `@cross/test` instead	Aug 19, 2024
chunked.ts	chunked.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
chunked_test.ts	chunked_test.ts	test: use `@cross/test` instead	Aug 19, 2024
compact.ts	compact.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
compact_test.ts	compact_test.ts	test: use `@cross/test` instead	Aug 19, 2024
compress.ts	compress.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
compress_test.ts	compress_test.ts	test: use `@cross/test` instead	Aug 19, 2024
count.ts	count.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
count_test.ts	count_test.ts	test: use `@cross/test` instead	Aug 19, 2024
cycle.ts	cycle.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
cycle_test.ts	cycle_test.ts	test: use `@cross/test` instead	Aug 19, 2024
deno.jsonc	deno.jsonc	feat(async): add `repeatable` helper function	Oct 14, 2024
drop.ts	drop.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
drop_test.ts	drop_test.ts	test: use `@cross/test` instead	Aug 19, 2024
drop_while.ts	drop_while.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
drop_while_test.ts	drop_while_test.ts	test: use `@cross/test` instead	Aug 19, 2024
enumerate.ts	enumerate.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
enumerate_test.ts	enumerate_test.ts	test: use `@cross/test` instead	Aug 19, 2024
every.ts	every.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
every_test.ts	every_test.ts	test: use `@cross/test` instead	Aug 19, 2024
filter.ts	filter.ts	fix(filter): Sort overloads to correct order	Aug 20, 2024
filter_test.ts	filter_test.ts	test: Add tests for filter with type predicate	Aug 20, 2024
find.ts	find.ts	docs: add links to `nth` module	Aug 13, 2024
find_test.ts	find_test.ts	test: use `@cross/test` instead	Aug 19, 2024
first.ts	first.ts	docs: add links to `nth` module	Aug 13, 2024
first_test.ts	first_test.ts	test: use `@cross/test` instead	Aug 19, 2024
flat_map.ts	flat_map.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
flat_map_test.ts	flat_map_test.ts	test: use `@cross/test` instead	Aug 19, 2024
flatten.ts	flatten.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
flatten_test.ts	flatten_test.ts	test: use `@cross/test` instead	Aug 19, 2024
for_each.ts	for_each.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
for_each_test.ts	for_each_test.ts	test: use `@cross/test` instead	Aug 19, 2024
iter.ts	iter.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
iter_test.ts	iter_test.ts	test: use `@cross/test` instead	Aug 19, 2024
last.ts	last.ts	docs: add links to `nth` module	Aug 13, 2024
last_test.ts	last_test.ts	test: use `@cross/test` instead	Aug 19, 2024
map.ts	map.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
map_test.ts	map_test.ts	test: use `@cross/test` instead	Aug 19, 2024
mod.ts	mod.ts	feat(repeat): add `repeat` module	Aug 17, 2024
mod_test.ts	mod_test.ts	test: use `@cross/test` instead	Aug 19, 2024
nth.ts	nth.ts	feat(nth): add `nth` operator	Aug 13, 2024
nth_test.ts	nth_test.ts	test: use `@cross/test` instead	Aug 19, 2024
package-lock.json	package-lock.json	feat(async): add `repeatable` helper function	Oct 14, 2024
package.json	package.json	feat(async): add `repeatable` helper function	Oct 14, 2024
pairwise.ts	pairwise.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
pairwise_test.ts	pairwise_test.ts	test: use `@cross/test` instead	Aug 19, 2024
partition.ts	partition.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
partition_test.ts	partition_test.ts	test: use `@cross/test` instead	Aug 19, 2024
range.ts	range.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
range_test.ts	range_test.ts	test: use `@cross/test` instead	Aug 19, 2024
reduce.ts	reduce.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
reduce_test.ts	reduce_test.ts	test: use `@cross/test` instead	Aug 19, 2024
repeat.ts	repeat.ts	feat(repeat): add `repeat` module	Aug 17, 2024
repeat_test.ts	repeat_test.ts	test: use `@cross/test` instead	Aug 19, 2024
some.ts	some.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
some_test.ts	some_test.ts	test: use `@cross/test` instead	Aug 19, 2024
take.ts	take.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
take_test.ts	take_test.ts	test: use `@cross/test` instead	Aug 19, 2024
take_while.ts	take_while.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
take_while_test.ts	take_while_test.ts	test: use `@cross/test` instead	Aug 19, 2024
uniq.ts	uniq.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
uniq_test.ts	uniq_test.ts	test: use `@cross/test` instead	Aug 19, 2024
zip.ts	zip.ts	docs: fix `@linkcode` URLs	Aug 12, 2024
zip_test.ts	zip_test.ts	test: use `@cross/test` instead	Aug 19, 2024

License

jsr-core/iterutil

Folders and files

Latest commit

History

Repository files navigation

iterutil

Usage

chain

chunked

compact

compress

count

cycle

drop

dropWhile

enumerate

every

filter

find

first

flatMap

flatten

forEach

iter

last

map

nth

pairwise

partition

range

reduce

repeat

repeatable

some

take

takeWhile

toAsyncIterable

uniq

zip

License

About

Topics

Resources

License

Stars

Watchers

Forks

Releases 19

Sponsor this project

Packages 0

Contributors 2

Languages

Packages