Could you tell me how to convert from

List<Either<A,B>>

to

Either<A,List<B>>

. until 0.8.1, I used

ListK.sequence

.

val src = List<Either<A,B>>
// 0.8.1
// import arrow.data.sequence
val result: Either<A, List<B>> = src.k().sequence(Either.applicative()).fix()

// 0.8.2
// which is the preferred ? or another solution?

// use ListK#traverse
val result: Either<A, List<B>> = src.k().traverse(Either.applicative(), ::identity).fix()

// import arrow.instances.listk.traverse.sequence
// import arrow.instances.either.functor.map
val result: Either<A, List<B>> = src.k().sequence(Either.applicative()).map{ it.fix() }

need to .map { it.fix() }.fix() so you get an Either not a Kind<EitherPartialOf....>

I'd guess the second, but it's weird that it changed to take away the sequence, and force you to .fix your way out of the Kinds

oh, I used

arrow.instances.either.functor.map

, so don’t need to map{it.fix()}.fix() thx your pointing out. I edited my post.

Heads up, In 0.9.0 snapshot it's extensions instead of instances

ideally it'd be the one with

import arrow.instances.listk.traverse.sequence

and it wouldn't return a

Kind

but we're where we are at codegen, so it's up to you to pick 😄

This is perhaps the most complete answer https://www.reddit.com/r/scala/comments/8ygjcq/can_someone_explain_to_me_the_benefits_of_io/e2jfrg8/

nice

the "problem" with arrow is that when you start to pull the yarn for one convenience function, you start taking more…

I'm completely lost here, there are references to a 0.9.0 but not published, references to binding all over the documentation, but no modules seem to have it. References to modules that are not published…

building from git because the bindings are missing from 0.8.2… BUILD SUCCESSFUL in 23m 59s

Ok it starts to work a bit better

@raulraja So regarding what you proposed, I cannot use it the way you wrote it, because httpClient.call is a restricted suspended function

tried with IO.async().run , doesn't work either. The full error is: Error:(79, 32) Kotlin: Restricted suspending functions can only invoke member or extension suspending functions on their restricted coroutine scope

fun worksFromDoi(doi: String): IO<WorksResponse> =
        binding {
            IO { calcDelay() }.bind()
            DeferredK<HttpClientCall> {
                httpClient.call("$API_URL/works/$doi") {
                    method = HttpMethod.Get
                }
            }.map { call ->
                IO.async().delay {
                    updateDelayFromHeaderData(
                        call.response.headers.get("X-Rate-Limit-Limit"),
                        call.response.headers.get("X-Rate-Limit-Interval")
                    )
                }
                IO.async().delay { updateLastQueryTime() }

                when (call.response.status.value) {
                    200 -> IO<WorksResponse> {
                        DeferredK<WorksResponse> {
                            worksAdapter.fromJson(
                                call.response.readText()
                            ) ?: WorksResponse(status = "failed-locally")
                        }.handleError { WorksResponse(status = "failed-locally") }.getCompleted()
                    }
                    404 -> IO.raiseError<WorksResponse>(NonExistentReference)
                    else -> IO.raiseError<WorksResponse>(UnManagedReturnCode(call.response.status.value))
                }

            }.handleError { IO.raiseError<WorksResponse>(DecodingError) }.value().getCompleted()

        }.fix().unsafeRunSync()

That's where I am stuck for now when I run that, I get a Exception in thread "main" java.lang.IllegalStateException: This job has not completed yet

I get that getCompleted is not what I should use but I can't find any way to return a WorksResponse for the 200 . so at least I wanted something that compile

You can turn the async result of the http client into an IO value with IO.async

Takes an async callback and gives you back an IO value that you can keep on composing

It's part of the Async type class which is what you would use in this case if you were working with type classes instead of IO directly

@bjonnh I can help you refactor it if you provide a github project or gist that compiles where I don't have to mock those internals.

Working on that

Hi, guys. You mentioned arrow playground (kotlin, not swift) few days ago, can you give me a link to play around? That would be a cool thing to prototype in 🙂

This? https://pl.kotl.in/

Ah

The playgrounds are actually embedded in the arrow docs in their correspondent functions https://arrow-kt.io/docs/apidocs/arrow-core-extensions/arrow.core.extensions.id.functor/arrow.-kind/map.html

We started documenting this way a couple of months ago and we are making progress toward documenting the entirety of Arrow as Kdoc with playable snippets that hit that server I linked above.

Trying to bring more Arrow in that project. Why does work return IO<Any> and not IO<Obj> ?

import <http://arrow.effects.IO|arrow.effects.IO>
import arrow.effects.extensions.io.monad.binding

data class Obj(val a: String)

sealed class KnownError : RuntimeException()
object DecodingError : KnownError()


fun apiCall(s: String) = IO {
    "Some string"
}

fun convert(s: String): Obj? {
   return Obj("Some other output")
}

fun work(s: String): IO<Obj> =
    IO.run {
        binding {
            val output = apiCall(s)

            val obj = convert(output.bind())

            if (obj != null)
                obj
            else
                raiseError<Obj>(DecodingError)

        }
    }