Removed forgotten implicit instances

Author: jendakol

README.md

@@ -159,9 +159,8 @@ For full list of options please see [reference.conf](core/src/main/resources/ref
 ### Scala usage
 
 The Scala API is now _finally tagless_ (read more e.g. [here](https://www.beyondthelines.net/programming/introduction-to-tagless-final/)) -
-you can change the type it works with by specifying it when creating the _connection_. In general you have to provide
-`cats.arrow.FunctionK[Task, A]` and `cats.arrow.FunctionK[A, Task]` however there are some types supported out-of-the-box by just importing
-`import com.avast.clients.rabbitmq._` (`scala.util.Try`, `scala.concurrent.Future` and `monix.eval.Task` currently).
+you can change the type it works with by specifying it when creating the _connection_. You have to provide`cats.arrow.FunctionK[Task, A]`
+and `cats.arrow.FunctionK[A, Task]` when creating new connection.
 
 The Scala API uses types-conversions for both consumer and producer, that means you don't have to work directly with `Bytes` (however you
 still can, if you want) and you touch only your business class which is then (de)serialized using provided converter.
@@ -185,6 +184,8 @@ val blockingExecutor: ExecutorService = Executors.newCachedThreadPool()
 
 val monitor: Monitor = ???
 
+implicit val fk: FunctionK[Task, Task] = cats.arrow.FunctionK.id
+
 // here you create the connection; it's shared for all producers/consumers amongst one RabbitMQ server - they will share a single TCP connection
 // but have separated channels
 // if you expect very high load, you can use separate connections for each producer/consumer, but it's usually not needed
@@ -245,26 +246,6 @@ There are multiple options where to get the _converter_ (it's the same case for
     1. Remove explicit type completely (not recommended)
     1. Make the explicit type more general (`DeliveryConverter` instead of `JsonDeliveryConverter` in this case)
 
-1. Cryptic errors  
-    It may happen you have everything configured "correctly" and the compiler still reports an error, for example
-    ```scala
-    def rabbitConnection(): RabbitMQConnection[Future] = RabbitMQConnection.fromConfig[Future](rabbitProperties, blocking)
-    ```
-    can give you something like:
-    ```
-    Error:(22, 99) could not find implicit value for evidence parameter of type com.avast.clients.rabbitmq.FromTask[scala.concurrent.Future]
-    Error occurred in an application involving default arguments.
-      def rabbitConnection(): RabbitMQConnection[Future] = RabbitMQConnection.fromConfig[Future](rabbitProperties, blocking)
-    Error:(22, 99) not enough arguments for method fromConfig: (implicit evidence$3: com.avast.clients.rabbitmq.FromTask[scala.concurrent.Future], implicit evidence$4: com.avast.clients.rabbitmq.ToTask[scala.concurrent.Future])com.avast.clients.rabbitmq.DefaultRabbitMQConnection[scala.concurrent.Future].
-    Unspecified value parameters evidence$3, evidence$4.
-    Error occurred in an application involving default arguments.
-      def rabbitConnection(): RabbitMQConnection[Future] = RabbitMQConnection.fromConfig[Future](rabbitProperties, blocking)
-    ```
-    This is caused by absence of `ExecutionContext` which makes `def fkToFuture(implicit ec: ExecutionContext): FromTask[Future]` impossible to
-    use (unfortunately compiler won't say that).  
-    Please bear in mind there is nothing this library could do to help you in this case - there is no way to provide any hint. However there are
-    some compiler plugins available which may help you to prevent such situations, e.g. [Splain](https://github.com/tek/splain).
-
 ### Java usage
 
 The Java api is placed in subpackage `javaapi` (but not all classes have their Java counterparts, some have to be imported from Scala API,

core/src/main/scala/com/avast/clients/rabbitmq/javaapi/RabbitMQJavaConnection.scala

@@ -3,10 +3,13 @@ package com.avast.clients.rabbitmq.javaapi
 import java.io.IOException
 import java.util.concurrent.{CompletableFuture, ExecutorService}
 
+import cats.arrow.FunctionK
 import com.avast.clients.rabbitmq.RabbitMQConnection.DefaultListeners
 import com.avast.clients.rabbitmq.{ChannelListener, ConnectionListener, ConsumerListener, RabbitMQConnection => ScalaConnection}
 import com.avast.metrics.api.Monitor
 import com.typesafe.config.Config
+import monix.eval.Task
+import monix.execution.Scheduler
 
 import scala.concurrent.{ExecutionContext, Future}
 
@@ -99,6 +102,14 @@ object RabbitMQJavaConnection {
 
       implicit val ec: ExecutionContext = ExecutionContext.fromExecutorService(executorService)
 
+      implicit val fkToFuture: FromTask[Future] = new FunctionK[Task, Future] {
+        override def apply[A](fa: Task[A]): Future[A] = fa.runAsync(Scheduler(ec))
+      }
+
+      implicit val fkFromFuture: ToTask[Future] = new FunctionK[Future, Task] {
+        override def apply[A](fa: Future[A]): Task[A] = Task.fromFuture(fa)
+      }
+
       new RabbitMQJavaConnectionImpl(
         ScalaConnection
           .fromConfig[Future](

core/src/main/scala/com/avast/clients/rabbitmq/rabbitmq.scala

@@ -1,18 +1,14 @@
 package com.avast.clients
 
 import cats.arrow.FunctionK
-import cats.{~>, Monad}
+import cats.~>
 import com.avast.bytes.Bytes
 import com.avast.clients.rabbitmq.api._
 import com.rabbitmq.client.{RecoverableChannel, RecoverableConnection}
 import mainecoon.FunctorK
 import monix.eval.Task
-import monix.execution.{ExecutionModel, Scheduler}
 
-import scala.concurrent.duration.Duration
-import scala.concurrent.{Await, ExecutionContext, Future}
 import scala.language.higherKinds
-import scala.util.Try
 
 package object rabbitmq {
   private[rabbitmq] type ServerConnection = RecoverableConnection
@@ -24,29 +20,6 @@ package object rabbitmq {
   type FromTask[A[_]] = FunctionK[Task, A]
   type ToTask[A[_]] = FunctionK[A, Task]
 
-  implicit val fkTask: FunctionK[Task, Task] = FunctionK.id
-
-  implicit def fkToFuture(implicit ec: ExecutionContext): FromTask[Future] = new FunctionK[Task, Future] {
-    override def apply[A](fa: Task[A]): Future[A] = fa.runAsync(Scheduler(ec))
-  }
-
-  implicit def fkToTry(implicit ec: ExecutionContext): FromTask[Try] = new FunctionK[Task, Try] {
-    override def apply[A](task: Task[A]): Try[A] = Try {
-      task.coeval(Scheduler(ec).withExecutionModel(ExecutionModel.SynchronousExecution))() match {
-        case Right(a) => a
-        case Left(fa) => Await.result(fa, Duration.Inf)
-      }
-    }
-  }
-
-  implicit val fkFromFuture: ToTask[Future] = new FunctionK[Future, Task] {
-    override def apply[A](fa: Future[A]): Task[A] = Task.fromFuture(fa)
-  }
-
-  implicit val fkFromTry: ToTask[Try] = new FunctionK[Try, Task] {
-    override def apply[A](fa: Try[A]): Task[A] = Task.fromTry(fa)
-  }
-
   implicit def producerFunctorK[A]: FunctorK[RabbitMQProducer[?[_], A]] = new FunctorK[RabbitMQProducer[?[_], A]] {
     override def mapK[F[_], G[_]](af: RabbitMQProducer[F, A])(fToG: ~>[F, G]): RabbitMQProducer[G, A] =
       (routingKey: String, body: A, properties: Option[MessageProperties]) => {
@@ -56,18 +29,6 @@ package object rabbitmq {
       }
   }
 
-  /*
-   * This is needed because last version of Monix depends on older cats than we have. It does not cause problems in general but we're unable
-   * to use `monix-cats` extension since it's missing some trait removed from Cats.
-   */
-  private[rabbitmq] implicit val taskMonad: Monad[Task] = new Monad[Task] {
-    override def pure[A](x: A): Task[A] = Task.now(x)
-
-    override def flatMap[A, B](fa: Task[A])(f: A => Task[B]): Task[B] = fa.flatMap(f)
-
-    override def tailRecM[A, B](a: A)(f: A => Task[Either[A, B]]): Task[B] = Task.tailRecM(a)(f)
-  }
-
   private[rabbitmq] implicit class DeliveryOps[A](val d: Delivery[A]) extends AnyVal {
     def mapBody[B](f: A => B): Delivery[B] = d match {
       case ok: Delivery.Ok[A] => ok.copy(body = f(ok.body))

core/src/test/scala/com/avast/clients/rabbitmq/DefaultRabbitMQProducerTest.scala

@@ -1,6 +1,7 @@
 package com.avast.clients.rabbitmq
 
 import com.avast.bytes.Bytes
+import com.avast.clients.rabbitmq.TestImplicits._
 import com.avast.clients.rabbitmq.api.MessageProperties
 import com.avast.metrics.scalaapi.Monitor
 import com.rabbitmq.client.AMQP
@@ -15,8 +16,8 @@ import org.scalatest.mockito.MockitoSugar
 
 import scala.concurrent.Future
 import scala.util.Random
-
 class DefaultRabbitMQProducerTest extends FunSuite with MockitoSugar with Eventually with ScalaFutures {
+
   test("basic") {
     val exchangeName = Random.nextString(10)
     val routingKey = Random.nextString(10)

core/src/test/scala/com/avast/clients/rabbitmq/DefaultRabbitMQPullConsumerTest.scala

@@ -21,8 +21,9 @@ import org.scalatest.time.{Seconds, Span}
 
 import scala.concurrent.Future
 import scala.util.Random
-
+import TestImplicits._
 class DefaultRabbitMQPullConsumerTest extends FunSuite with MockitoSugar with ScalaFutures with Eventually {
+
   test("should ACK") {
     val messageId = UUID.randomUUID().toString
 

core/src/test/scala/com/avast/clients/rabbitmq/LiveTest.scala

@@ -4,6 +4,7 @@ import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.{CountDownLatch, Executors, Semaphore, TimeUnit}
 
 import com.avast.bytes.Bytes
+import com.avast.clients.rabbitmq.TestImplicits._
 import com.avast.clients.rabbitmq.api._
 import com.avast.clients.rabbitmq.extras.PoisonedMessageHandler
 import com.avast.clients.rabbitmq.extras.format.JsonDeliveryConverter

core/src/test/scala/com/avast/clients/rabbitmq/TestImplicits.scala

@@ -0,0 +1,35 @@
+package com.avast.clients.rabbitmq
+import cats.arrow.FunctionK
+import monix.eval.Task
+import monix.execution.{ExecutionModel, Scheduler}
+
+import scala.concurrent.duration.Duration
+import scala.concurrent.{Await, ExecutionContext, Future}
+import scala.util.Try
+
+object TestImplicits {
+  implicit val fkTask: FunctionK[Task, Task] = FunctionK.id
+
+  implicit def fkTaskToFuture(implicit ec: ExecutionContext): FromTask[Future] = new FunctionK[Task, Future] {
+    override def apply[A](fa: Task[A]): Future[A] = fa.runAsync(Scheduler(ec))
+  }
+
+  implicit val fkTaskFromFuture: ToTask[Future] = new FunctionK[Future, Task] {
+    override def apply[A](fa: Future[A]): Task[A] = Task.fromFuture(fa)
+  }
+
+  def fkTaskToTry(timeout: Duration)(implicit ec: ExecutionContext): FromTask[Try] = new FunctionK[Task, Try] {
+    override def apply[A](task: Task[A]): Try[A] = Try {
+      task.coeval(Scheduler(ec).withExecutionModel(ExecutionModel.SynchronousExecution))() match {
+        case Right(a) => a
+        case Left(fa) => Await.result(fa, timeout)
+      }
+    }
+  }
+
+  implicit def fkTaskToTry(implicit ec: ExecutionContext): FromTask[Try] = fkTaskToTry(Duration.Inf)
+
+  implicit val fkTaskFromTry: ToTask[Try] = new FunctionK[Try, Task] {
+    override def apply[A](fa: Try[A]): Task[A] = Task.fromTry(fa)
+  }
+}

extras/README.md

@@ -31,6 +31,10 @@ Republish(Map(PoisonedMessageHandler.RepublishCountHeaderName -> 1.asInstanceOf[
 ```
 Note you can provide your custom poisoned-message handle action:
 ```scala
+
+implicit val fkFromTask: FunctionK[Task, Future] = ???
+implicit val fkToTask: FunctionK[Future, Task] = ???
+
 val newReadAction = PoisonedMessageHandler.withCustomPoisonedAction[Future](3)(myReadAction) { delivery =>
   logger.warn(s"Delivery $delivery is poisoned!")
   Future.successful(())

extras/src/main/scala/com/avast/clients/rabbitmq/extras/PoisonedMessageHandler.scala

@@ -3,14 +3,16 @@ package com.avast.clients.rabbitmq.extras
 import java.util.concurrent.{CompletableFuture, ExecutorService}
 import java.util.function.{Function => JavaFunction}
 
+import cats.arrow.FunctionK
 import com.avast.bytes.Bytes
 import com.avast.clients.rabbitmq.api.DeliveryResult.{Reject, Republish}
 import com.avast.clients.rabbitmq.api.{Delivery, DeliveryResult}
 import com.avast.clients.rabbitmq.extras.PoisonedMessageHandler._
 import com.avast.clients.rabbitmq.javaapi.JavaConverters._
-import com.avast.clients.rabbitmq.{FromTask, ToTask, javaapi, _}
+import com.avast.clients.rabbitmq.{javaapi, FromTask, ToTask}
 import com.typesafe.scalalogging.StrictLogging
 import monix.eval.Task
+import monix.execution.Scheduler
 
 import scala.concurrent.{ExecutionContext, ExecutionContextExecutor, Future}
 import scala.language.higherKinds
@@ -75,6 +77,14 @@ object PoisonedMessageHandler {
   type JavaAction = JavaFunction[javaapi.Delivery, CompletableFuture[javaapi.DeliveryResult]]
   type CustomJavaPoisonedAction = JavaFunction[javaapi.Delivery, CompletableFuture[Void]]
 
+  private implicit def fkToFuture(implicit ec: ExecutionContext): FromTask[Future] = new FunctionK[Task, Future] {
+    override def apply[A](fa: Task[A]): Future[A] = fa.runAsync(Scheduler(ec))
+  }
+
+  private implicit val fkFromFuture: ToTask[Future] = new FunctionK[Future, Task] {
+    override def apply[A](fa: Future[A]): Task[A] = Task.fromFuture(fa)
+  }
+
   def apply[F[_]: FromTask: ToTask, A](maxAttempts: Int)(wrappedAction: Delivery[A] => F[DeliveryResult]): PoisonedMessageHandler[F, A] = {
     new PoisonedMessageHandler(maxAttempts)(wrappedAction)
   }

extras/src/test/scala/com/avast/clients/rabbitmq/extras/PoisonedMessageHandlerTest.scala

@@ -1,13 +1,13 @@
 package com.avast.clients.rabbitmq.extras
 
 import com.avast.bytes.Bytes
-import com.avast.clients.rabbitmq._
 import com.avast.clients.rabbitmq.api.DeliveryResult.Republish
 import com.avast.clients.rabbitmq.api.{Delivery, DeliveryResult, MessageProperties}
 import com.avast.clients.rabbitmq.extras.PoisonedMessageHandler._
 import monix.execution.Scheduler.Implicits.global
 import org.scalatest.FunSuite
 import org.scalatest.concurrent.ScalaFutures
+import TestImplicits._
 
 import scala.concurrent.Future