```IO.parMapN(<http://Dispatchers.IO|Dispatchers.I...

# arrow

[pakoito]

IO.parMapN(<http://Dispatchers.IO|Dispatchers.IO>, ioS1, ioS2, ioS3) { a, b, c ->
  Either.map(a,b,c) { aa, bb, cc -> ... }
}

[Mark Fisher]

Thanks Paco. What is async about the unsafeRunAsync method then? I couldn't see any difference between it and unsafeRunSync

[pakoito]

Sync blocks the thread, Async doesn’t. But if your code is run on the current thread anyway, they’ll work similarily

[Mark Fisher]

I couldn't find an Either.map method that worked like this, in the end, the following worked:

@Test
    fun `io module test`() {
        val ioModule = Module(IO.async())
        ioModule.run {
            val ioS1 = repository.byId(u1).fix().attempt()
            val ioS2 = repository.byId(u2).fix().attempt()
            val ioS3 = repository.byId(u3).fix().attempt()

            val contextIO = IO.dispatchers().io()
            val contextS = <http://Schedulers.io|Schedulers.io>().asCoroutineContext()
            IO.parMapN(contextS, ioS1, ioS2, ioS3) { a, b, c ->
                ioInfo(a)
                ioInfo(b)
                ioInfo(c)
            }.unsafeRunSync()
        }
    }

[Mark Fisher]

private val ioInfo: (Either<Throwable, Int>) -> Unit = { result ->
        when (result) {
            is Either.Right -> <http://logger.info|logger.info> { "got stock: ${result.b}" }
            is Either.Left -> logger.error { "error: ${result.a}" }
        }
    }

[pakoito]

you’re side-effecting on the when, I would instead wrap it on an IO operation

[pakoito]

like this

[pakoito]

fun IO<A>.logError(): IO<A> =
  attempt().flatMap { 
    it.fold(
      { IO { logger.error { "error: $it" } }.flatMap { raiseError(it) } }, 
      { IO.just(it).flatTap { IO { <http://logger.info|logger.info> { "got stock: $it" } } } }
    ) 
  }

and then

val ioS1 = repository.byId(u1).fix().logError()

[pakoito]

even better, make <http://logger.info|logger.info> a suspend function

[pakoito]

to indicate it’s a side-effect

[Mark Fisher]

Very nice. In this case it's just a test class, so I just wanted to dump the results of the completed threads, so don't really mind it being side-effecty.

[Mark Fisher]

Coming back to your original code using Either.map() I found a map function on applicative(), so could do:

Either.applicative<Throwable>().map(a, b) { (aa, bb) ->
    <http://logger.info|logger.info> { "T2 result: $aa, $bb"}
}

but I have to know that only 2 of the results were valid, one wasn't (it was an error). Using the triple version doesn't print anything (i.e. map(a, b, c)). Is there a way to map over all values without knowing how many were correct?

[pakoito]

map only works with 3 of them

[pakoito]

sorry

[pakoito]

I mean if all three of them are correct

[pakoito]

if you want to side-effect on errors, or do something with them, you have to use handleError , handleErrorWith or even mapLeft

[Mark Fisher]

Thanks. I'm learning lots. I found I can do Either.applicative<Throwable>().tupled(a, b, c).fix() which also combines into a left if there's an error too.

[pakoito]

yep, it’s a specialized Either.map 😄