Instance Methods

It's

`map`

, the most important method in programming! Exactly the same as ES6 `map`

, but lazy.Usage

Type Definition

const sequence: Seq<string> = Seq.infinite().map(num => num.toString());

type map = <U>(fn: (value: T, index: number) => U) => Seq<U>;

`window`

takes a sequence and groups it into "windows" of a certain length. This works well with infinite sequences where you want to process some number of values at a time.Usage

Type Definition

// Grab numbers in groups of 10.

const sequence: Seq<number[]> = Seq.infinite().window(10);

By default, only triggers chained responses when the window fills, guaranteeing the window is the exact size expect. Set

`allowPartialWindow`

to `false`

to allow the trailing edge of a sequence to not be divisible by the window size.// Gives: [0, 1, 2] -> [3, 4, 5] -> [6, 7, 8] -> [9, 10]

const sequence: Seq<number> = Seq.range(0, 10).window(3);

type window = (size: number, allowPartialWindow = true) => Seq<T[]>;

Works like

`window`

, makes the window size 2. Groups a sequence as alternating pairs. Useful for processing data which alternates Map keys and values.Usage

Type Definition

const sequence: Seq<[string, number]> = Seq.fromArray(["a", 1, "b", 2]);

type pairwise = () => Seq<[T, T]>;

Ask whether a sequence is empty.

Usage

Type Definition

const anythingInThere: boolean = Seq.empty().isEmpty();

type isEmpty = () => boolean;

`tap`

lets you run side-effect generating functions on a sequence. Allows you to "tap in to" a data flow. Very useful for logging and debugging what values are flowing through the chain at a given location.Usage

Type Definition

const sequence: Seq<number> = Seq.infinite().tap(num => console.log(num));

type tap = (fn: (value: T, index: number) => void) => Seq<T>;

`log`

provides the most common use-case for `tap. Add this to a sequence chain to log each value that passes through it.Usage

Type Definition

const sequence: Seq<number> = Seq.infinite().log();

type log = () => Seq<T>;

Given a sequence where each item in an array of items, flatten all those arrays into a single flat sequence of values.

Usage

Type Definition

type Person = { name: string; friends: Person[] };

â€‹

const sequence: Seq<Friend> = Seq.fromArray([person1, person2])

.map(person => person.friends)

.flat();

type flat = <U>(this: Seq<U[]>) => Seq<U>;

`flatMap`

is used when mapping a list to each items related items. For example, if you wanted to map from a list of people to each persons list of friends. Despite each mapping function returning an array, the final output is a flatten array of all the results concattenated.Similar to

`[].map().flat()`

, but in `leisure`

the item mappings won't execute until enough of the resulting values have been realized to trigger each map.Usage

Type Definition

type Person = { name: string; friends: Person[] };

â€‹

const sequence: Seq<Friend> = Seq.fromArray([person1, person2]).flatMap(

person => person.friends

);

type flatMap = <U>(fn: (value: T, index: number) => U[]) => Seq<U>;

Runs a predicate function on each item in a sequence to produce a new sequence where only the values which responded with

`true`

remain.Usage

Type Definition

// Create a sequence of only even numbers.

const sequence: Seq<number> = Seq.infinite().filter(num => num % 2 === 0);

type filter = (fn: (value: T, index: number) => unknown) => Seq<T>;

Combines the current sequence with 1 or more additional sequences.

Usage

Type Definition

const sequence: Seq<number> = Seq.fromArray([0, 1]).concat(

Seq.fromArray([2, 3]),

Seq.fromArray([4, 5])

);

type concat = (...tail: Array<Seq<T>>) => Seq<T>;

Takes 1 or more sequences and creates a new sequence built by pulling the next value from each of the sequences in order.

Usage

Type Definition

// Builds: a -> 1 -> b -> 2 -> c -> 3

const sequence: Seq<string | number> = Seq.fromArray([

"a",

"b",

"c"

]).interleave(Seq.range(1, 3));

type interleave = (...tail: Array<Seq<T>>) => Seq<T>;

Given a sequence, place a value between each value of the original sequence. Useful for adding punctuation between strings.

Usage

Type Definition

// Builds: Apples -> , -> Oranges -> , -> Bananas

const sequence: Seq<string> = Seq.fromArray([

"Apples",

"Oranges",

"Bananas"

]).interpose(", ");

â€‹

console.log(sequence.toArray().join(""));

type interpose = (separator: T) => Seq<T>;

Given a sequence, only forwards the values which have no already been seen. Very similar to lodash's

`uniq`

method.Usage

Type Definition

// Builds: 1 -> 2 -> 3 -> 4

const sequence: Seq<number> = Seq.fromArray([1, 2, 3, 2, 1, 4]).distinct();

type distinct = () => Seq<T>;

Same as

`distinct`

, but allows a function to describe on what value the sequence should be unique.Usage

Type Definition

// Builds: { firstName: "A", lastName: "Z" } ->

// { firstName: "B", lastName: "Y" } ->

// { firstName: "C", lastName: "W" }

type Person = { firstName: string; lastName: string };

const sequence: Seq<Person> = Seq.fromArray([

{ firstName: "A", lastName: "Z" },

{ firstName: "B", lastName: "Y" },

{ firstName: "A", lastName: "X" },

{ firstName: "C", lastName: "W" }

]).distinctBy(person => person.firstName);

type distinctBy = <U>(fn: (value: T) => U) => Seq<T>;

Given a sequence, splits the values into two separate sequences. One represents the values where the partition function is

`true`

and the other for `false`

.Usage

Type Definition

const [isEven, isOdd] = Seq.infinite().partitionBy(num => num % 2 === 0);

type partition = (fn: (value: T, index: number) => unknown) => [Seq<T>, Seq<T>];

Lazily checks if the sequence includes a value.

Usage

Type Definition

const doesItInclude = Seq.infinite().includes(10);

type includes = (value: T) => boolean;

Lazily searches for a value that matches the predicate.

Usage

Type Definition

// Returns 11

const gtTen = Seq.infinite().find(num => num > 10);

type find = (fn: (value: T, index: number) => unknown) => T | undefined;

Exactly the same as

`Array.prototype.reduce`

. See more here. This causes a full realization of the data. Not lazy.Usage

Type Definition

// Returns 0 + 1 + 2 + 3 + 4 = 10

const sum = Seq.infinite()

.take(5)

.reduce((sum, num) => sum + num);

type reduce = <A>(fn: (sum: A, value: T, index: number) => A, initial: A) => A;

This method is helpful for chaining. Shocking, I know. Let's you "map" the entire sequence in a chain, rather than per-each-item. Allows adding arbitrary sequence helpers and methods to chain, even if they are written in user-land and not on the

`Seq`

prototype.Usage

Type Definition

// Same as `Seq.interpose(Seq.infinite(), Seq.infinite())`

const sequence = Seq.infinite().chain(seq => seq.interpose(Seq.infinite()));

type chain = <U>(fn: (value: Seq<T>) => U) => U;

Usage

Type Definition

// Find the first even random number.

const areAnyEven = Seq.random()

.map(num => Math.round(num * 1000))

.some(num => num % 2 === 0);

type some = (fn: (value: T, index: number) => unknown) => boolean;

Usage

Type Definition

// Fails fast if there are negative numbers

const areAllPositive = Seq.random()

.map(num => Math.round(num * 1000) - 500)

.every(num => num > 0);

type every = (fn: (value: T, index: number) => unknown) => boolean;

Given a sequence of unknown length, create a sub sequence of just the first X number of items.

Usage

Type Definition

// Grabs 0 -> 1 -> 2 -> 3 -> 4

const firstFive = Seq.infinite().take(5);

type take = (num: number) => Seq<T>;

Given a sequence of unknown length, create a sub sequence of as many items in a row that satisfy the predicate.

Usage

Type Definition

// Gives 0 -> 1 -> 2 -> 3 -> 4

const lessThanFive = Seq.infinite().takeWhile(num => num < 5);

type takeWhile = (fn: (value: T, index: number) => unknown) => Seq<T>;

Given a sequence of unknown length, skips the first X number of items.

Usage

Type Definition

// Gives 5 -> 6 -> 7 -> 8 -> 9

const secondFive = Seq.infinite()

.skip(5)

.take(5);

type skip = (num: number) => Seq<T>;

Given a sequence of unknown length, skip as many items in a row that satisfy the predicate.

Usage

Type Definition

// Gives 5 -> 6 -> 7 -> 8 -> 9

const greaterThanFive = Seq.infinite()

.skipWhile(num => num < 5)

.take(5);

type skipWhile = (fn: (value: T, index: number) => unknown) => Seq<T>;

Returns the

`nth`

item. Items are 1-indexed.Usage

Type Definition

const thirdItem = Seq.infinite().nth(3);

type nth = (i: number) => T | undefined;

Returns the

`index`

item. Items are 0-indexed.Usage

Type Definition

const fourthItem = Seq.infinite().index(3);

type nth = (i: number) => T | undefined;

Gets the first value in the sequence.

Usage

Type Definition

const fifth = Seq.infinite()

.skip(4)

.first();

type first = () => T | undefined;

Lazily combines a second sequence with this current one to produce a tuple with the current step in each of the two positions. Useful for zipping a sequence of keys with a sequence of values, before converting to a Map of key to value.

Usage

Type Definition

const seq2 = Seq.range(0, 3);

â€‹

// Gives: ["zero", 0] -> ["one", 1] -> ["two", 2] -> ["three", 3]

const sequence: Seq<[string, number]> = Seq.fromArray([

"zero",

"one",

"two",

"three"

]).zip(seq2);

type zip<T2> = (seq2: Seq<T2>) => Seq<[T | undefined, T2 | undefined]>;

Takes a second sequence and lazily combines it to produce an arbitrary value by mapping the current value of the two positions through a user-supplied function. Useful for table (row/col) math.

Usage

Type Definition

const seq2 = Seq.repeat(2);

â€‹

// Gives: 0 -> 2 -> 4 -> 6

const sequence: Seq<number> = Seq.range(0, 3).zipWith(

([num, multiplier]) => num * multiplier,

seq2

);

type zip2With = <T2, T3, T4>(

fn: (

[result1, result2, result3]:

| [T, T2, T3]

| [T, undefined, undefined]

| [T, T2, undefined]

| [T, undefined, T3]

| [undefined, T2, undefined]

| [undefined, T2, T3]

| [undefined, undefined, T3],

index: number

) => T4,

seq2: Seq<T2>,

seq3: Seq<T3>

) => Seq<T4>;

Takes two sequences and lazily combines them with this one to produce a 3-tuple with the current step in each of the three positions.

Usage

Type Definition

const seq2 = Seq.range(0, 3);

const seq3 = Seq.range(3, 0);

â€‹

// Gives: ["zero", 0, 3] -> ["one", 1, 2] -> ["two", 2, 1] -> ["three", 3, 0]

const sequence: Seq<[string, number]> = Seq.fromArray([

"zero",

"one",

"two",

"three"

]).zip2(seq2, seq3);

type zip2 = <T2, T3>(

seq2: Seq<T2>,

seq3: Seq<T3>

) => Seq<[T | undefined, T2 | undefined, T3 | undefined]>;

Takes two sequences and lazily combine them with this sequence to produce an arbitrary value by mapping the current value of the three positions through a user-supplied function.

Usage

Type Definition

const seq2 = Seq.repeat(2);

const seq3 = Seq.repeat(1);

â€‹

// Gives: 0 -> 2 -> 4 -> 6

const sequence: Seq<number> = Seq.range(0, 3).zip2With(

([num, multiplier, divisor]) => (num * multiplier) / divisor,

seq2,

seq3

);

type zip2With = <T2, T3, T4>(

fn: (

[result1, result2, result3]:

| [T, T2, T3]

| [T, undefined, undefined]

| [T, T2, undefined]

| [T, undefined, T3]

| [undefined, T2, undefined]

| [undefined, T2, T3]

| [undefined, undefined, T3],

index: number

) => T4,

seq2: Seq<T2>,

seq3: Seq<T3>

) => Seq<T4>;

Converts the sequence to a real JavaScript array. Realizes the entire sequence.

Usage

Type Definition

const lessThanTen = Seq.infinite()

.take(10)

.toArray();

type toArray = () => T[];

Usage

Type Definition

â€‹

type forEach = (fn: (value: T, index: number) => void) => void;

Given a sequence of numbers, adds them all together. This realizes the entire sequence.

Usage

Type Definition

// Returns 0 + 1 + 2 + 3 + 4 = 10

const sum = Seq.infinite()

.take(5)

.sum();

type sum = (this: Seq<number>) => number;

Given a sequence of arbitrary data, adds together the result of the mapping function. This realizes the entire sequence.

Usage

// Returns 0 + 1 + 2 + 3 + 4 = 10

const sum = Seq.fromArray([

{ balance: 0 },

{ balance: 1 },

{ balance: 2 },

{ balance: 3 },

{ balance: 4 }

]).sumBy(user => user.balance);

{% endtab %}

â€‹

{% tab title="Type Definition" %}

â€‹

```typescript

type sumBy = (fn: (value: T) => number) => number;

Given a sequence of numbers, averages them all together. Tise realizes the entire sequence.

Usage

Type Definition

// Returns (0 + 1 + 2 + 3 + 4) / 5 = 2

const sum = Seq.infinite()

.take(5)

.average();

type average = (this: Seq<number>) => number;

Given a sequence of arbitrary data, averages together the result of the mapping function. This realizes the entire sequence.

Usage

Type Definition

// Returns (0 + 1 + 2 + 3 + 4) / 5 = 2

const sum = Seq.fromArray([

{ balance: 0 },

{ balance: 1 },

{ balance: 2 },

{ balance: 3 },

{ balance: 4 }

]).averageBy(user => user.balance);

type averageBy = (fn: (value: T) => number) => number;

Given a non-infinite sequence, return a

`Map`

which counts the occurances of each unique value. This realizes the entire sequence.Usage

Type Definition

// Returns a Map of numbers from 0->100 and how many times they randomly occured in this set of 500.

const freq = Seq.random()

.map(num => Math.round(num * 100))

.take(500)

.frequencies();

type frequencies = () => Map<T, number>;

Group a sequence by the return of a mapping function. This realizes the entire sequence.

Usage

Type Definition

// Random generates 1000 years between 0-2000 and

// groups them by decade.

const groupedByDecade = Seq.random()

.map(num => Math.round(num * 2000))

.take(100)

.groupBy(year => Math.round(year / 10));

type groupBy = <U>(fn: (item: T) => U) => Map<U, T[]>;

Last modified 2yr ago

Copy link

On this page

map

window

pairwise

isEmpty

tap

log

flat

flatMap

filter

concat

interleave

interpose

distinct

distinctBy

partitionBy

includes

find

reduce

chain

some

every

take

takeWhile

skip

skipWhile

nth

index

first

zip

zipWith

zip2

zip2With

toArray

forEach

sum

sumBy

average

averageBy

frequencies

groupBy