Há pouco tempo, comecei a usar o Scala em vez do Java. Parte do processo de "conversão" entre os idiomas para mim foi aprender a usar Eithers em vez de (marcado) Exceptions. Eu tenho codificado dessa maneira por um tempo, mas recentemente comecei a me perguntar se esse é realmente o melhor caminho a percorrer.
Uma grande vantagem Eithertem mais Exceptioné melhor desempenho; um Exceptionprecisa criar um rastreamento de pilha e está sendo lançado. Até onde eu entendo, jogar a Exceptionparte não é a parte mais exigente, mas construir o rastreamento da pilha é.
Mas então, sempre é possível construir / herdar Exceptions com scala.util.control.NoStackTrace, e mais ainda, vejo muitos casos em que o lado esquerdo de um Eitheré de fato um Exception(renunciando ao aumento de desempenho).
Uma outra vantagem Eitheré a segurança do compilador; o compilador Scala não se queixará de Exceptions não manipulados (ao contrário do compilador do Java). Mas se não me engano, essa decisão é fundamentada com o mesmo raciocínio discutido neste tópico, então ...
Em termos de sintaxe, sinto que o Exceptionestilo é muito mais claro. Examine os seguintes blocos de código (ambos obtendo a mesma funcionalidade):
Either estilo:
def compute(): Either[String, Int] = {
val aEither: Either[String, String] = if (someCondition) Right("good") else Left("bad")
val bEithers: Iterable[Either[String, Int]] = someSeq.map {
item => if (someCondition(item)) Right(item.toInt) else Left("bad")
}
for {
a <- aEither.right
bs <- reduce(bEithers).right
ignore <- validate(bs).right
} yield compute(a, bs)
}
def reduce[A,B](eithers: Iterable[Either[A,B]]): Either[A, Iterable[B]] = ??? // utility code
def validate(bs: Iterable[Int]): Either[String, Unit] = if (bs.sum > 22) Left("bad") else Right()
def compute(a: String, bs: Iterable[Int]): Int = ???Exception estilo:
@throws(classOf[ComputationException])
def compute(): Int = {
val a = if (someCondition) "good" else throw new ComputationException("bad")
val bs = someSeq.map {
item => if (someCondition(item)) item.toInt else throw new ComputationException("bad")
}
if (bs.sum > 22) throw new ComputationException("bad")
compute(a, bs)
}
def compute(a: String, bs: Iterable[Int]): Int = ???O último parece muito mais limpo para mim, e o código que trata da falha (com correspondência de padrões Eitherou try-catch) é bastante claro nos dois casos.
Então, minha pergunta é - por que usar Eitherover (marcado) Exception?
Atualizar
Depois de ler as respostas, percebi que poderia não ter apresentado o cerne do meu dilema. Minha preocupação não é com a falta de try-catch; pode-se "pegar" um Exceptioncom Tryou usar o catchpara quebrar a exceção com Left.
Meu principal problema com Either/ Trysurge quando escrevo código que pode falhar em muitos pontos ao longo do caminho; nesses cenários, ao encontrar uma falha, tenho que propagar essa falha por todo o meu código, tornando o código muito mais complicado (como mostra os exemplos mencionados acima).
Na verdade, existe outra maneira de quebrar o código sem Exceptions usando return(que na verdade é outro "tabu" no Scala). O código ainda seria mais claro que a Eitherabordagem e, embora um pouco menos limpo que o Exceptionestilo, não haveria medo de Exceptions não capturados .
def compute(): Either[String, Int] = {
val a = if (someCondition) "good" else return Left("bad")
val bs: Iterable[Int] = someSeq.map {
item => if (someCondition(item)) item.toInt else return Left("bad")
}
if (bs.sum > 22) return Left("bad")
val c = computeC(bs).rightOrReturn(return _)
Right(computeAll(a, bs, c))
}
def computeC(bs: Iterable[Int]): Either[String, Int] = ???
def computeAll(a: String, bs: Iterable[Int], c: Int): Int = ???
implicit class ConvertEither[L, R](either: Either[L, R]) {
def rightOrReturn(f: (Left[L, R]) => R): R = either match {
case Right(r) => r
case Left(l) => f(Left(l))
}
}Basicamente, as return Leftsubstituições throw new Exceptione o método implícito em qualquer uma delas rightOrReturnsão um complemento para a propagação automática de exceções na pilha.
Try. A parte sobre Eithervs Exceptionsimplesmente afirma que Eithers deve ser usado quando o outro caso do método for "não excepcional". Primeiro, essa é uma definição muito, muito vaga. Segundo, vale mesmo a pena a sintaxe? Quero dizer, eu realmente não me importaria de usar Eithers se não fosse pela sobrecarga de sintaxe que eles apresentam.
Eitherparece uma mônada para mim. Use-o quando precisar dos benefícios de composição funcional que as mônadas fornecem. Ou talvez não .
Eitherpor si só não é uma mônada. A projeção para o lado esquerdo ou direito é uma mônada, mas Eitherpor si só não é. Você pode torná- la uma mônada, "influenciando" para o lado esquerdo ou o lado direito. No entanto, você transmite uma certa semântica nos dois lados de um Either. O Scala's Eitherera originalmente imparcial, mas era tendencioso recentemente, de modo que atualmente é de fato uma mônada, mas a "monadness" não é uma propriedade inerente, Eithermas sim um resultado de ser tendenciosa.