¿Cómo puedo (mejor) convertir una Opción devuelta por una llamada de método en un Try (por preferencia, aunque sea un Either o un scalaz)\/ o incluso una validación podría estar bien), incluida la especificación de un valor de error, si corresponde.

Por ejemplo, tengo el siguiente código, que se siente torpe, pero al menos hace (la mayoría de) el trabajo:

import scala.util._

case class ARef(value: String)
case class BRef(value: String)
case class A(ref: ARef, bRef: BRef)
class MismatchException(msg: String) extends RuntimeException(msg)

trait MyTry {

  // Given:
  val validBRefs: List[BRef]

  // Want to go from an Option[A] (obtained, eg., via a function call passing a provided ARef)
  // to a Try[BRef], where the b-ref needs to be checked against the above list of BRefs or fail:

  def getValidBRefForReferencedA(aRef: ARef): Try[BRef] = {

    val abRef = for {
      a <- get[A](aRef) // Some function that returns an Option[A]
      abRef = a.bRef
      _ <- validBRefs.find(_ == abRef)
    } yield (abRef)

    abRef match {
      case Some(bRef) => Success(bRef)
      case None => Failure(new MismatchException("No B found matching A's B-ref"))
    }
  }
}

Se siente como que debería haber una manera para que la coincidencia final se transforme en un mapa o mapa plano o construcción similar y se incorpore en el precedente para la comprensión.

Además, preferiría poder especificar un mensaje de error diferente si la llamada para devolver una Opción [A] del ARef falló (devolvió Ninguno) en comparación con el error de la verificación de BRef (solo me importa saber el motivo del fallo, por lo que una validación Scalaz no se siente como el ajuste ideal).

¿Es este un lugar adecuado para usar un transformador de mónada? Si es así, ¿scalaz proporciona una adecuada, o alguien puede dar un ejemplo de cómo se vería?