Type Members

1.  type TryT[F[_], A] = invariant.OpacityTypes.TryT[F, A]

   A monad transformer for exception handling.

   A monad transformer for exception handling.

   Example:

   1. As a monad transformer, TryT should be used with another monadic data type, like scalaz.Name.

      import scalaz.Name
      import com.thoughtworks.tryt.invariant.TryT, TryT._
      
      type TryName[A] = TryT[Name, A]

      Given a validate function,

      def validate(s: String): Int = s.toInt

      when creating a TryT-transformed scalaz.Name from the validate,

      import scalaz.syntax.all._
      val invalidTry: TryName[Int] = validate("invalid input").point[TryName]

      then the exceptions thrown in validate call should be converted to a scala.util.Failure;

      import com.thoughtworks.tryt.invariant.TryT._
      
      val TryT(Name(failure)) = invalidTry
      
      import scala.util._
      failure should be(an[Failure[_]])

      and when there is no exception thrown in validate call,

      val validTry: TryName[Int] = validate("42").point[TryName]

      then the result of validate call should be converted to a scala.util.Success;

      val TryT(Name(success)) = validTry
      success should be(Success(42))

      and when the TryT-transformed scalaz.Name is built from a for-comprehension,

      val invalidForComprehension: TryName[Int] = for {
        i <- validate("42").point[TryName]
        j <- validate("invalid input").point[TryName]
      } yield i + j

      then the exceptions thrown in the for-comprehension should be converted to a scala.util.Failure;

      val TryT(Name(failure2)) = invalidTry
      failure2 should be(an[Failure[_]])

   Note

   This TryT type is an opacity alias to F[Try[A]]. All type classes and helper functions for this TryT type are defined in the companion object TryT

   See also

   This TryT transfomer is similar to scalaz.EitherT, except TryT handles exceptions thrown in callback functions passed to map, bind or point.