zip

inline fun <B, C> zip(other: Resource<B>, crossinline combine: (A, B) -> C): Resource<C>
fun <B> zip(other: Resource<B>): Resource<Pair<A, B>>
inline fun <B, C, D, E> zip(    b: Resource<B>,     c: Resource<C>,     d: Resource<D>,     crossinline map: (A, B, C, D) -> E): Resource<E>
inline fun <B, C, D, E, G> zip(    b: Resource<B>,     c: Resource<C>,     d: Resource<D>,     e: Resource<E>,     crossinline map: (A, B, C, D, E) -> G): Resource<G>
inline fun <B, C, D, E, F, G, H> zip(    b: Resource<B>,     c: Resource<C>,     d: Resource<D>,     e: Resource<E>,     f: Resource<F>,     crossinline map: (A, B, C, D, E, F) -> G): Resource<G>
inline fun <B, C, D, E, F, G, H> zip(    b: Resource<B>,     c: Resource<C>,     d: Resource<D>,     e: Resource<E>,     f: Resource<F>,     g: Resource<G>,     crossinline map: (A, B, C, D, E, F, G) -> H): Resource<H>
inline fun <B, C, D, E, F, G, H, I> zip(    b: Resource<B>,     c: Resource<C>,     d: Resource<D>,     e: Resource<E>,     f: Resource<F>,     g: Resource<G>,     h: Resource<H>,     crossinline map: (A, B, C, D, E, F, G, H) -> I): Resource<I>
inline fun <B, C, D, E, F, G, H, I, J> zip(    b: Resource<B>,     c: Resource<C>,     d: Resource<D>,     e: Resource<E>,     f: Resource<F>,     g: Resource<G>,     h: Resource<H>,     i: Resource<I>,     crossinline map: (A, B, C, D, E, F, G, H, I) -> J): Resource<J>
inline fun <B, C, D, E, F, G, H, I, J, K> zip(    b: Resource<B>,     c: Resource<C>,     d: Resource<D>,     e: Resource<E>,     f: Resource<F>,     g: Resource<G>,     h: Resource<H>,     i: Resource<I>,     j: Resource<J>,     crossinline map: (A, B, C, D, E, F, G, H, I, J) -> K): Resource<K>


inline fun <B, C, D> zip(    b: Resource<B>,     c: Resource<C>,     crossinline map: (A, B, C) -> D): Resource<D>

Combines two independent resource values with the provided map function, returning the resulting immutable Resource value. The finalizers run in order of left to right by using flatMap under the hood, but zip provides a nicer syntax for combining values that don't depend on each-other.

Useful to compose up to 9 independent resources, see example for more details on how to use in code.

import arrow.fx.coroutines.*

class UserProcessor {
fun start(): Unit = println("Creating UserProcessor")
fun shutdown(): Unit = println("Shutting down UserProcessor")
fun process(ds: DataSource): List<String> =
ds.users().map { "Processed $it" }
}

class DataSource {
fun connect(): Unit = println("Connecting dataSource")
fun users(): List<String> = listOf("User-1", "User-2", "User-3")
fun close(): Unit = println("Closed dataSource")
}

class Service(val db: DataSource, val userProcessor: UserProcessor) {
suspend fun processData(): List<String> = userProcessor.process(db)
}

val userProcessor = resource {
UserProcessor().also(UserProcessor::start)
} release UserProcessor::shutdown

val dataSource = resource {
DataSource().also { it.connect() }
} release DataSource::close

suspend fun main(): Unit {
userProcessor.zip(dataSource) { userProcessor, ds ->
Service(ds, userProcessor)
}.use { service -> service.processData() }
}

See also

to combine resources that rely on each-other.