Hi, does Arrow have function like `(List<IO<...

# arrow

[genovich]

Hi, does Arrow have function like (List<IO<T>>) -> IO<T> which runs each IO in List<IO<T>> in parallel and waiting for the first result?

[genovich]

Just found the solution:

reduce { acc, io -> 
        coroutineContext.raceN(acc, io).map { it.fold(::identity, ::identity) }
    }

but maybe there is may be better solution

[simon.vergauwen]

@genovich there is no such method out of the box. There is a slight improvement over your snippet which uses never and fold instead. It uses an IO that never finishes as an empty value for the list. Such that emptyList().race() would result in a race that never finishes, instead of blowing up like reduce.

fun <A> List<IO<A>>.race(): IO<A> =
  foldRight(never<A>()) { acc, io 
     IO.raceN(acc, io)
       .map { it.fold(::identity, ::identity) }
  }

Keep in mind that the `IO`s are scheduled in order, so the once scheduled first might have a slight advantage over the last onces being scheduled. Which might also depend on in which coroutineContext you launch it etc.

[genovich]

Thanks!

[julian]

Wow, that's a really cool way to do it! ... using never @simon.vergauwen

[genovich]

Is it ok to define monoid and use list.fold(monoid) in this case?

[simon.vergauwen]

Yes, that's definitely possible and I think it will be lawfull as well.
It would need a special testing strategy tho since Monoid#empty is never finishing

[simon.vergauwen]

https://github.com/arrow-kt/arrow-core/blob/master/arrow-core-test/src/main/kotlin/arrow/core/test/laws/MonoidLaws.kt#L35