Reputation: 6006
I have a following trait:
trait Recoverable[M[_]] {
def recoverW[T, U >: T](f: PartialFunction[Throwable, M[U]])(implicit executor: ExecutionContext): M[U]
def fail[T](error: Throwable): M[T]
}
Also I have an implicit conversion method in the same package:
implicit def tryRecoverable[T](`try`: Try[T]) = new Recoverable[Try] {
override def recoverW[T, U >: T](f: PartialFunction[Throwable, Try[U]])(implicit executor: ExecutionContext): Try[U] = `try`.recoverWith[U](f)
override def fail[T](error: Throwable): Try[T] = Failure(error)
}
This code doesn't compile complaining with
type arguments [U] do not conform to method recoverWith's type parameter bounds [U >: T]
override def recoverW[T, U >: T](f: PartialFunction[Throwable, Try[U]])(implicit executor: ExecutionContext): Try[U] = `try`.recoverWith[U](f)
^
Why this code doesn't compile?
Upvotes: 0
Views: 68
Reputation: 22374
Because T
inside recoverW
and T
inside tryRecoverable
- are different T's ([T, ...]
defines new method-scoped T
), you may:
trait Recoverable[M[_]] {
type TT
def recoverW[U >: TT](f: PartialFunction[Throwable, M[U]])(implicit executor: ExecutionContext): M[U]
def fail(error: Throwable): M[TT]
}
implicit def tryRecoverable[T](`try`: Try[T]) = new Recoverable[Try] {
type TT = T
override def recoverW[U >: T](f: PartialFunction[Throwable, Try[U]])(implicit executor: ExecutionContext): Try[U] = `try`.recoverWith[U](f)
override def fail(error: Throwable): Try[T] = Failure(error)
}
But i wouldn't use M[_]
definition here, as it's mostly used when you can actually concretise your M[_]
inside your method, like:
trait Monad[M[_]] extends Applicative[M] {
def flatMap[T, U](m: M[T])(fn: (T) => M[U]): M[U]
...
}
See Twitter's Monad for instance. Actually, using M[_]
is more Haskell-style as there is no classess, so monad itself is passed as parameter to method. So maybe you shoudn't use it at all and specify trait Recoverable[M[T]]
directly.
Or you can do it Haskell style:
trait Recoverable[M[_]] {
def recoverW[T, U >: T](m: M[T])(f: PartialFunction[Throwable, M[U]])(implicit executor: ExecutionContext): M[U]
def fail[T](m: M[T])(error: Throwable): M[T]
}
implicit val tryRecoverable = new Recoverable[Try] {
override def recoverW[T, U >: T](`try`: Try[T])( f: PartialFunction[Throwable, Try[U]])(implicit executor: ExecutionContext): Try[U] = `try`.recoverWith[U](f)
override def fail[T](`try`: Try[T])( error: Throwable): Try[T] = Failure(error)
}
Then use it as:
scala> implicitly[Recoverable[Try]].recoverW(Try{"aaaa"})({case x => Try{"bbb"}})
res54: scala.util.Try[String] = Success(aaaa)
Or just require it inside your function/class using Try[T]: Recoverable
syntax sugar:
def recover[T, Try[T]: Recoverable](t: Try[T]) = recoverW(t) _
Upvotes: 2