arrow-core-data / 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: Map<K, B>, f: (Map<K, B>, Entry<K, A>) -> Map<K, B>): Map<K, B>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: Map<K, B>, f: (Entry<K, A>, Map<K, B>) -> Map<K, B>): Map<K, B>fun <K, A, B> Map<K, A>.~~foldRight~~(b: B, f: (Entry<K, A>, B) -> B): B |
| getOption | fun <K, A> Map<K, A>.~~getOption~~(k: K): Option<A> |
| k | fun <K, A> Map<K, A>.~~k~~(): MapK<K, A> |
| 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> |
| plus | operator fun <K, V> Map<out K, V>.~~plus~~(tuple: Tuple2<K, V>): Map<K, V>operator fun <K, V> Map<out K, V>.~~plus~~(tuples: Iterable<Tuple2<K, V>>): Map<K, V>operator fun <K, V> Map<out K, V>.~~plus~~(tuples: Array<out Tuple2<K, V>>): Map<K, V>operator fun <K, V> Map<out K, V>.~~plus~~(tuples: Sequence<Tuple2<K, V>>): Map<K, V> |
| 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 parts fun <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> |