use handleError instead of recoverError (so use Scala's func instead of partial func)

Author: matteobaglini

application/src/main/scala/application/Version4.scala

@@ -12,7 +12,7 @@ package application
       - orchestrate domain, infrastructure, parsing and error handling
       - run the whole app lifted in the IO monad
       - print final rover output to the console if everything is ok
-      - recover from any unhandled error and print it
+      - handle any unhandled error by printing it
  */
 object Version4 {
 

application/src/main/scala/application/Version5.scala

@@ -74,7 +74,7 @@ object Version5 {
         _ <- runMission(display, planet, rover, commands)
       } yield ()
 
-    runResult.recoverWith(display.error(_))
+    runResult.handleErrorWith(display.error)
   }
 
   // NOTE: is used display to print obstacle/completed cases

application/src/main/scala/application/Version6.scala

@@ -81,7 +81,7 @@ object Version6 {
 
         loadResult
           .map(toSuccessful)
-          .recover(toFailed(_))
+          .handleError(toFailed)
           // NOTE: signal to the Runtime to continue the loop
           .map(continue)
 

application/src/main/scala/application/answers/Version4.scala

@@ -19,7 +19,7 @@ object Version4 {
         _ <- runMission(planet, rover, commands)
       } yield ()
 
-    runResult.recoverWith(writeError(_))
+    runResult.handleErrorWith(writeError)
   }
 
   def runMission(planet: Planet, rover: Rover, commands: List[Command]): IO[Unit] =

application/src/main/scala/application/answers/Version5.scala

@@ -57,7 +57,7 @@ object Version5 {
         _ <- runMission(display, planet, rover, commands)
       } yield ()
 
-    runResult.recoverWith(display.error(_))
+    runResult.handleErrorWith(display.error)
   }
 
   def runMission(display: DisplayWriter, planet: Planet, rover: Rover, commands: List[Command]): IO[Unit] =

application/src/main/scala/application/answers/Version6.scala

@@ -67,7 +67,7 @@ object Version6 {
 
         loadResult
           .map(toSuccessful)
-          .recover(toFailed(_))
+          .handleError(toFailed)
           .map(continue)
 
       case Effect.AskCommands =>

demos/src/test/scala/demos/Either.scala

@@ -3,6 +3,7 @@ package demos
 @munit.IgnoreSuite
 class EitherDemo extends munit.FunSuite {
 
+  import cats.syntax.applicativeError._
   import cats.syntax.either._
 
   test("creation") {
@@ -42,30 +43,16 @@ class EitherDemo extends munit.FunSuite {
   }
 
   test("error handling") {
-
-    def handle(e: Either[String, Int]): Either[String, Int] =
-      e.recover(e =>
-        e match {
-          case "unknown" => 42
-        }
-      )
+    val e1: Either[String, Int] = Left("unknown")
 
     // The Left[String] value is converted to a Right[Int]
-    val e1: Either[String, Int] = handle(Left("unknown"))
-
-    // The Left[String] value isn't converted
-    val e2: Either[String, Int] = handle(Left("anything else"))
+    val e2: Either[String, Int] =
+      e1.handleError(e => e.hashCode())
 
-    def handleWith(e: Either[String, Int]): Either[String, Int] =
-      e.recoverWith(e =>
-        e match {
-          case "unknown" => Right(42)
-        }
-      )
+    val e3: Either[String, Int] = Left("unknown")
 
     // Same conversions as before
-    val e3: Either[String, Int] = handleWith(Left("unknown"))
-    val e4: Either[String, Int] = handleWith(Left("anything else"))
+    val e4: Either[String, Int] = e3.handleErrorWith(e => Right(e.hashCode))
   }
 
 }

demos/src/test/scala/demos/IO.scala

@@ -18,7 +18,7 @@ class IODemo extends munit.FunSuite {
     val io2 = IO(throw new RuntimeException("boom!"))
 
     // In order evaluate our program we explicitly call unsafeRunSync
-    IO(5).unsafeRunSync()
+    io1.unsafeRunSync()
 
     // Pay attention to the pure function, it's eager-evaluated
 
@@ -29,7 +29,20 @@ class IODemo extends munit.FunSuite {
     // val io4 = IO.pure(System.out.println("hi!"))
 
     // Eval throw and then create IO
-    // val io5 = I.pureO(throw new RuntimeException("boom!"))
+    // val io5 = IO.pure(throw new RuntimeException("boom!"))
+  }
+
+  test("manipulation") {
+    val io1: IO[Int] = IO(5)
+
+    // Change the right type parameter's type
+    val io2: IO[String] = io1.map(_.toString)
+
+    // Change IO
+    val io3: IO[String] = io2.flatMap(_ => IO("hi!"))
+
+    // Change IO's state
+    val io4: IO[String] = io3.flatMap(_ => IO(throw new RuntimeException("boom!")))
   }
 
   test("error handling") {
@@ -39,18 +52,10 @@ class IODemo extends munit.FunSuite {
     val io1: IO[String] = IO(throw UnreachableServer())
 
     val io2: IO[String] =
-      io1.recover(e =>
-        e match {
-          case UnreachableServer() => "localhost"
-        }
-      )
+      io1.handleError(e => e.getMessage())
 
     val io3: IO[String] =
-      io1.recoverWith(e =>
-        e match {
-          case UnreachableServer() => IO("localhost")
-        }
-      )
+      io1.handleErrorWith(e => IO.pure(e.getMessage))
 
     // Plus, IO provides attempt function that trap any error and
     // materialize them as Either[Throwable, A]