clear up some of the debt …

and maybe support multi-platform ?

🙂

That would be tough for Java imports

it looks like major rewrites to me.

Hence the 3.0 😉

I am not too sure about many classes such as FuelManager and other.

too large to port it over.

wow.. multiplatform? that owuld be awesome

i currently use ktor for http clients on other platforms but it has a bit many dependencies

it kinda forces you to use coroutine too

i really don't mind coroutines, flows for example are onf of my new fav things

Google encourages Android developers to use coroutines too.

https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-test/ interesting

I am planning to push the WIP Corountines-based branch that needs to fix some area like response-related functions.

👍

anything i can help with right now for the coroutines rewrite?

it have been slowly

Android Studio really hate kotlin script. 😞

@kittinunf Four different await types of Functions with T, ResponseOf, Result<>, and ResponseResultOf

are we are moving to just ResponseResultOf?

yea I think so, I think we should try to minimize our public API somehow

client can save

Request

if they want to ….

so it makes sense to return just

Response

and

Result

in my opinion

That would be like Pair?

i hope this won't make code too ugly.. i liked being able to just chain calls without saving it to a request, then executing but simplifying the public API and all the duplicate implementations to match seems more important

@Nikky it will be just one function to call

"/get".httpGet().awaitResponseOf()

or different name

i guess i am jsut used to this pattern:

val (request, response, result) = url.httpGet()
            .awaitObjectResponseResult(kotlinxDeserializerOf(loader = Type.serializer(), json = json))
        return when (result) {
            is Result.Success -> result.value
            is Result.Failure -> {
                logger.error("failed request")
                logger.error("url: $url")
                logger.error("cUrl: ${request.cUrlString()}")
                logger.error("response: $response")
                logger.error(result.error.exception) { result.error }
                throw result.error.exception
            }
        }

rethrowing might not be the wisest choice but thats not really what matters i guess i could make this same thing happen wit ha inline function and lamdda to configure the request or so.. to avoid copypasting the same stuff all over the place