arrow-core / arrow.core / kotlin.collections.Map

Extensions for kotlin.collections.Map

align Combines two structures by taking the union of their shapes and using Ior to hold the elements.fun <K, A, B> Map<K, A>.align(b: Map<K, B>): Map<K, Ior<A, B>>
Combines two structures by taking the union of their shapes and combining the elements with the given function.fun <K, A, B, C> Map<K, A>.align(b: Map<K, B>, fa: (Entry<K, Ior<A, B>>) -> C): Map<K, C>
combine fun <K, A> Map<K, A>.combine(SG: Semigroup<A>, b: Map<K, A>): Map<K, A>
filterIsInstance Returns a Map containing all elements that are instances of specified type parameter R.fun <K, R> Map<K, *>.filterIsInstance(): Map<K, R>
filterMap fun <K, A, B> Map<K, A>.filterMap(f: (A) -> B?): Map<K, B>
flatMap fun <K, A, B> Map<K, A>.flatMap(f: (Entry<K, A>) -> Map<K, B>): Map<K, B>
foldLeft fun <K, A, B> Map<K, A>.foldLeft(b: B, f: (B, Entry<K, A>) -> B): B
foldRight fun <K, A, B> Map<K, A>.foldRight(b: B, f: (Entry<K, A>, B) -> B): B
padZip Align two structures as in zip, but filling in blanks with null.fun <K, A, B> Map<K, A>.padZip(other: Map<K, B>): Map<K, Pair<A?, B?>>fun <K, A, B, C> Map<K, A>.padZip(other: Map<K, B>, fa: (K, A?, B?) -> C): Map<K, C>
salign aligns two structures and combine them with the given Semigroups ‘+’fun <K, A> Map<K, A>.salign(SG: Semigroup<A>, other: Map<K, A>): Map<K, A>
sequenceEither fun <K, E, A> Map<K, Either<E, A>>.sequenceEither(): Either<E, Map<K, A>>
sequenceValidated fun <K, E, A> Map<K, Validated<E, A>>.sequenceValidated(semigroup: Semigroup<E>): Validated<E, Map<K, A>>
traverseEither fun <K, E, A, B> Map<K, A>.traverseEither(f: (A) -> Either<E, B>): Either<E, Map<K, B>>
traverseValidated fun <K, E, A, B> Map<K, A>.traverseValidated(semigroup: Semigroup<E>, f: (A) -> Validated<E, B>): Validated<E, Map<K, B>>
unalign Splits a union into its component parts.fun <K, A, B> Map<K, Ior<A, B>>.unalign(): Pair<Map<K, A>, Map<K, B>>
after applying the given function, splits the resulting union shaped structure into its components partsfun <K, A, B, C> Map<K, C>.unalign(fa: (Entry<K, C>) -> Ior<A, B>): Pair<Map<K, A>, Map<K, B>>
unzip Unzips the structure holding the resulting elements in an Pairfun <K, A, B> Map<K, Pair<A, B>>.unzip(): Pair<Map<K, A>, Map<K, B>>
After applying the given function unzip the resulting structure into its elements.fun <K, A, B, C> Map<K, C>.unzip(fc: (Entry<K, C>) -> Pair<A, B>): Pair<Map<K, A>, Map<K, B>>
void fun <K, A> Map<K, A>.void(): Map<K, Unit>
widen fun <K, B, A : B> Map<K, A>.widen(): Map<K, B>
zip Combines to structures by taking the intersection of their shapes and using Pair to hold the elements.fun <K, A, B> Map<K, A>.zip(other: Map<K, B>): Map<K, Pair<A, B>>
Combines to structures by taking the intersection of their shapes and combining the elements with the given function.fun <Key, A, B, C> Map<Key, A>.zip(other: Map<Key, B>, map: (Key, A, B) -> C): Map<Key, C>fun <Key, B, C, D, E> Map<Key, B>.zip(c: Map<Key, C>, d: Map<Key, D>, map: (Key, B, C, D) -> E): Map<Key, E>
fun <Key, B, C, D, E, F> Map<Key, B>.zip(c: Map<Key, C>, d: Map<Key, D>, e: Map<Key, E>, map: (Key, B, C, D, E) -> F): Map<Key, F>
fun <Key, B, C, D, E, F, G> Map<Key, B>.zip(c: Map<Key, C>, d: Map<Key, D>, e: Map<Key, E>, f: Map<Key, F>, map: (Key, B, C, D, E, F) -> G): Map<Key, G>
fun <Key, B, C, D, E, F, G, H> Map<Key, B>.zip(c: Map<Key, C>, d: Map<Key, D>, e: Map<Key, E>, f: Map<Key, F>, g: Map<Key, G>, map: (Key, B, C, D, E, F, G) -> H): Map<Key, H>
fun <Key, B, C, D, E, F, G, H, I> Map<Key, B>.zip(c: Map<Key, C>, d: Map<Key, D>, e: Map<Key, E>, f: Map<Key, F>, g: Map<Key, G>, h: Map<Key, H>, map: (Key, B, C, D, E, F, G, H) -> I): Map<Key, I>
fun <Key, B, C, D, E, F, G, H, I, J> Map<Key, B>.zip(c: Map<Key, C>, d: Map<Key, D>, e: Map<Key, E>, f: Map<Key, F>, g: Map<Key, G>, h: Map<Key, H>, i: Map<Key, I>, map: (Key, B, C, D, E, F, G, H, I) -> J): Map<Key, J>
fun <Key, B, C, D, E, F, G, H, I, J, K> Map<Key, B>.zip(c: Map<Key, C>, d: Map<Key, D>, e: Map<Key, E>, f: Map<Key, F>, g: Map<Key, G>, h: Map<Key, H>, i: Map<Key, I>, j: Map<Key, J>, map: (Key, B, C, D, E, F, G, H, I, J) -> K): Map<Key, K>
fun <Key, B, C, D, E, F, G, H, I, J, K, L> Map<Key, B>.zip(c: Map<Key, C>, d: Map<Key, D>, e: Map<Key, E>, f: Map<Key, F>, g: Map<Key, G>, h: Map<Key, H>, i: Map<Key, I>, j: Map<Key, J>, k: Map<Key, K>, map: (Key, B, C, D, E, F, G, H, I, J, K) -> L): Map<Key, L>

Do you like Arrow?

Arrow Org
<