sttp | The Scala HTTP client | HTTP library

I'm not familiar with Reactive Streams, but it looks like they made some changes during the patch version and moved classes around in 1.0.3. See Reactive Streams 1.0.3 is here!

When we released 1.0.2, we shipped a compatibility/conversion library to seamlessly convert between the java.util.concurrent.Flow and the org.reactivestreams namespaces—in 1.0.3 these adapters are instead included in the main 1.0.3 jar.

How can I find which of my dependencies are importing them?

If you're using the latest sbt 1.5.4, it has Johannes's dependency graph plugin built-in by default, so you can run dependencyTree from sbt shell:

You will need to change the encoding of the path segments in the parsed URI to a more strict one:

The decoding is delegated to Circe. What is described in the documentation is only derivation of Schemas - which are necessary for documentation.

Hence, I'd be looking for the cause of the error by checking if you have the proper Decoder in scope, and checking what happens if you try to decode an example value directly using circe.

Your error messages is associated with each other. First error tells us that compiler couldn't find object SttpBackends which has field of SttpBackend. The second one tells us that compiler couldn't find implicit backend: SttpBackend for constructing FutureSttpClient. It requires two implicits: SttpBackend and ExecutionContext.

You can create Promise, complete it when Observable is completed by .doOnComplete

And await it in the main thread.

The problems comes from the fact that with the sttp backend open, you are computing a list of tasks to be performed - the List[Task[Response[Either[String, String]]]], but you are not running them. Hence, we need to sequence running these tasks, before the backend closes.

The key thing to do here is to create a single description of a task, that runs all of these requests while the backend is still open.

Once you compute data (which itself is a task - a description of a computation - which, when run, yield a list of tasks - also descriptions of computations), we need to convert this into a single, non-nested Task. This can be done in a variety of ways (e.g. using simple sequencing), but in your case this will be using the Observable:

So if i have understood right you have types like this:

Thanks to the help of Travis Brown and the circe Gitter community for helping me figure this one out.

I'm quoting Travis here:

it would be better to build up the instance you need to parse the top-level JSON object compositionally… i.e. have a Decoder[User] that only decodes a single user JSON object, and then use Decoder[List[User]].at("data") or something similar to decode the top-level JSON object containing the data field with the JSON array.

I have ended up with an implementation that looks something like:

You can use monix.reactive.Observable like this