OrderedMap

A type of Map that has the additional guarantee that the iteration order of entries will be the order in which they were set().

type OrderedMap<K, V> extends Map<K, V>

Discussion

The iteration behavior of OrderedMap is the same as native ES6 Map and JavaScript Object.

Note that OrderedMap are more expensive than non-ordered Map and may consume more memory. OrderedMap#set is amortized O(log32 N), but not stable.

Construction

OrderedMap()

OrderedMap<K, V>(): OrderedMap<K, V> OrderedMap<K, V>(iter: Iterable.Keyed<K, V>): OrderedMap<K, V> OrderedMap<K, V>(iter: Iterable<any, Array<any>>): OrderedMap<K, V> OrderedMap<K, V>(array: Array<Array<any>>): OrderedMap<K, V> OrderedMap<V>(obj: {[key: string]: V}): OrderedMap<string, V> OrderedMap<K, V>(iterator: Iterator<Array<any>>): OrderedMap<K, V> OrderedMap<K, V>(iterable: Object): OrderedMap<K, V>

Static methods

OrderedMap.isOrderedMap()

OrderedMap.isOrderedMap(maybeOrderedMap: any): boolean

Persistent changes

set()

Returns a new Map also containing the new key, value pair. If an equivalent key already exists in this Map, it will be replaced.

set(key: K, value: V): Map<K, V>

Inherited from

Map#set()

delete()

Returns a new Map which excludes this key.

delete(key: K): Map<K, V>

Inherited from

Map#delete()

alias

remove()

Discussion

Note: delete cannot be safely used in IE8, but is provided to mirror the ES6 collection API.

clear()

Returns a new Map containing no keys or values.

clear(): Map<K, V>

Inherited from

Map#clear()

update()

update(updater: (value: Map<K, V>) => Map<K, V>): Map<K, V> update(key: K, updater: (value: V) => V): Map<K, V> update(key: K, notSetValue: V, updater: (value: V) => V): Map<K, V>

Inherited from

Map#update()

merge()

merge(...iterables: Iterable<K, V>[]): Map<K, V> merge(...iterables: {[key: string]: V}[]): Map<string, V>

Inherited from

Map#merge()

mergeWith()

mergeWith(
merger: (previous?: V, next?: V, key?: K) => V,
...iterables: Iterable<K, V>[]
): Map<K, V>
mergeWith(
merger: (previous?: V, next?: V, key?: K) => V,
...iterables: {[key: string]: V}[]
): Map<string, V>

Inherited from

Map#mergeWith()

mergeDeep()

mergeDeep(...iterables: Iterable<K, V>[]): Map<K, V> mergeDeep(...iterables: {[key: string]: V}[]): Map<string, V>

Inherited from

Map#mergeDeep()

mergeDeepWith()

mergeDeepWith(
merger: (previous?: V, next?: V, key?: K) => V,
...iterables: Iterable<K, V>[]
): Map<K, V>
mergeDeepWith(
merger: (previous?: V, next?: V, key?: K) => V,
...iterables: {[key: string]: V}[]
): Map<string, V>

Inherited from

Map#mergeDeepWith()

Deep persistent changes

setIn()

setIn(keyPath: Array<any>, value: any): Map<K, V> setIn(KeyPath: Iterable<any, any>, value: any): Map<K, V>

Inherited from

Map#setIn()

deleteIn()

deleteIn(keyPath: Array<any>): Map<K, V> deleteIn(keyPath: Iterable<any, any>): Map<K, V>

Inherited from

Map#deleteIn()

updateIn()

updateIn(keyPath: Array<any>, updater: (value: any) => any): Map<K, V> updateIn(
keyPath: Array<any>,
notSetValue: any,
updater: (value: any) => any
): Map<K, V>
updateIn(keyPath: Iterable<any, any>, updater: (value: any) => any): Map<K, V> updateIn(
keyPath: Iterable<any, any>,
notSetValue: any,
updater: (value: any) => any
): Map<K, V>

Inherited from

Map#updateIn()

mergeIn()

mergeIn(keyPath: Iterable<any, any>, ...iterables: Iterable<K, V>[]): Map<K, V> mergeIn(keyPath: Array<any>, ...iterables: Iterable<K, V>[]): Map<K, V> mergeIn(keyPath: Array<any>, ...iterables: {[key: string]: V}[]): Map<string, V>

Inherited from

Map#mergeIn()

mergeDeepIn()

mergeDeepIn(
keyPath: Iterable<any, any>,
...iterables: Iterable<K, V>[]
): Map<K, V>
mergeDeepIn(keyPath: Array<any>, ...iterables: Iterable<K, V>[]): Map<K, V> mergeDeepIn(
keyPath: Array<any>,
...iterables: {[key: string]: V}[]
): Map<string, V>

Inherited from

Map#mergeDeepIn()

Transient changes

withMutations()

Every time you call one of the above functions, a new immutable Map is created. If a pure function calls a number of these to produce a final return value, then a penalty on performance and memory has been paid by creating all of the intermediate immutable Maps.

withMutations(mutator: (mutable: Map<K, V>) => any): Map<K, V>

Inherited from

Map#withMutations()

Discussion

If you need to apply a series of mutations to produce a new immutable Map, withMutations() creates a temporary mutable copy of the Map which can apply mutations in a highly performant manner. In fact, this is exactly how complex mutations like merge are done.

As an example, this results in the creation of 2, not 4, new Maps:

var map1 = Immutable.Map(); var map2 = map1.withMutations(map => { map.set('a', 1).set('b', 2).set('c', 3); }); assert(map1.size === 0); assert(map2.size === 3);

Note: Not all methods can be used on a mutable collection or within withMutations! Only set and merge may be used mutatively.

asMutable()

Another way to avoid creation of intermediate Immutable maps is to create a mutable copy of this collection. Mutable copies always return this, and thus shouldn't be used for equality. Your function should never return a mutable copy of a collection, only use it internally to create a new collection. If possible, use withMutations as it provides an easier to use API.

asMutable(): Map<K, V>

Inherited from

Map#asMutable()

Discussion

Note: if the collection is already mutable, asMutable returns itself.

Note: Not all methods can be used on a mutable collection or within withMutations! Only set and merge may be used mutatively.

asImmutable()

The yin to asMutable's yang. Because it applies to mutable collections, this operation is mutable and returns itself. Once performed, the mutable copy has become immutable and can be safely returned from a function.

asImmutable(): Map<K, V>

Inherited from

Map#asImmutable()

Conversion to Seq

toSeq()

Returns Seq.Keyed.

toSeq(): Seq.Keyed<K, V>

Inherited from

Collection.Keyed#toSeq()

toKeyedSeq()

Returns a Seq.Keyed from this Iterable where indices are treated as keys.

toKeyedSeq(): Seq.Keyed<K, V>

Inherited from

Iterable#toKeyedSeq()

Discussion

This is useful if you want to operate on an Iterable.Indexed and preserve the [index, value] pairs.

The returned Seq will have identical iteration order as this Iterable.

Example:

var indexedSeq = Immutable.Seq.of('A', 'B', 'C'); indexedSeq.filter(v => v === 'B').toString() // Seq [ 'B' ] var keyedSeq = indexedSeq.toKeyedSeq(); keyedSeq.filter(v => v === 'B').toString() // Seq { 1: 'B' }

toIndexedSeq()

Returns an Seq.Indexed of the values of this Iterable, discarding keys.

toIndexedSeq(): Seq.Indexed<V>

Inherited from

Iterable#toIndexedSeq()

toSetSeq()

Returns a Seq.Set of the values of this Iterable, discarding keys.

toSetSeq(): Seq.Set<V>

Inherited from

Iterable#toSetSeq()

Members

size

All collections maintain their current size as an integer.

size: number

Inherited from

Collection#size

Value equality

equals()

True if this and the other Iterable have value equality, as defined by Immutable.is().

equals(other: Iterable<K, V>): boolean

Inherited from

Iterable#equals()

Discussion

Note: This is equivalent to Immutable.is(this, other), but provided to allow for chained expressions.

hashCode()

Computes and returns the hashed identity for this Iterable.

hashCode(): number

Inherited from

Iterable#hashCode()

Discussion

The hashCode of an Iterable is used to determine potential equality, and is used when adding this to a Set or as a key in a Map, enabling lookup via a different instance.

var a = List.of(1, 2, 3); var b = List.of(1, 2, 3); assert(a !== b); // different instances var set = Set.of(a); assert(set.has(b) === true);

If two values have the same hashCode, they are not guaranteed to be equal. If two values have different hashCodes, they must not be equal.

Reading values

get()

Returns the value associated with the provided key, or notSetValue if the Iterable does not contain this key.

get(key: K, notSetValue?: V): V

Inherited from

Iterable#get()

Discussion

Note: it is possible a key may be associated with an undefined value, so if notSetValue is not provided and this method returns undefined, that does not guarantee the key was not found.

has()

True if a key exists within this Iterable, using Immutable.is to determine equality

has(key: K): boolean

Inherited from

Iterable#has()

includes()

True if a value exists within this Iterable, using Immutable.is to determine equality

includes(value: V): boolean

Inherited from

Iterable#includes()

alias

contains()

first()

The first value in the Iterable.

first(): V

Inherited from

Iterable#first()

last()

The last value in the Iterable.

last(): V

Inherited from

Iterable#last()

Reading deep values

getIn()

getIn(searchKeyPath: Array<any>, notSetValue?: any): any getIn(searchKeyPath: Iterable<any, any>, notSetValue?: any): any

Inherited from

Iterable#getIn()

hasIn()

hasIn(searchKeyPath: Array<any>): boolean hasIn(searchKeyPath: Iterable<any, any>): boolean

Inherited from

Iterable#hasIn()

Conversion to JavaScript types

toJS()

Deeply converts this Iterable to equivalent JS.

toJS(): any

Inherited from

Iterable#toJS()

alias

toJSON()

Discussion

Iterable.Indexeds, and Iterable.Sets become Arrays, while Iterable.Keyeds become Objects.

toArray()

Shallowly converts this iterable to an Array, discarding keys.

toArray(): Array<V>

Inherited from

Iterable#toArray()

toObject()

Shallowly converts this Iterable to an Object.

toObject(): {[key: string]: V}

Inherited from

Iterable#toObject()

Discussion

Throws if keys are not strings.

Conversion to Collections

toMap()

Converts this Iterable to a Map, Throws if keys are not hashable.

toMap(): Map<K, V>

Inherited from

Iterable#toMap()

Discussion

Note: This is equivalent to Map(this.toKeyedSeq()), but provided for convenience and to allow for chained expressions.

toOrderedMap()

Converts this Iterable to a Map, maintaining the order of iteration.

toOrderedMap(): OrderedMap<K, V>

Inherited from

Iterable#toOrderedMap()

Discussion

Note: This is equivalent to OrderedMap(this.toKeyedSeq()), but provided for convenience and to allow for chained expressions.

toSet()

Converts this Iterable to a Set, discarding keys. Throws if values are not hashable.

toSet(): Set<V>

Inherited from

Iterable#toSet()

Discussion

Note: This is equivalent to Set(this), but provided to allow for chained expressions.

toOrderedSet()

Converts this Iterable to a Set, maintaining the order of iteration and discarding keys.

toOrderedSet(): OrderedSet<V>

Inherited from

Iterable#toOrderedSet()

Discussion

Note: This is equivalent to OrderedSet(this.valueSeq()), but provided for convenience and to allow for chained expressions.

toList()

Converts this Iterable to a List, discarding keys.

toList(): List<V>

Inherited from

Iterable#toList()

Discussion

Note: This is equivalent to List(this), but provided to allow for chained expressions.

toStack()

Converts this Iterable to a Stack, discarding keys. Throws if values are not hashable.

toStack(): Stack<V>

Inherited from

Iterable#toStack()

Discussion

Note: This is equivalent to Stack(this), but provided to allow for chained expressions.

Iterators

keys()

An iterator of this Iterable's keys.

keys(): Iterator<K>

Inherited from

Iterable#keys()

Discussion

Note: this will return an ES6 iterator which does not support Immutable JS sequence algorithms. Use keySeq instead, if this is what you want.

values()

An iterator of this Iterable's values.

values(): Iterator<V>

Inherited from

Iterable#values()

Discussion

Note: this will return an ES6 iterator which does not support Immutable JS sequence algorithms. Use valueSeq instead, if this is what you want.

entries()

An iterator of this Iterable's entries as [key, value] tuples.

entries(): Iterator<Array<any>>

Inherited from

Iterable#entries()

Discussion

Note: this will return an ES6 iterator which does not support Immutable JS sequence algorithms. Use entrySeq instead, if this is what you want.

Iterables (Seq)

keySeq()

Returns a new Seq.Indexed of the keys of this Iterable, discarding values.

keySeq(): Seq.Indexed<K>

Inherited from

Iterable#keySeq()

valueSeq()

Returns an Seq.Indexed of the values of this Iterable, discarding keys.

valueSeq(): Seq.Indexed<V>

Inherited from

Iterable#valueSeq()

entrySeq()

Returns a new Seq.Indexed of [key, value] tuples.

entrySeq(): Seq.Indexed<Array<any>>

Inherited from

Iterable#entrySeq()

Sequence algorithms

map()

Returns a new Iterable of the same type with values passed through a mapper function.

map<M>(
mapper: (value?: V, key?: K, iter?: Iterable<K, V>) => M,
context?: any
): Iterable<K, M>

Inherited from

Iterable#map()

Discussion

Seq({ a: 1, b: 2 }).map(x => 10 * x) // Seq { a: 10, b: 20 }

filter()

Returns a new Iterable of the same type with only the entries for which the predicate function returns true.

filter(
predicate: (value?: V, key?: K, iter?: Iterable<K, V>) => boolean,
context?: any
): Iterable<K, V>

Inherited from

Iterable#filter()

Discussion

Seq({a:1,b:2,c:3,d:4}).filter(x => x % 2 === 0) // Seq { b: 2, d: 4 }

filterNot()

Returns a new Iterable of the same type with only the entries for which the predicate function returns false.

filterNot(
predicate: (value?: V, key?: K, iter?: Iterable<K, V>) => boolean,
context?: any
): Iterable<K, V>

Inherited from

Iterable#filterNot()

Discussion

Seq({a:1,b:2,c:3,d:4}).filterNot(x => x % 2 === 0) // Seq { a: 1, c: 3 }

reverse()

Returns a new Iterable of the same type in reverse order.

reverse(): Iterable<K, V>

Inherited from

Iterable#reverse()

sort()

Returns a new Iterable of the same type which includes the same entries, stably sorted by using a comparator.

sort(comparator?: (valueA: V, valueB: V) => number): Iterable<K, V>

Inherited from

Iterable#sort()

Discussion

If a comparator is not provided, a default comparator uses < and >.

comparator(valueA, valueB):

  • Returns 0 if the elements should not be swapped.
  • Returns -1 (or any negative number) if valueA comes before valueB
  • Returns 1 (or any positive number) if valueA comes after valueB
  • Is pure, i.e. it must always return the same value for the same pair of values.

When sorting collections which have no defined order, their ordered equivalents will be returned. e.g. map.sort() returns OrderedMap.

sortBy()

Like sort, but also accepts a comparatorValueMapper which allows for sorting by more sophisticated means:

sortBy<C>(
comparatorValueMapper: (value?: V, key?: K, iter?: Iterable<K, V>) => C,
comparator?: (valueA: C, valueB: C) => number
): Iterable<K, V>

Inherited from

Iterable#sortBy()

Discussion

hitters.sortBy(hitter => hitter.avgHits);

groupBy()

Returns a Iterable.Keyed of Iterable.Keyeds, grouped by the return value of the grouper function.

groupBy<G>(
grouper: (value?: V, key?: K, iter?: Iterable<K, V>) => G,
context?: any
): Seq.Keyed<G, Iterable<K, V>>

Inherited from

Iterable#groupBy()

Discussion

Note: This is always an eager operation.

Side effects

forEach()

The sideEffect is executed for every entry in the Iterable.

forEach(
sideEffect: (value?: V, key?: K, iter?: Iterable<K, V>) => any,
context?: any
): number

Inherited from

Iterable#forEach()

Discussion

Unlike Array#forEach, if any call of sideEffect returns false, the iteration will stop. Returns the number of entries iterated (including the last iteration which returned false).

Creating subsets

slice()

Returns a new Iterable of the same type representing a portion of this Iterable from start up to but not including end.

slice(begin?: number, end?: number): Iterable<K, V>

Inherited from

Iterable#slice()

Discussion

If begin is negative, it is offset from the end of the Iterable. e.g. slice(-2) returns a Iterable of the last two entries. If it is not provided the new Iterable will begin at the beginning of this Iterable.

If end is negative, it is offset from the end of the Iterable. e.g. slice(0, -1) returns an Iterable of everything but the last entry. If it is not provided, the new Iterable will continue through the end of this Iterable.

If the requested slice is equivalent to the current Iterable, then it will return itself.

rest()

Returns a new Iterable of the same type containing all entries except the first.

rest(): Iterable<K, V>

Inherited from

Iterable#rest()

butLast()

Returns a new Iterable of the same type containing all entries except the last.

butLast(): Iterable<K, V>

Inherited from

Iterable#butLast()

skip()

Returns a new Iterable of the same type which excludes the first amount entries from this Iterable.

skip(amount: number): Iterable<K, V>

Inherited from

Iterable#skip()

skipLast()

Returns a new Iterable of the same type which excludes the last amount entries from this Iterable.

skipLast(amount: number): Iterable<K, V>

Inherited from

Iterable#skipLast()

skipWhile()

Returns a new Iterable of the same type which includes entries starting from when predicate first returns false.

skipWhile(
predicate: (value?: V, key?: K, iter?: Iterable<K, V>) => boolean,
context?: any
): Iterable<K, V>

Inherited from

Iterable#skipWhile()

Discussion

Seq.of('dog','frog','cat','hat','god') .skipWhile(x => x.match(/g/)) // Seq [ 'cat', 'hat', 'god' ]

skipUntil()

Returns a new Iterable of the same type which includes entries starting from when predicate first returns true.

skipUntil(
predicate: (value?: V, key?: K, iter?: Iterable<K, V>) => boolean,
context?: any
): Iterable<K, V>

Inherited from

Iterable#skipUntil()

Discussion

Seq.of('dog','frog','cat','hat','god') .skipUntil(x => x.match(/hat/)) // Seq [ 'hat', 'god' ]

take()

Returns a new Iterable of the same type which includes the first amount entries from this Iterable.

take(amount: number): Iterable<K, V>

Inherited from

Iterable#take()

takeLast()

Returns a new Iterable of the same type which includes the last amount entries from this Iterable.

takeLast(amount: number): Iterable<K, V>

Inherited from

Iterable#takeLast()

takeWhile()

Returns a new Iterable of the same type which includes entries from this Iterable as long as the predicate returns true.

takeWhile(
predicate: (value?: V, key?: K, iter?: Iterable<K, V>) => boolean,
context?: any
): Iterable<K, V>

Inherited from

Iterable#takeWhile()

Discussion

Seq.of('dog','frog','cat','hat','god') .takeWhile(x => x.match(/o/)) // Seq [ 'dog', 'frog' ]

takeUntil()

Returns a new Iterable of the same type which includes entries from this Iterable as long as the predicate returns false.

takeUntil(
predicate: (value?: V, key?: K, iter?: Iterable<K, V>) => boolean,
context?: any
): Iterable<K, V>

Inherited from

Iterable#takeUntil()

Discussion

Seq.of('dog','frog','cat','hat','god').takeUntil(x => x.match(/at/)) // ['dog', 'frog']

Combination

concat()

Returns a new Iterable of the same type with other values and iterable-like concatenated to this one.

concat(...valuesOrIterables: any[]): Iterable<K, V>

Inherited from

Iterable#concat()

Discussion

For Seqs, all entries will be present in the resulting iterable, even if they have the same key.

flatten()

flatten(depth?: number): Iterable<any, any> flatten(shallow?: boolean): Iterable<any, any>

Inherited from

Iterable#flatten()

flatMap()

flatMap<MK, MV>(
mapper: (value?: V, key?: K, iter?: Iterable<K, V>) => Iterable<MK, MV>,
context?: any
): Iterable<MK, MV>
flatMap<MK, MV>(
mapper: (value?: V, key?: K, iter?: Iterable<K, V>) => any,
context?: any
): Iterable<MK, MV>

Inherited from

Iterable#flatMap()

Reducing a value

reduce()

Reduces the Iterable to a value by calling the reducer for every entry in the Iterable and passing along the reduced value.

reduce<R>(
reducer: (reduction?: R, value?: V, key?: K, iter?: Iterable<K, V>) => R,
initialReduction?: R,
context?: any
): R

Inherited from

Iterable#reduce()

see

Discussion

If initialReduction is not provided, or is null, the first item in the Iterable will be used.

reduceRight()

Reduces the Iterable in reverse (from the right side).

reduceRight<R>(
reducer: (reduction?: R, value?: V, key?: K, iter?: Iterable<K, V>) => R,
initialReduction?: R,
context?: any
): R

Inherited from

Iterable#reduceRight()

Discussion

Note: Similar to this.reverse().reduce(), and provided for parity with Array#reduceRight.

every()

True if predicate returns true for all entries in the Iterable.

every(
predicate: (value?: V, key?: K, iter?: Iterable<K, V>) => boolean,
context?: any
): boolean

Inherited from

Iterable#every()

some()

True if predicate returns true for any entry in the Iterable.

some(
predicate: (value?: V, key?: K, iter?: Iterable<K, V>) => boolean,
context?: any
): boolean

Inherited from

Iterable#some()

join()

Joins values together as a string, inserting a separator between each. The default separator is ",".

join(separator?: string): string

Inherited from

Iterable#join()

isEmpty()

Returns true if this Iterable includes no values.

isEmpty(): boolean

Inherited from

Iterable#isEmpty()

Discussion

For some lazy Seq, isEmpty might need to iterate to determine emptiness. At most one iteration will occur.

count()

count(): number count(
predicate: (value?: V, key?: K, iter?: Iterable<K, V>) => boolean,
context?: any
): number

Inherited from

Iterable#count()

countBy()

Returns a Seq.Keyed of counts, grouped by the return value of the grouper function.

countBy<G>(
grouper: (value?: V, key?: K, iter?: Iterable<K, V>) => G,
context?: any
): Map<G, number>

Inherited from

Iterable#countBy()

Discussion

Note: This is not a lazy operation.

Search for value

find()

Returns the first value for which the predicate returns true.

find(
predicate: (value?: V, key?: K, iter?: Iterable<K, V>) => boolean,
context?: any,
notSetValue?: V
): V

Inherited from

Iterable#find()

findLast()

Returns the last value for which the predicate returns true.

findLast(
predicate: (value?: V, key?: K, iter?: Iterable<K, V>) => boolean,
context?: any,
notSetValue?: V
): V

Inherited from

Iterable#findLast()

Discussion

Note: predicate will be called for each entry in reverse.

findEntry()

Returns the first [key, value] entry for which the predicate returns true.

findEntry(
predicate: (value?: V, key?: K, iter?: Iterable<K, V>) => boolean,
context?: any,
notSetValue?: V
): Array<any>

Inherited from

Iterable#findEntry()

findLastEntry()

Returns the last [key, value] entry for which the predicate returns true.

findLastEntry(
predicate: (value?: V, key?: K, iter?: Iterable<K, V>) => boolean,
context?: any,
notSetValue?: V
): Array<any>

Inherited from

Iterable#findLastEntry()

Discussion

Note: predicate will be called for each entry in reverse.

findKey()

Returns the key for which the predicate returns true.

findKey(
predicate: (value?: V, key?: K, iter?: Iterable.Keyed<K, V>) => boolean,
context?: any
): K

Inherited from

Iterable#findKey()

findLastKey()

Returns the last key for which the predicate returns true.

findLastKey(
predicate: (value?: V, key?: K, iter?: Iterable.Keyed<K, V>) => boolean,
context?: any
): K

Inherited from

Iterable#findLastKey()

Discussion

Note: predicate will be called for each entry in reverse.

keyOf()

Returns the key associated with the search value, or undefined.

keyOf(searchValue: V): K

Inherited from

Iterable#keyOf()

lastKeyOf()

Returns the last key associated with the search value, or undefined.

lastKeyOf(searchValue: V): K

Inherited from

Iterable#lastKeyOf()

max()

Returns the maximum value in this collection. If any values are comparatively equivalent, the first one found will be returned.

max(comparator?: (valueA: V, valueB: V) => number): V

Inherited from

Iterable#max()

Discussion

The comparator is used in the same way as Iterable#sort. If it is not provided, the default comparator is >.

When two values are considered equivalent, the first encountered will be returned. Otherwise, max will operate independent of the order of input as long as the comparator is commutative. The default comparator > is commutative only when types do not differ.

If comparator returns 0 and either value is NaN, undefined, or null, that value will be returned.

maxBy()

Like max, but also accepts a comparatorValueMapper which allows for comparing by more sophisticated means:

maxBy<C>(
comparatorValueMapper: (value?: V, key?: K, iter?: Iterable<K, V>) => C,
comparator?: (valueA: C, valueB: C) => number
): V

Inherited from

Iterable#maxBy()

Discussion

hitters.maxBy(hitter => hitter.avgHits);

min()

Returns the minimum value in this collection. If any values are comparatively equivalent, the first one found will be returned.

min(comparator?: (valueA: V, valueB: V) => number): V

Inherited from

Iterable#min()

Discussion

The comparator is used in the same way as Iterable#sort. If it is not provided, the default comparator is <.

When two values are considered equivalent, the first encountered will be returned. Otherwise, min will operate independent of the order of input as long as the comparator is commutative. The default comparator < is commutative only when types do not differ.

If comparator returns 0 and either value is NaN, undefined, or null, that value will be returned.

minBy()

Like min, but also accepts a comparatorValueMapper which allows for comparing by more sophisticated means:

minBy<C>(
comparatorValueMapper: (value?: V, key?: K, iter?: Iterable<K, V>) => C,
comparator?: (valueA: C, valueB: C) => number
): V

Inherited from

Iterable#minBy()

Discussion

hitters.minBy(hitter => hitter.avgHits);

Comparison

isSubset()

isSubset(iter: Iterable<any, V>): boolean isSubset(iter: Array<V>): boolean

Inherited from

Iterable#isSubset()

isSuperset()

isSuperset(iter: Iterable<any, V>): boolean isSuperset(iter: Array<V>): boolean

Inherited from

Iterable#isSuperset()

Sequence functions

flip()

Returns a new Iterable.Keyed of the same type where the keys and values have been flipped.

flip(): Iterable.Keyed<V, K>

Inherited from

Iterable.Keyed#flip()

Discussion

Seq({ a: 'z', b: 'y' }).flip() // { z: 'a', y: 'b' }

mapKeys()

Returns a new Iterable.Keyed of the same type with keys passed through a mapper function.

mapKeys<M>(
mapper: (key?: K, value?: V, iter?: Iterable.Keyed<K, V>) => M,
context?: any
): Iterable.Keyed<M, V>

Inherited from

Iterable.Keyed#mapKeys()

Discussion

Seq({ a: 1, b: 2 }) .mapKeys(x => x.toUpperCase()) // Seq { A: 1, B: 2 }

mapEntries()

Returns a new Iterable.Keyed of the same type with entries ([key, value] tuples) passed through a mapper function.

mapEntries<KM, VM>(
mapper: (
entry?: Array<any>,
index?: number,
iter?: Iterable.Keyed<K, V>
) => Array<any>
,
context?: any
): Iterable.Keyed<KM, VM>

Inherited from

Iterable.Keyed#mapEntries()

Discussion

Seq({ a: 1, b: 2 }) .mapEntries(([k, v]) => [k.toUpperCase(), v * 2]) // Seq { A: 2, B: 4 }

This documentation is generated from immutable.d.ts. Pull requests and Issues welcome.