Changes Xor to Either

Author: juanpedromoreno

client/shared/src/main/scala/org/scalaexercises/evaluator/EvaluatorClient.scala

@@ -5,7 +5,7 @@
 
 package org.scalaexercises.evaluator
 
-import cats.data.XorT
+import cats.data.EitherT
 import cats.~>
 import cats.implicits._
 import org.scalaexercises.evaluator.EvaluatorResponses.{EvalIO, EvaluationException, EvaluationResponse, EvaluationResult}
@@ -25,15 +25,17 @@ object EvaluatorClient {
   def apply(url: String, authKey: String) =
     new EvaluatorClient(url, authKey)
 
-  implicit class EvaluationIOSyntaxXOR[A](
+  implicit class EvaluationIOSyntaxEither[A](
     evalIO: EvalIO[EvaluationResponse[A]]) {
 
     def exec(
       implicit I: (EvaluatorOp ~> Future)): Future[EvaluationResponse[A]] =
       evalIO foldMap I
 
-    def liftEvaluator: XorT[EvalIO, EvaluationException, EvaluationResult[A]] =
-      XorT[EvalIO, EvaluationException, EvaluationResult[A]](evalIO)
+    def liftEvaluator: EitherT[EvalIO,
+                               EvaluationException,
+                               EvaluationResult[A]] =
+      EitherT[EvalIO, EvaluationException, EvaluationResult[A]](evalIO)
 
   }
 }

client/shared/src/main/scala/org/scalaexercises/evaluator/EvaluatorResponses.scala

@@ -7,7 +7,7 @@ package org.scalaexercises.evaluator
 
 import cats.data.Xor
 import cats.free.Free
-import cats.syntax.xor._
+import cats.implicits._
 import io.circe.Decoder
 import io.circe.parser._
 import io.circe.generic.auto._
@@ -23,7 +23,7 @@ object EvaluatorResponses {
 
   type EvalIO[A] = Free[EvaluatorOp, A]
 
-  type EvaluationResponse[A] = EvaluationException Xor EvaluationResult[A]
+  type EvaluationResponse[A] = Either[EvaluationException, EvaluationResult[A]]
 
   case class EvaluationResult[A](result: A,
                                  statusCode: Int,
@@ -44,18 +44,17 @@ object EvaluatorResponses {
     implicit D: Decoder[A]): Future[EvaluationResponse[A]] =
     futureResponse map {
       case r if isSuccess(r.statusCode) ⇒
-        decode[A](r.body).fold(
-          e ⇒
-            JsonParsingException(e.getMessage, r.body)
-              .left[EvaluationResult[A]],
-          result ⇒
-            Xor.Right(
+        decode[A](r.body) match {
+          case Xor.Left(e) =>
+            Either.left(JsonParsingException(e.getMessage, r.body))
+          case Xor.Right(result) =>
+            Either.right(
               EvaluationResult(result, r.statusCode, r.headers.toLowerCase))
-        )
+        }
       case r ⇒
-        UnexpectedException(
-          s"Failed invoking get with status : ${r.statusCode}, body : \n ${r.body}")
-          .left[EvaluationResult[A]]
+        Either.left(
+          UnexpectedException(
+            s"Failed i(nvoking get with status : ${r.statusCode}, body : \n ${r.body}"))
     }
 
   private[this] def isSuccess(statusCode: Int) =

server/src/test/scala/org/scalaexercises/evaluator/EvalEndpointSpec.scala

@@ -48,7 +48,7 @@ class EvalEndpointSpec extends FunSpec with Matchers {
             )
           )
         ).putHeaders(authHeader))
-      .unsafePerformSync
+      .run
 
   def verifyEvalResponse(
     response: Response,
@@ -58,7 +58,7 @@ class EvalEndpointSpec extends FunSpec with Matchers {
   ) = {
 
     response.status should be(expectedStatus)
-    val evalResponse = response.as[EvalResponse].unsafePerformSync
+    val evalResponse = response.as[EvalResponse].run
     evalResponse.value should be(expectedValue)
     evalResponse.msg should be(expectedMessage)
   }

server/src/test/scala/org/scalaexercises/evaluator/EvaluatorSpec.scala

@@ -17,8 +17,7 @@ class EvaluatorSpec extends FunSpec with Matchers {
 
   describe("evaluation") {
     it("can evaluate simple expressions") {
-      val result: EvalResult[Int] =
-        evaluator.eval("{ 41 + 1 }").unsafePerformSync
+      val result: EvalResult[Int] = evaluator.eval("{ 41 + 1 }").run
 
       result should matchPattern {
         case EvalSuccess(_, 42, _) ⇒
@@ -27,7 +26,7 @@ class EvaluatorSpec extends FunSpec with Matchers {
 
     it("fails with a timeout when takes longer than the configured timeout") {
       val result: EvalResult[Int] =
-        evaluator.eval("{ while(true) {}; 123 }").unsafePerformSync
+        evaluator.eval("{ while(true) {}; 123 }").run
 
       result should matchPattern {
         case Timeout(_) ⇒
@@ -52,7 +51,7 @@ Eval.now(42).value
           remotes = remotes,
           dependencies = dependencies
         )
-        .unsafePerformSync
+        .run
 
       result should matchPattern {
         case EvalSuccess(_, 42, _) =>
@@ -79,14 +78,14 @@ Eval.now(42).value
           remotes = remotes,
           dependencies = dependencies1
         )
-        .unsafePerformSync
+        .run
       val result2: EvalResult[Int] = evaluator
         .eval(
           code,
           remotes = remotes,
           dependencies = dependencies2
         )
-        .unsafePerformSync
+        .run
 
       result1 should matchPattern {
         case EvalSuccess(_, 42, _) =>
@@ -113,7 +112,7 @@ Asserts.scalaTestAsserts(true)
           remotes = remotes,
           dependencies = dependencies
         )
-        .unsafePerformSync
+        .run
 
       result should matchPattern {
         case EvalSuccess(_, (), _) =>
@@ -137,7 +136,7 @@ Asserts.scalaTestAsserts(false)
           remotes = remotes,
           dependencies = dependencies
         )
-        .unsafePerformSync
+        .run
 
       result should matchPattern {
         case EvalRuntimeError(