fix build issues

Author: Cristian Popovici

src/main/scala/util/retry/blocking/Retry.scala

@@ -2,76 +2,77 @@ package util.retry.blocking
 
 import util.retry.blocking.RetryStrategy.RetryStrategyProducer
 
+import scala.concurrent.{ExecutionContext, Future}
 import scala.util.Try
 import scala.util.control.NonFatal
 
 /**
-  * The `Retry` type represents a computation that is retrying itself in case of an exception. It uses a `RetryStrategy`
-  * as a policy for the retry operation.
-  *
-  * The result may be successful consisting of the computation result value or a failure that
-  * is wrapping the underlying exception. The type is similar to the scala [[scala.util.Try]] type.
-  *
-  * Example:
-  * {{{
-  * import scala.concurrent.duration._
-  * import util.retry.blocking.{RetryStrategy, Failure, Retry, Success}
-  *
-  * implicit val retryStrategy =
-  *  RetryStrategy.fixedBackOff(retryDuration = 1.seconds, maxAttempts = 2)
-  *
-  * val r = Retry(1 / 1) match {
-  *   case Success(x) => x
-  *   case Failure(t) => log("Exception occurred", t)
-  * }
-  * }}}
-  */
+ * The `Retry` type represents a computation that is retrying itself in case of an exception. It uses a `RetryStrategy`
+ * as a policy for the retry operation.
+ *
+ * The result may be successful consisting of the computation result value or a failure that
+ * is wrapping the underlying exception. The type is similar to the scala [[scala.util.Try]] type.
+ *
+ * Example:
+ * {{{
+ * import scala.concurrent.duration._
+ * import util.retry.blocking.{RetryStrategy, Failure, Retry, Success}
+ *
+ * implicit val retryStrategy =
+ *  RetryStrategy.fixedBackOff(retryDuration = 1.seconds, maxAttempts = 2)
+ *
+ * val r = Retry(1 / 1) match {
+ *   case Success(x) => x
+ *   case Failure(t) => log("Exception occurred", t)
+ * }
+ * }}}
+ */
 sealed trait Retry[+T] {
 
   /**
-    * Returns `true` if the `Retry` is a `Failure` otherwise it returns `false`.
-    */
+   * Returns `true` if the `Retry` is a `Failure` otherwise it returns `false`.
+   */
   def flatMap[S](f: T => Retry[S]): Retry[S]
 
   /**
-    * Maps the given function to the value from this `Success` or returns this if this is a `Failure`.
-    */
+   * Maps the given function to the value from this `Success` or returns this if this is a `Failure`.
+   */
   def map[S](f: T => S)(implicit strategy: RetryStrategyProducer): Retry[S]
 
   /**
-    * Returns `true` if the `Retry` is a `Failure` otherwise it returns `false`.
-    */
+   * Returns `true` if the `Retry` is a `Failure` otherwise it returns `false`.
+   */
   def isFailure: Boolean
 
   /**
-    * Returns `true` if the `Retry` is a `Success` otherwise it returns `false` otherwise.
-    */
+   * Returns `true` if the `Retry` is a `Success` otherwise it returns `false` otherwise.
+   */
   def isSuccess: Boolean
 
   /**
-    * Returns the computation value in case of a `Success`.
-    * In case of a `Failure` it throws the underlying exception.
-    */
+   * Returns the computation value in case of a `Success`.
+   * In case of a `Failure` it throws the underlying exception.
+   */
   def get: T
 
   /**
-    * Returns the computation value in case of a `Success`. Otherwise it is returning the provided default.
-    */
+   * Returns the computation value in case of a `Success`. Otherwise it is returning the provided default.
+   */
   def getOrElse[U >: T](default: => U): U = if (isSuccess) get else default
 
   /**
-    * Applies the given function `f` if this is a `Success`, otherwise returns `Unit` if this is a `Failure`.
-    */
+   * Applies the given function `f` if this is a `Success`, otherwise returns `Unit` if this is a `Failure`.
+   */
   def foreach[X](f: T => X)
 
   /**
-    * Applies the given function `f` if this is a `Failure`, otherwise returns this if this is a `Success`.
-    */
+   * Applies the given function `f` if this is a `Failure`, otherwise returns this if this is a `Success`.
+   */
   def recover[X >: T](f: PartialFunction[Throwable, X]): Retry[X]
 
   /**
-    * Transforms the `Retry` value by applying a transformation function to its underlying value
-    */
+   * Transforms the `Retry` value by applying a transformation function to its underlying value
+   */
   def transform[X](f: T => X): X
 }
 
@@ -85,7 +86,7 @@ final case class Success[+T](value: T) extends Retry[T] {
   override def transform[X](f: T => X): X = f(value)
   override def flatMap[S](f: T => Retry[S]): Retry[S] = f(value)
   override def map[S](f: T => S)(
-      implicit strategy: RetryStrategyProducer): Retry[S] = Retry(f(value))
+    implicit strategy: RetryStrategyProducer): Retry[S] = Retry(f(value))
 }
 
 final case class Failure[+T](exception: Throwable) extends Retry[T] {
@@ -106,20 +107,18 @@ final case class Failure[+T](exception: Throwable) extends Retry[T] {
   override def transform[X](f: T => X): X = throw exception
   override def flatMap[S](f: T => Retry[S]): Retry[S] = Failure(exception)
   override def map[S](f: T => S)(
-      implicit strategy: RetryStrategyProducer): Retry[S] = Failure(exception)
+    implicit strategy: () => RetryStrategy): Retry[S] = Failure(exception)
 }
 
 object Retry {
-  def apply[T](fn: => T)(implicit strategy: RetryStrategyProducer): Retry[T] = {
+  def apply[T](fn: => T)(implicit strategy: () => RetryStrategy): Retry[T] = {
     def go(fn: => T)(strategy: RetryStrategy): Retry[T] = {
       Try(fn) match {
         case x: scala.util.Success[T] =>
           Success(x.value)
         case _ if strategy.shouldRetry() =>
-          println("retrying")
           go(fn)(strategy.update())
         case f: scala.util.Failure[T] =>
-          println("giving up")
           Failure(f.exception)
       }
     }

src/test/scala/RetryDslSpec.scala

@@ -2,6 +2,7 @@ import org.scalatest.{FlatSpec, Matchers}
 import util.retry.blocking.RetryStrategy.RetryStrategyProducer
 import util.retry.blocking._
 
+import scala.concurrent.{ExecutionContext, Future}
 import scala.concurrent.duration._
 
 /**
@@ -18,6 +19,9 @@ class RetryDslSpec extends FlatSpec with Matchers {
       y <- Retry(1 / 1)
     } yield x + y
 
+    implicit val ec = ExecutionContext.global
+    Retry(Future(1))
+
     result should be(Success(2))
   }