arrow-fx-coroutines/arrow.fx.coroutines/Resource/zip

zip

inline fun <B, C> zip(other: Resource, crossinline combine: (A, B) -> C): Resource<C>

fun zip(other: Resource): Resource<Pair<A, B>>

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

inline fun <B, C, D, E, F, G> zip( b: Resource, 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, 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, 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, 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

inline fun <B, C, D, E, F, G, H, I, J> zip( b: Resource, c: Resource<C>, d: Resource<D>, e: Resource<E>, f: Resource<F>, g: Resource<G>, h: Resource<H>, i: Resource, 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, c: Resource<C>, d: Resource<D>, e: Resource<E>, f: Resource<F>, g: Resource<G>, h: Resource<H>, i: Resource, 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, 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)
}

//sampleStart
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() }
}
//sampleEnd

zip

See also