Documentation

import { pipe, range, filter, take, toarray } from "powerseq"; // npm install powerseq

// calling one operator
for(var item of filter([1,2,3,4,5], x => x % 2 === 0)){
    console.log(item);
}

// chaining many operators 
const items = pipe(range(1, Number.MAX_VALUE), filter(x => x % 2 === 0), take(5), toarray());
console.log(items);

• thanks to function overloading the same operator can be called alone or as a part of pipe(..., operator(), ...) expression
• for some operators a special counterparts ending with p are provided (concatp,defaultifemptyp,includesp,sequenceequalp,zipp,interleavep), those functions must be used inside pipe(..., opp()), so we call concat([1,2,3], [4,5,6]) or pipe([1,2,3], concatp([4,5,6]) )
• mapping powerseq operators to LINQ, RxJS, JS Array, lodash, F#, Clojure, Kotlin, Java
• read Programming with sequences series to better understand iterators and generators in JS, it also presents how to implement powerseq operators from scratch

functions

• creators: defer, empty, entries, generate, range, repeatvalue, throww
• operators: average, buffer, cast, combinations, concat, count, countby, defaultifempty, distinct, distinctby, distinctuntilchanged, doo, elementat, every, except, exceptby, expand, filter, filtermap, find, findindex, flat, flatmap, foreach, groupby, groupbytoobject, groupbytotransformedobject, groupjoin, ignoreelements, includes, interleave, interpose, intersect, intersectby, isempty, join, last, map, max, maxby, memoize, min, minby, oftype, orderby, orderbydescending, pairwise, partitionby, reduce, repeat, reverse, scan, sequenceequal, share, single, skip, skiplast, skipwhile, some, sum, take, takelast, takewhile, thenby, thenbydescending, toarray, tomap, toobject, union, unionby, zip

creators

defer

• defer(() => [1, 2, 3] /* executed on demand */) -> seq [1, 2, 3]

empty

• empty() -> seq []

entries

• entries({ 'a': 1, b: 2 }) -> seq [['a', 1], ['b', 2]]
• entries([1, 2, 3]) -> seq [[0, 1], [1, 2], [2, 3]]

generate

• generate(0, x => x < 4, x => x + 1, x => 'a'.repeat(x)) -> seq ['', 'a', 'aa', 'aaa']

range

• range(10, 4) -> seq [10, 11, 12, 13]

repeatvalue

• repeatvalue(true, 4) -> seq [true, true, true, true]
• take(repeatvalue(true), 2) -> seq [true, true]

throww

• throww(new Error('exception ...')) -> error: exception ...

operators

average

• average([1, 2, 3, 4]) -> 2.5
• average(['a', 'aa', 'aaa'], s => s.length) -> 2
• average(['a', 'aa', ''], (s, index) => s.length + index) -> 2

buffer

• buffer([1, 2, 3, 4, 5, 6, 7], 2) -> seq [[1, 2], [3, 4], [5, 6], [7]]
• buffer([1, 2, 3, 4, 5, 6, 7], 2, /*skip*/ 4) -> seq [[1, 2], [5, 6]]

cast

• cast([new Number(1), new Number(2), 's', false], Number) -> error: An element in the sequence cannot be cast to type 'Number'.

combinations

• combinations([1, 2, 3, 4], 2) -> seq [[1, 2], [1, 3], [2, 3], [1, 4], [2, 4], [3, 4]]
• combinations([1, 2, 3, 4], 3) -> seq [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]

concat

• concat([1, 2], [3, 5], [6]) -> seq [1, 2, 3, 5, 6]

count

• count([2, 2, 2]) -> 3
• count([2, 4, 6], x => x > 2) -> 2
• count([2, 4, 6], (x, index) => index >= 2) -> 1

countby

• countby(['a', 'a', 'cc', 'ddd', 'xx'], x => x.length) -> Map {1 => 2, 2 => 2, 3 => 1}
• pipe(['a', 'a', 'cc', 'ddd', 'xx'], countby(x => x), toobject()) -> { a:2, cc:1, ddd:1, xx:1 }

defaultifempty

• defaultifempty([1, 2, 3]) -> seq [1, 2, 3]
• defaultifempty([]) -> seq [undefined]
• defaultifempty([], 10) -> seq [10]

distinct

• distinct([1, 2, 1, 3, 2]) -> seq [1, 2, 3]
• distinct(['a', 'aa', 'ab', 'abc'], x => x.length) -> seq [1, 2, 3]

distinctby

• distinctby(['a', 'aa', 'ab', 'abc'], x => x.length) -> seq ['a', 'aa', 'abc']

distinctuntilchanged

• distinctuntilchanged([1, 1, 2, 2, 2, 1, 3, 3]) -> seq [1, 2, 1, 3]

doo

• doo([1, 2, 3,], x => { }) -> seq [1, 2, 3]

elementat

• elementat([1, 2, 12, 15], 2) -> 12
• elementat([1, 2, 12, 15], 20) -> undefined
• elementat([1, 2, 12, 15], 20, 100) -> 100

every

• every([1, 2, 12, 15], x => x > 0) -> true
• every([1, 2, 12, 15], x => x < 10) -> false
• every([0, 1, 3, 3], (x, index) => x === index) -> false

except

• except([1, 2, 2, 3, 4], [2, 3]) -> seq [1, 4]

exceptby

• exceptby(['a', 'b', 'ba', 'xde'], ['poc'], x => x.length) -> seq ['a', 'ba']

expand

• expand([1], x => x > 8 ? [] : [10, x * 2]) -> seq [1, 10, 2, 10, 4, 10, 8, 10, 16]

filter

• filter([1, 2, 2, 3, 4], x => x > 2) -> seq [3, 4]
• filter([1, 2, 2, 3, 4], (x, index) => x - 1 === index) -> seq [1, 2]

filtermap

• filtermap([1, 2, 3, 4], x => x % 2 === 0 ? (x * 10).toString() : null) -> seq ['20', '40']
• filtermap([1, 2, 3, 4], (x, i) => i % 2 === 0 ? (x * 10).toString() : null)
  • seq ['10', '30']

find

• find([1, 2, 2, 3, 4]) -> 1
• find([1, 2, 2, 3, 4], x => x > 2) -> 3
• find([1, 2, 2, 3, 4], x => x > 4) -> undefined
• find([1, 2, 2, 3, 4], x => x > 4, 100) -> 100
• find([1, 2, 2, 3, 4], (x, index) => x > 1 && index > 2) -> 3

findindex

• findindex([1, 2, 2, 3, 4], x => x > 1) -> 1
• findindex([1, 2, 2, 3, 4], (x, index) => index > 1) -> 2
• findindex([1, 2, 2, 3, 4], (x, index) => x > 1 && index > 2) -> 3

flat

• flat([1, [2, 3], [[4, 5], 6], []]) -> seq [1, 2, 3, [4, 5], 6]
• flat([1, [2, 3], [[4, 5], 6], []], 1) -> seq [1, 2, 3, [4, 5], 6]
• flat([1, [2, 3], [[4, 5], 6], []], 2) -> seq [1, 2, 3, 4, 5, 6]
• flat(['a', ['b', ['c', 'd']], 'e'], (item, depth) => typeof item !== 'string')
  • seq ['a', 'b', 'c', 'd', 'e']

flatmap

• flatmap([{ ns: [1] }, { ns: [99, 10] }, { ns: [6, 3] }], x => x.ns) -> seq [1, 99, 10, 6, 3]
• flatmap([{ ns: [1] }, { ns: [99, 10] }, { ns: [6, 3] }], (x, index) => x.ns.map(n => [index, n]))
  • seq [[0, 1], [1, 99], [1, 10], [2, 6], [2, 3]]
• flatmap(['abc', 'cd'], text => text, (text, char, index) => `${index}. ${char} (${text})`)
  • seq ['0. a (abc)', '1. b (abc)', '2. c (abc)', '3. c (cd)', '4. d (cd)']

foreach

• foreach([1, 2, 3], x => { /* some action */ ; }) -> undefined

groupby

• groupby(['a', 'b', 'cc', 'ddd', 'xx'], x => x.length) -> Map {1 => ['a', 'b'], 2 => ['cc', 'xx'], 3 => ['ddd']}
• groupby(['a', 'b', 'cc', 'ddd', 'xx'], x => x.length, x => x.toUpperCase())
  • Map {1 => ['A', 'B'], 2 => ['CC', 'XX'], 3 => ['DDD']}
• groupby(['a', 'b', 'cc', 'ddd', 'xx'], x => x.length, (x, k) => k) -> Map {1 => [1, 1], 2 => [2, 2], 3 => [3]}
• pipe(['a', 'b', 'cc', 'ddd', 'xx'], groupby(x => x.length), map(([key, values]) => ({ key, values })))
  • seq [{ key:1, values:['a', 'b'] }, { key:2, values:['cc', 'xx'] }, { key:3, values:['ddd'] }]
• pipe(['a', 'b', 'cc', 'ddd', 'xx'], groupby(x => x.length), toobject())
  • { 1:['a', 'b'], 2:['cc', 'xx'], 3:['ddd'] }

groupbytoobject

• groupbytoobject(['a', 'bb', 'ccc', 'e', 'ff'], x => x.length) -> { 1:['a', 'e'], 2:['bb', 'ff'], 3:['ccc'] }
• groupbytoobject(['a', 'bb', 'ccc', 'e', 'ff'], x => x.length, x => x.toUpperCase())
  • { 1:['A', 'E'], 2:['BB', 'FF'], 3:['CCC'] }
• groupbytoobject(['a', 'bb', 'ccc', 'e', 'ff'], x => x.length, x => x.length)
  • { 1:[1, 1], 2:[2, 2], 3:[3] }
• groupbytoobject(['a', 'bb', 'ccc', 'e', 'ff'], x => x.length, (x, key) => x + key)
  • { 1:['a1', 'e1'], 2:['bb2', 'ff2'], 3:['ccc3'] }

groupbytotransformedobject

• groupbytotransformedobject(['a', 'bb', 'ccc', 'e', 'ff'], x => x.length, xs => xs.join(','))
  • { 1:'a,e', 2:'bb,ff', 3:'ccc' }
• groupbytotransformedobject(['a', 'bb', 'ccc', 'e', 'ff'], x => x.length, xs => xs.length)
  • { 1:2, 2:2, 3:1 }

groupjoin

• groupjoin([1, 3, 2, 1], ['a', 'b', 'cc'], x => x, y => y.length, (x, ys) => x + ':' + ys)
  • seq ['1:a,b', '3:', '2:cc', '1:a,b']

ignoreelements

• ignoreelements([1, 3, 2]) -> seq []

includes

• includes([1, 2, 3], 2) -> true
• includes([1, 2, 3], 5) -> false
• includes([1, 2, 3], 3, /*fromIndex*/ 4) -> false

interleave

• interleave([1, 2, 3], [10, 20]) -> seq [1, 10, 2, 20]
• interleave([-1], [1, 2, 3], [10, 20]) -> seq [-1, 1, 10]
• interleave([1, 2, 3]) -> seq [1, 2, 3]

interpose

• interpose([1, 2, 3], 0) -> seq [1, 0, 2, 0, 3]
• interpose([1], 0) -> seq [1]
• interpose([], 0) -> seq []

intersect

• intersect([1, 2, 2, 3], [3, 3, 1]) -> seq [3, 1]

intersectby

• intersectby(['a', 'c', 'ddd'], ['r', 'ww', 'ttt', 'oooo'], x => x.length)
  • seq ['r', 'ttt']

isempty

• isempty([]) -> true
• isempty([1, 2]) -> false

join

• join([1, 2, 3], ['a', 'bb', 'x'], x => x, y => y.length, (x, y) => x + ':' + y)
  • seq ['1:a', '1:x', '2:bb']

last

• last([1, 2, 3]) -> 3
• last([]) -> undefined
• last([1, 2, 3, 4, 5], x => x > 2) -> 5
• last([1, 2, 3, 4, 5], (x, index) => x > 2 && index < 4) -> 4
• last([1, 2, 3, 4, 5], x => x > 10) -> undefined
• last([1, 2, 3, 4, 5], x => x > 10, -1) -> -1

map

• map([1, 2, 3], x => x * 10) -> seq [10, 20, 30]
• map([1, 2, 3], (x, index) => x * 10 + index) -> seq [10, 21, 32]

max

• max([1, 2, 3, 1]) -> 3
• max(['a', 'bb', 'rrr', 'd'], x => x.length) -> 3

maxby

• maxby(['a', 'bb', 'rrr', 'd'], x => x.length) -> 'rrr'
• maxby(['a', 'bb', 'rrr', 'd'], (x, index) => x.length * index) -> 'rrr'

memoize

• pipe(range(0, 4), map(i => ({ i })), memoize(), xs => zip(xs, xs, (x1, x2) => [x1.i, x2.i, x1 === x2]))
  • seq [[0, 0, true], [1, 1, true], [2, 2, true], [3, 3, true]]

min

• min([1, 2, 3, 1]) -> 1
• min(['a', 'bb', 'rrr', 'd'], x => x.length) -> 1
• min(['a', 'bb', 'rrr', 'd'], (x, index) => x.length * index) -> 0

minby

• minby(['a', 'bb', 'rrr', 'd'], x => x.length) -> 'a'
• minby(['a', 'bb', 'rrr', 'd'], (x, index) => x.length * index) -> 'a'

oftype

• oftype([new Number(1), new Number(2), 's', false], Number) -> seq [{ }, { }]

orderby

• orderby([1, 4, 2, 3, 5, 1], x => x) -> seq [1, 1, 2, 3, 4, 5]
• orderby(['abc', 'dd', 'sdfe', 'f'], x => x.length) -> seq ['f', 'dd', 'abc', 'sdfe']

orderbydescending

• orderbydescending([1, 4, 2, 3, 5, 1], x => x) -> seq [5, 4, 3, 2, 1, 1]
• orderbydescending(['abc', 'dd', 'sdfe', 'f'], x => x.length) -> seq ['sdfe', 'abc', 'dd', 'f']

pairwise

• pairwise([1, 2, 3, 4]) -> seq [[1, 2], [2, 3], [3, 4]]
• pairwise([1, 2]) -> seq [[1, 2]]
• pairwise([1]) -> seq []
• pairwise([]) -> seq []

partitionby

• partitionby([1, 2, 4, 6, 3, 4], n => n % 2 === 0) -> seq [[1], [2, 4, 6], [3], [4]]

reduce

• reduce([1, 2, 3], (a, x) => a + x) -> 6
• reduce([1, 2, 3], (a, x) => a + (x * 10), '') -> '102030'

repeat

• repeat([1, 2, 3], 2) -> seq [1, 2, 3, 1, 2, 3]
• take(repeat([1, 2, 3]), 5) -> seq [1, 2, 3, 1, 2]

reverse

• reverse([1, 2, 3]) -> seq [3, 2, 1]

scan

• scan([1, 2, 3], (a, x) => a + x) -> seq [3, 6]
• scan([1], (a, x) => a + x) -> seq []
• scan([1, 2, 3], (a, x) => a + (x * 10), '') -> seq ['', '10', '1020', '102030']
• scan([1], (a, x) => a + (x * 10), '') -> seq ['', '10']
• scan([], (a, x) => a + (x * 10), '') -> seq ['']

sequenceequal

• sequenceequal([1, 2, 3], [1, 2, 3]) -> true
• sequenceequal([1, 2, 3], [1, 2, 2]) -> false
• sequenceequal([1, 2, 3], [1, 2]) -> false

share

• pipe(range(0, 4), map(i => ({ i })), share(), xs => zip(xs, xs, (x1, x2) => [x1.i, x2.i, x1 === x2]))
  • seq [[0, 1, false], [2, 3, false]]

single

• single([1]) -> 1
• single([]) -> undefined
• single([1, 2, 3], x => x > 2) -> 3
• single([1, 2, 3], x => x > 10) -> undefined
• single([1, 2, 3], x => x > 10, -1) -> -1

skip

• skip([1, 2, 3, 4, 5], 2) -> seq [3, 4, 5]

skiplast

• skiplast([1, 2, 3, 4], 2) -> seq [1, 2]
• skiplast([1, 2, 3, 4], 0) -> seq [1, 2, 3, 4]
• skiplast([1, 2, 3, 4], 5) -> seq []

skipwhile

• skipwhile([1, 2, 2, 3, 3, 4, 5], x => x < 3) -> seq [3, 3, 4, 5]

some

• some([1]) -> true
• some([]) -> false
• some([1, 2, 3], x => x > 2) -> true
• some([1, 2, 3], x => x > 3) -> false

sum

• sum([1, 2, 3]) -> 6
• sum(['a', 'asd', 'yy'], x => x.length) -> 6
• sum(['a', 'asd', 'yy'], (x, index) => x.length + index) -> 9

take

• take([1, 2, 3, 4, 5], 2) -> seq [1, 2]

takelast

• takelast([1, 2, 3], 2) -> seq [2, 3]
• takelast([1, 2, 3], 0) -> seq []
• takelast([1, 2, 3], 5) -> seq [1, 2, 3]

takewhile

• takewhile([1, 2, 2, 3, 3, 4, 5], x => x < 3) -> seq [1, 2, 2]

thenby

• thenby(orderby(['xa', 'a', 'fg', 'ert', 'b'], x => x.length), x => x) -> seq ['a', 'b', 'fg', 'xa', 'ert']

thenbydescending

• thenbydescending(orderby(['xa', 'a', 'fg', 'ert', 'b'], x => x.length), x => x)
  • seq ['b', 'a', 'xa', 'fg', 'ert']

toarray

• toarray([1, 2, 2]) -> [1, 2, 2]

tomap

• tomap(['a', 'bb', 'ccc'], x => x.length) -> Map {1 => 'a', 2 => 'bb', 3 => 'ccc'}
• tomap(['a', 'bb', 'ccc'], x => x.length, x => x.toUpperCase()) -> Map {1 => 'A', 2 => 'BB', 3 => 'CCC'}

toobject

• toobject(['a', 'bb', 'ccc'], x => x.length) -> { 1:'a', 2:'bb', 3:'ccc' }
• toobject(['a', 'bb', 'ccc'], x => x.length, x => x.toUpperCase()) -> { 1:'A', 2:'BB', 3:'CCC' }
• toobject(['a', 'bb', 'ccc'], x => x.length, (x, k) => k) -> { 1:1, 2:2, 3:3 }
• toobject(new Map([[1, 'one'], [2, 'two']])) -> { 1:'one', 2:'two' }

union

• union([1, 2, 2], [2, 3, 3, 4]) -> seq [1, 2, 3, 4]

unionby

• unionby(['a', 'c', 'ddd'], ['r', 'ww', 'ttt', 'oooo'], x => x.length) -> seq ['a', 'ddd', 'ww', 'oooo']

zip

• zip(['a', 'b', 'c'], [1, 2], (s, n) => s + n) -> seq ['a1', 'b2']
• zip(['a', 'b', 'c'], [1, 2], [false], (s, n, b) => s + n + b) -> seq ['a1false']

mapping

• average - Average (linq), mean, meanBy (lodash), average, averageBy (fsharp), average (kotlin), C.averaging*, C.summarizing* (java)
• buffer - Chunk (linq), bufferCount, pairwise (rxjs), chunk (lodash), chunkBySize, windowed, pairwise (fsharp), partition-all, partition~ (clojure), chunked, windowed (kotlin)
• cast - Cast (linq), cast (fsharp)
• combinations -
• concat - Concat (linq), concat (rxjs), concat (jsarray), concat (lodash), append (fsharp), concat (clojure), plus, plusElement (kotlin), concat (java)
• count - Count (linq), count (rxjs), size (lodash), length (fsharp), count (clojure), count (kotlin), count, C.counting, C.summarizing* (java)
• countby - countBy (fsharp)
• defaultifempty - DefaultIfEmpty (linq), defaultIfEmpty (rxjs), ifEmpty (kotlin)
• defer - defer (rxjs), delay (fsharp)
• distinct - Distinct (linq), distinct (rxjs), uniq, uniqWith (lodash), distinct (fsharp), distinct (clojure), distinct (kotlin), distinct (java)
• distinctby - DistinctBy (linq), uniqBy (lodash), distinctBy (fsharp), distinctBy (kotlin)
• distinctuntilchanged - distinctUntilChanged, distinctUntilKeyChanged (rxjs), dedupe (clojure)
• doo - do (rxjs), onEach (kotlin), peek (java)
• elementat - ElementAt, ElementAtOrDefault (linq), elementAt (rxjs), nth (lodash), nth (fsharp), nth, get~ (clojure), elementAt, elementAtOrElse, elementAtOrNull (kotlin)
• empty - empty (rxjs), empty (fsharp), emptySequence (kotlin), empty (java)
• entries - pairs (rxjs), entries (jsarray)
• every - All (linq), every (rxjs), every (jsarray), every (lodash), forall (fsharp), every? (clojure), all (kotlin), allMatch (java)
• except - Except (linq), difference, without (lodash), difference~ (clojure), minus~ (kotlin)
• exceptby - ExceptBy (linq), differenceBy, differenceWith (lodash)
• expand - expand (rxjs), unfold (fsharp)
• filter - Where (linq), filter (rxjs), filter (jsarray), filter (lodash), filter, where (fsharp), filter (clojure), filter, filterIndexed (kotlin), filter (java)
• filtermap - choose (fsharp), keep (clojure), mapNotNull, mapIndexedNotNull (kotlin)
• find - First, FirstOrDefault (linq), find, first (rxjs), find (jsarray), first, head, find (lodash), find~, tryFind, head (fsharp), first~ (clojure), find, first~ (kotlin), findFirst~ (java)
• findindex - findIndex (rxjs), findIndex (jsarray), findIndex (lodash), findIndex~, tryFindIndex (fsharp), indexOfFirst, indexOf~ (kotlin)
• flat - flat~ (jsarray), flatten (lodash), flatten~ (clojure), flatten (kotlin)
• flatmap - SelectMany (linq), flatMap (jsarray), flatMap (lodash), collect (fsharp), mapcat (clojure), flatMap (kotlin), flatMap, mapMulti (java)
• foreach - forEach (jsarray), each, forEach (lodash), iter, iteri (fsharp), forEach, forEachIndexed (kotlin), forEach (java)
• generate - init, initInfinite (fsharp), iterate, repeatedly (clojure), generate (kotlin), iterate (java)
• groupby - GroupBy (linq), groupBy (rxjs), groupBy (lodash), groupBy (fsharp), group-by (clojure), groupBy, groupingBy (kotlin), C.groupingBy (java)
• groupbytoobject -
• groupbytotransformedobject -
• groupjoin - GroupJoin (linq)
• ignoreelements - ignoreElements (rxjs)
• includes - Contains (linq), includes (jsarray), includes (lodash), contains (fsharp), contains? (clojure), contains (kotlin)
• interleave - interleave (clojure)
• interpose - interpose (clojure)
• intersect - Intersect (linq), intersection (lodash), intersection~ (clojure), intersect~ (kotlin)
• intersectby - IntersectBy (linq), intersectionBy, intersectionWith (lodash)
• isempty - isEmpty (rxjs), isEmpty (fsharp), empty? (clojure), none (kotlin)
• join - Join (linq)
• last - Last, LastOrDefault (linq), last (rxjs), findLast (lodash), last (fsharp), findLast, last~ (kotlin)
• map - Select (linq), map (rxjs), map (jsarray), map (lodash), map, mapi (fsharp), map (clojure), map, mapIndexed (kotlin), map (java)
• max - Max (linq), max (rxjs), max (lodash), max (fsharp), maxOf (kotlin), max (java)
• maxby - MaxBy (linq), maxBy (lodash), maxBy (fsharp), max-key (clojure), maxBy (kotlin), C.maxBy, C.summarizing* (java)
• memoize - cache (fsharp)
• min - Min (linq), min (rxjs), min (lodash), min (fsharp), minOf (kotlin), min (java)
• minby - MinBy (linq), minBy (lodash), minBy (fsharp), min-key (clojure), minBy (kotlin), C.minBy, C.summarizing* (java)
• oftype - OfType (linq)
• orderby - OrderBy (linq), sort (jsarray), orderBy, sortBy (lodash), sort, sortBy (fsharp), sort, sort-by (clojure), sorted, sortedBy (kotlin), sorted (java)
• orderbydescending - OrderByDescending (linq), sort (jsarray), orderBy, sortBy (lodash), sort, sortBy (fsharp), sortedDescending, sortedByDescending (kotlin)
• pairwise - pairwise (rxjs), pairwise (fsharp)
• partitionby - partition-by (clojure)
• range - Range (linq), range (rxjs), range (lodash), range (clojure)
• reduce - Aggregate (linq), reduce (rxjs), reduce (jsarray), reduce (lodash), fold, reduce (fsharp), reduce (clojure), fold, reduce, reduceOrNull (kotlin), reduce (java)
• repeat - repeat (rxjs), cycle (clojure)
• repeatvalue - repeat (clojure)
• reverse - Reverse (linq), reverse (jsarray), reverse (lodash), reverse (clojure)
• scan - scan (rxjs), scan (fsharp), reductions (clojure), scan, runningFold, runningReduce (kotlin)
• sequenceequal - SequenceEqual (linq), sequenceEqual (rxjs)
• share - share (rxjs)
• single - Single, SingleOrDefault (linq), single (rxjs), exactlyOne (fsharp), single, singleOrNull (kotlin)
• skip - Skip (linq), skip (rxjs), drop, tail (lodash), skip~ (fsharp), drop (clojure), drop (kotlin), skip (java)
• skiplast - dropRight, initial (lodash), drop-last (clojure)
• skipwhile - SkipWhile (linq), skipWhile (rxjs), dropWhile (lodash), skipWhile (fsharp), drop-while (clojure), dropWhile (kotlin), dropwhile (java)
• some - Any (linq), some (jsarray), some (lodash), exists (fsharp), some (clojure), any (kotlin), anyMatch (java)
• sum - Sum (linq), sum, sumBy (lodash), sum, sumBy (fsharp), sum, sumOf (kotlin), C.summing*, C.summarizing* (java)
• take - Take (linq), take (rxjs), take (lodash), truncate, ~take (fsharp), take (clojure), take (kotlin), limit (java)
• takelast - takeLast (rxjs), last, takeRight (lodash), take-last (clojure)
• takewhile - TakeWhile (linq), takeWhile (rxjs), takeWhile (lodash), takeWhile (fsharp), take-while (clojure), takeWhile (kotlin), takeWhile (java)
• thenby - ThenBy (linq), sort (jsarray), orderBy, sortBy (lodash), sort, sortBy (fsharp)
• thenbydescending - ThenByDescending (linq), sort (jsarray), orderBy, sortBy (lodash), sort, sortBy (fsharp)
• throww - throw (rxjs)
• toarray - ToArray (linq), toArray (fsharp), toList (kotlin), toArray, toList, C.toList (java)
• tomap - ToDictionary (linq), toMap (kotlin), C.toMap (java)
• toobject - fromPairs, keyBy (lodash), associate, associateBy, associateWith (kotlin), C.toMap (java)
• union - Union (linq), union (lodash), union~ (clojure), union~ (kotlin)
• unionby - UnionBy (linq), unionBy, unionWith (lodash)
• zip - Zip (linq), zip (rxjs), zip, zipWith (lodash), zip, zip3 (fsharp), map (clojure), zip (kotlin)