invariant

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

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

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[_]])