Interface AnySequence<T>

Iterates through this sequence.

True if all elements pass the predicate

from([2, 1, 5]).all(x => x >= 1)
// => true
from([2, 1, 5]).all(x => x >= 2)
// => false
Copy

True if any elements pass the predicate

from([2, 1, 5]).any(x => x >= 4)
// => true
from([2, 1, 5]).any(x => x <= 0)
// => false
Copy

True if the sequence is not empty

from([2, 1, 5]).any()
// => true
from([]).any()
// => false
Copy

Append another iterable to the end

from([1, 2]).append([3, 4])
// => [1, 2, 3, 4]
Copy

Projects each element to a number and averages the sequence. If empty, throws.

from(['2', '1', '6']).average(x => parseFloat(x))
// => 3
Copy

True if the element is in the sequence. Checked with ===.

from([2, 1, 5]).contains(1)
// => true
from([{ a: '1' }]).contains({ a: '1' })
// => false (strict equality. use any with a custom search instead.)
Copy

Counts the number of elements in the sequence

from([2, 1, 5]).count()
// => 3
from([]).count()
// => 0
Copy

Get all distinct elements of the sequence using strict equality. First value wins.

from([1, 2, 2, 3]).distinct()
// => [1, 2, 3]
Copy

Get all distinct elements of the sequence, mapping each element to a key that will be used for strict equality. First value wins.

from([10, 15, 20, 25, 30]).distinct(x => Math.trunc(x / 10))
// => [10, 20, 30]
Copy

Get the first element in the sequence. Will throw if empty! Use firstOrDefault if no throw is wanted.

from([2, 1, 5]).first()
// => 2
from([]).first()
// => throws
Copy

Get the first element in the sequence that matches a condition. Will throw if empty! Use firstOrDefault if no throw is wanted.

from([2, 1, 5]).first(x => x >= 4)
// => 5
from([2, 1, 5]).first(x => x < 0)
// => throws
Copy

Get the first element in the sequence. If empty, returns undefined.

from([2, 1, 5]).firstOrDefault()
// => 2
from([]).firstOrDefault()
// => undefined
Copy

Get the first element in the sequence that matches a condition. If empty or no matches, returns undefined.

from([2, 1, 5]).firstOrDefault(x => x >= 4)
// => 5
from([2, 1, 5]).firstOrDefault(x => x < 0)
// => undefined
Copy

Project each element to an iterable/array, then flatten the result

from(['1 2', '3 4']).flat(x => x.split(' '))
// => ['1', '2', '3', '4']
Copy

Project each element to get a key, and group all items by that key.

from([10, 15, 20]).groupBy(x => Math.trunc(x / 10))
                   .map(g => ({ key: g.key, values: Array.from(g) }))
// => [{ key: 1, values: [10, 15] },
//     { key: 2, values: [20] }]
Copy

Project each element to get a key, and group all items, each projected onto another type.

from([10, 15, 20]).groupBy(x => Math.trunc(x / 10), x => x.toString())
                   .map(g => ({ key: g.key, values: Array.from(g) }))
// => [{ key: 1, values: ['10', '15'] },
//     { key: 2, values: ['20'] }]
Copy

Correlates the elements of two sequences based on matching keys, and groups everything in the other table.

const appleTypes = [
    { name: 'green apple', id: 5 },
    { name: 'red apple', id: 2 },
    { name: 'yellow apple', id: 10 }
];
const apples = [
    { name: 'golden delicious', type: 10 },
    { name: 'granny smith', type: 5 },
    { name: 'pink lady', type: 2 },
    { name: 'fuji', type: 2 },
    { name: 'unknown', type: 999 }
];

from(appleTypes).groupJoin(
    apples,
    type => type.id,
    apple => apple.type,
    (type, apples) => `${type.name}: ${apples.map(a => a.name).joinString(', ')}`
);
// => [ 'green apple: granny smith',
//      'red apple: pink lady, fuji',
//      'yellow apple: golden delicious' ]
Copy

Correlates the elements of two sequences based on matching keys. An inner join.

const appleTypes = [
    { name: 'green apple', id: 5 },
    { name: 'red apple', id: 2 },
    { name: 'yellow apple', id: 10 }
];
const apples = [
    { name: 'golden delicious', type: 10 },
    { name: 'granny smith', type: 5 },
    { name: 'pink lady', type: 2 },
    { name: 'fuji', type: 2 },
    { name: 'unknown', type: 999 }
];

from(apples).join(
    appleTypes,
    apple => apple.type,
    type => type.id,
    (apple, type) => `${apple.name}: ${type.name}`
)
// => [ 'golden delicious: yellow apple',
//      'granny smith: green apple',
//      'pink lady: red apple',
//      'fuji: red apple' ]
Copy

Get the last element in the sequence. Will throw if empty! Use lastOrDefault if no throw is wanted.

from([2, 1, 5]).last()
// => 5
from([]).last()
// => throws
Copy

Get the last element in the sequence that matches a condition. Will throw if empty! Use lastOrDefault if no throw is wanted.

from([2, 1, 5]).last(x => x < 4)
// => 1
from([]).last(x => x < 0)
// => throws
Copy

Get the last element in the sequence. If empty, returns undefined.

from([2, 1, 5]).lastOrDefault()
// => 5
from([]).lastOrDefault()
// => undefined
Copy

Get the last element in the sequence that matches a condition. If empty or no matches, returns undefined.

from([2, 1, 5]).lastOrDefault(x => x < 4)
// => 1
from([2, 1, 5]).lastOrDefault(x => x < 0)
// => undefined
Copy

Map each element to another

from([2, 1, 5]).map(x => x + 1)
// => [3, 2, 6]
Copy

Projects each element to a number and finds the max of the sequence. If empty, throws.

from(['2', '1', '5']).max(x => parseFloat(x))
// => 5
Copy

Finds the maximum element in the sequence according to a selector. Equivalent (but faster) to orderByDescending(f).first().

from([{ key: 'A', value: 2 }, { key: 'B', value: 1 }, { key: 'C', value: 10 }]).maxBy(x => x.value)
// => { key: 'C', value: 10 }
Copy

Projects each element to a number and finds the min of the sequence. If empty, throws.

from(['2', '1', '5']).min(x => parseFloat(x))
// => 1
Copy

Finds the minimum element in the sequence according to a selector. Equivalent (but faster) to orderBy(f).first().

from([{ key: 'A', value: 2 }, { key: 'B', value: 1 }, { key: 'C', value: 10 }]).minBy(x => x.value)
// => { key: 'B', value: 1 }
Copy

True if no elements pass the predicate

from([2, 1, 5]).none(x => x === 0)
// => true
from([2, 1, 5]).none(x => x === 1)
// => false
Copy

Sort the array in ascending order of the selector

from([4, 1, 10]).orderBy(x => x)
// => [1, 4, 10]
Copy

Sort the array in ascending order of the selector, with a custom comparer

// Sort alphabetically, ignoring case.
from(['A xylophone', 'a frog', 'a zoo']).orderBy(x => x, new Intl.Collator('en', { sensitivity: 'base' }).compare)
// => ['a frog', 'A xylophone', 'a zoo']
Copy

Sort the array in descending order of the selector

from([4, 1, 10]).orderByDescending(x => x)
// => [10, 4, 1]
Copy

Sort the array in descending order of the selector, with a custom comparer

// Sort reverse alphabetically, ignoring case.
from(['A xylophone', 'a frog', 'a zoo']).orderByDescending(x => x, new Intl.Collator('en', { sensitivity: 'base' }).compare)
// => ['a zoo', 'A xylophone', 'a frog']
Copy

Prepend another iterable to the start

from([1, 2]).prepend([3, 4])
// => [3, 4, 1, 2]
Copy

Reverses the sequence.

from([2, 1, 5]).reverse()
// => [5, 1, 2]
Copy

Get the only element in the sequence. Will throw if empty or more than one element! Use singleOrDefault if no throw is wanted.

from([2]).single()
// => 2
from([2, 1, 5]).single()
// => throws
from([]).single()
// => throws
Copy

Get the only element in the sequence that matches a condition. Will throw if empty or more than one element! Use singleOrDefault if no throw is wanted.

from([2, 1, 5]).single(x => x >= 4)
// => 5
from([2, 1, 5]).single(x => x >= 1)
// => throws
Copy

Get the only element in the sequence. Returns undefined if empty or more than one element.

from([2]).singleOrDefault()
// => 2
from([2, 1, 5]).singleOrDefault()
// => undefined
Copy

Get the only element in the sequence that matches a condition. Returns undefined if empty or more than one element.

from([2, 1, 5]).singleOrDefault(x => x >= 4)
// => 5
from([2, 1, 5]).singleOrDefault(x => x >= 1)
// => undefined
Copy

Skip a number of elements before letting the rest through

from([2, 3, 1, 5]).skip(2)
// => [1, 5]
Copy

Skip elements while the predicate is true, then take the rest

from([2, 3, 1, 5]).skipWhile(x => x >= 2)
// => [1, 5]
Copy

Projects each element to a number and sums the sequence. If empty, returns 0.

from(['2', '1', '5']).sum(x => parseFloat(x))
// => 8
Copy

Take a maximum amount of elements

from([2, 1, 5]).take(2)
// => [2, 1]
Copy

Take elements while the predicate is true, then skips the rest

from([2, 3, 1, 5]).takeWhile(x => x >= 2)
// => [2, 3]
Copy

Converts this sequence to an array.
Note: If you are using this Sequence in a for..of loop, you do not need this -- you can use the sequence directly.

from([2, 1, 5]).toArray()
// => [2, 1, 5]
Copy

Converts this sequence to a Map. First key wins.

from([{ k: 'a', v: 123 }, { k: 'b', v: 456 }]).toMap(x => x.k, x => x.v)
// => new Map([['a', 123], ['b', 456]])
Copy

Converts this sequence into an object. First key wins.

from([{ k: 'a', v: 123 }, { k: 'b', v: 456 }]).toObject(x => x.k, x => x.v)
// => { a: 123, b: 456 }
Copy

Convert this sequence into a Set

from([2, 1, 1, 5]).toSet()
// => new Set([2, 1, 5])
Copy

Map each element and convert the resulting sequence into a set

from([2, 1, 1, 5]).toSet(x => x + 1)
// => new Set([3, 2, 6])
Copy

Filters with a TS type assertion ('is'), narrowing to that type

function isNumber(x: number | string): x is number {
    return typeof x === 'number';
}
from(['string', 12, 'str']).where(isNumber)
// => [12]
// sequence is now Sequence<number>
Copy

Filters with and narrows to a type

from(['string', 12, 'str']).where<number>(x => typeof x === 'number')
// => [12]
// sequence is now Sequence<number>
Copy

note! must use generic type! otherwise this overload is not used, and the type is not narrowed.

Filters with a predicate that must return a truthy value

from([5, 10, 20]).where(x => x >= 8)
// => [10, 20]
Copy