Usar cualquiera de los dos para procesar fallos en código Scala

La biblioteca Scalaz tiene algo parecido, ya sea con el nombre de Validación. Es más idiomático que usar como "obtener un resultado válido o un fallo".

La validación también permite acumular errores.

Edit: "alike" o bien es completamente falso, porque la Validación es un funtor aplicativo, y scalaz o Bien, llamado \/ (pronunciado "disjonction" o "either"), es una mónada. El hecho de que la validación pueda acumular errores se debe a esa naturaleza. Por otro lado, / tiene un "stop naturaleza temprana, deteniéndose en la primera - \ / (léalo "izquierda", o "error") que encuentra. Hay una explicación perfecta aquí: http://typelevel.org/blog/2014/02/21/error-handling.html

Véase: http://scalaz.googlecode.com/svn/continuous/latest/browse.sxr/scalaz/example/ExampleValidation.scala.html

Según lo solicitado por el comentario, copie / pegue el enlace anterior (algunas líneas eliminadas):

// Extracting success or failure values
val s: Validation[String, Int] = 1.success
val f: Validation[String, Int] = "error".fail

// It is recommended to use fold rather than pattern matching:
val result: String = s.fold(e => "got error: " + e, s => "got success: " + s.toString)

s match {
  case Success(a) => "success"
  case Failure(e) => "fail"
}

// Validation is a Monad, and can be used in for comprehensions.
val k1 = for {
  i <- s
  j <- s
} yield i + j
k1.toOption assert_≟ Some(2)

// The first failing sub-computation fails the entire computation.
val k2 = for {
  i <- f
  j <- f
} yield i + j
k2.fail.toOption assert_≟ Some("error")

// Validation is also an Applicative Functor, if the type of the error side of the validation is a Semigroup.
// A number of computations are tried. If the all success, a function can combine them into a Success. If any
// of them fails, the individual errors are accumulated.

// Use the NonEmptyList semigroup to accumulate errors using the Validation Applicative Functor.
val k4 = (fNel <**> fNel){ _ + _ }
k4.fail.toOption assert_≟ some(nel1("error", "error"))

El fragmento que publicaste parece muy artificial. Se utiliza cualquiera de los dos en una situación en la que:

1. No es suficiente saber que los datos no están disponibles.
2. Debe devolver uno de los dos tipos distintos.

Convertir una excepción en una izquierda es, de hecho, un caso de uso común. Sobre try / catch, tiene la ventaja de mantener el código unido, lo que tiene sentido si la excepción es un resultado esperado. La forma más común de manejar Cualquiera es patrón coincidencia:

result match {
  case Right(res) => ...
  case Left(res) => ...
}

Otra forma interesante de manejar Either es cuando aparece en una colección. Al hacer un mapa sobre una colección, lanzar una excepción podría no ser viable, y es posible que desee devolver alguna información que no sea "no posible". El uso de cualquiera de los dos le permite hacer eso sin sobrecargar el algoritmo:

val list = (
  library 
  \\ "books" 
  map (book => 
    if (book \ "author" isEmpty) 
      Left(book) 
    else 
      Right((book \ "author" toList) map (_ text))
  )
)

Aquí tenemos una lista de todos los autores en la biblioteca, más una lista de libros sin autor. Así que podemos procesarlo aún más en consecuencia:

val authorCount = (
  (Map[String,Int]() /: (list filter (_ isRight) map (_.right.get))) 
   ((map, author) => map + (author -> (map.getOrElse(author, 0) + 1)))
  toList
)
val problemBooks = list flatMap (_.left.toSeq) // thanks to Azarov for this variation

Por lo tanto, el uso básico de cualquiera de los dos va así. No es una clase particularmente útil, pero si lo fuera, lo habrías visto antes. Por otro lado, tampoco es inútil.