Hi, with Arrow 1.2.1, would this be the most idio...

# arrow

[Jörg Winter]

Hi,

with Arrow 1.2.1, would this be the most idiomatic way to use high-level concurrency (parZip) and not short-circuiting (by using Either results) and finally, if all results are Either.right, making the insert in some database (in this case) ?
Logging/Aggregating also goes in a separate call to "onLeft", as I think there is no handler for it in "zipOrAccumulate" (?)

suspend fun collectData() {
    parZip(
        { catch { fetchFromHttp1() } },
        { catch { fetchFromHttp2() } },
        { catch { fetchFromHttp3() } }
    ) { result1, result2, result3 ->
        val result = zipOrAccumulate(result1, result2, result3) { r1, r2, r3 ->
            dbRepository.save(Entity(r1, r2, r3))
        }
        result.onLeft {
            log.error(it.map { it.message }.joinToString("\n", "\n"))
        }
    }
}

[simon.vergauwen]

Hey @Jörg Winter,

There is also parZipOrAccumulate.

suspend fun collectData() {
    parZipOrAccumulate(
        { catch { fetchFromHttp1() }.bind() },
        { catch { fetchFromHttp2() }.bind() },
        { catch { fetchFromHttp3() }.bind() }
    ) { r1, r2, r3 ->
      dbRepository.save(Entity(r1, r2, r3))
        .onLeft {
          log.error(it.map { it.message }.joinToString("\n", "\n"))
        }
    }
}

[Jörg Winter]

I am using 1.2.1 but I can not use that construct, seems to require transform fn as first param, and bind is deprecated (?)

[Alejandro Serrano.Mena]

oh, weird, bind should never be deprecated (unless used in Effect)

[Jörg Winter]

parZipOrAccumulate is not even suggested by Intellij in my code, so I am not sure if I am in the necessary context maybe…

[simon.vergauwen]

Aha.. it's defined on Raise<E>. https://apidocs.arrow-kt.io/arrow-fx-coroutines/arrow.fx.coroutines/par-zip-or-accumul[…]A,%20B,%20C,%20D,%20F,%20G,%20H,%20I,%20J)%20-%3E%20K):%20K

I think you need to call:

suspend fun collectData() = either {
    parZipOrAccumulate(
        { catch { fetchFromHttp1() }.bind() },
        { catch { fetchFromHttp2() }.bind() },
        { catch { fetchFromHttp3() }.bind() }
    ) { r1, r2, r3 ->
      dbRepository.save(Entity(r1, r2, r3))
        .onLeft {
          log.error(it.map { it.message }.joinToString("\n", "\n"))
        }
    }
}

[simon.vergauwen]

There is 1 bind that has been deprecated but it's from a long long time ago. There was an object ResultEffect from the pre-1.x DSLs, that accidentally leaked into the public API 😕 Since it's an object it can be top-level imported, and it's basically Either<Throwable, A>#getOrThrow.

We probably should've changed it to HIDDEN in 1.2.x

[Jörg Winter]

trying your latest suggestion gives me:

[Jörg Winter]

or this, without the type parameters:

[simon.vergauwen]

Could you provide a small snippet with imports?

[Jörg Winter]

import arrow.core.Either.Companion.catch
import arrow.core.raise.either
import arrow.fx.coroutines.parZipOrAccumulate
import org.springframework.stereotype.Service

@Service
class DataCollectionService(
) {

    suspend fun collectAndSave() {
        either {
            parZipOrAccumulate(
                { catch { fetchSomeHttp1() }.bind() },
                { catch { fetchSomeHttp2() }.bind() },
                { catch { fetchSomeHttp3() }.bind() }
            ) { result1: String, result2: String, result3: String ->
                // TODO what ever with results
            }
        }
    }

    private fun fetchSomeHttp1(): String {
        return "r1"
    }

    private fun fetchSomeHttp2(): String {
        return "r2"
    }

    private fun fetchSomeHttp3(): String {
        return "r3"
    }

}

[Jörg Winter]

..in which

[simon.vergauwen]

Ah, ye it's not able to automatically infer the type 😞 So I think you need, either<Throwable, A> { }

[Jörg Winter]

yep.. almost. I had to provide a transformation as 1st parameter also, now it works nicely:

either<Throwable, Unit> {
    parZipOrAccumulate(
        { throwable, throwable2 -> RuntimeException(throwable.message + throwable2.message) },
        { catch { fetchSomeHttp1() }.bind() },
        { catch { fetchSomeHttp2() }.bind() },
        { catch { fetchSomeHttp3() }.bind() }
    ) { result1, result2, result3 ->
        // some side-effect of type Unit
    }
}.onLeft { left -> log.error(left.message) }

🎉

[Jörg Winter]

Thanks

[Jörg Winter]

definetly nicer than my initial attempt

[simon.vergauwen]

Oh, I'm sorry 😄 If you put either<NonEmptyList<Throwable>, Unit> { } you don't need to extra lambda,
but if you want to stick to throwable that is better. Although I'd use throwable.apply { addSuppressed(throwable2) }