Fix implicit messages

Author: sebaciv

rest/src/main/scala/io/udash/rest/raw/RestResponse.scala

@@ -55,12 +55,14 @@ object RestResponse extends RestResponseLowPrio {
   }
 
   implicit def taskLikeFromResponseTask[F[_], T](
-    implicit fromTask: FromTask[F], fromResponse: AsReal[RestResponse, T]
+    implicit fromTask: FromTask[F],
+    fromResponse: AsReal[RestResponse, T],
   ): AsReal[Task[RestResponse], Try[F[T]]] =
     rawTask => Success(fromTask.fromTask(rawTask.map(fromResponse.asReal)))
 
   implicit def taskLikeToResponseTask[F[_], T](
-    implicit taskLike: TaskLike[F], asResponse: AsRaw[RestResponse, T]
+    implicit taskLike: TaskLike[F],
+    asResponse: AsRaw[RestResponse, T],
   ): AsRaw[Task[RestResponse], Try[F[T]]] =
     _.fold(Task.raiseError, ft => Task.from(ft).map(asResponse.asRaw)).recoverHttpError
 
@@ -70,13 +72,13 @@ object RestResponse extends RestResponseLowPrio {
   @implicitNotFound("${F}[${T}] is not a valid result type because:\n#{forResponseType}")
   implicit def effAsyncAsRealNotFound[F[_], T](implicit
     fromAsync: TaskLike[F],
-    forResponseType: ImplicitNotFound[AsReal[RestResponse, T]]
+    forResponseType: ImplicitNotFound[AsReal[RestResponse, T]],
   ): ImplicitNotFound[AsReal[Task[RestResponse], Try[F[T]]]] = ImplicitNotFound()
 
   @implicitNotFound("${F}[${T}] is not a valid result type because:\n#{forResponseType}")
   implicit def effAsyncAsRawNotFound[F[_], T](implicit
     toAsync: TaskLike[F],
-    forResponseType: ImplicitNotFound[AsRaw[RestResponse, T]]
+    forResponseType: ImplicitNotFound[AsRaw[RestResponse, T]],
   ): ImplicitNotFound[AsRaw[Task[RestResponse], Try[F[T]]]] = ImplicitNotFound()
 
   // following two implicits provide nice error messages when result type of HTTP method is totally wrong
@@ -185,12 +187,14 @@ object StreamedRestResponse extends StreamedRestResponseLowPrio {
   }
 
   implicit def taskLikeFromResponseTask[F[_], T](
-    implicit fromTask: FromTask[F], fromResponse: AsReal[StreamedRestResponse, T]
+    implicit fromTask: FromTask[F],
+    fromResponse: AsReal[StreamedRestResponse, T],
   ): AsReal[Task[StreamedRestResponse], Try[F[T]]] =
     rawTask => Success(fromTask.fromTask(rawTask.map(fromResponse.asReal)))
 
   implicit def taskLikeToResponseTask[F[_], T](
-    implicit taskLike: TaskLike[F], asResponse: AsRaw[StreamedRestResponse, T]
+    implicit taskLike: TaskLike[F],
+    asResponse: AsRaw[StreamedRestResponse, T],
   ): AsRaw[Task[StreamedRestResponse], Try[F[T]]] =
     _.fold(Task.raiseError, ft => Task.from(ft).map(asResponse.asRaw)).recoverHttpError
 
@@ -204,8 +208,8 @@ object StreamedRestResponse extends StreamedRestResponseLowPrio {
   ): AsRaw[Task[StreamedRestResponse], Try[Observable[T]]] =
     _.fold(Task.raiseError, ft => Task.eval(ft).map(asResponse.asRaw)).recoverHttpError
 
-  // following two implicits provide nice error messages when serialization is lacking for HTTP method result
-  // while the async wrapper is fine (e.g. Future)
+  // following implicits provide nice error messages when serialization is lacking for HTTP method result
+  // while the async wrapper is fine
 
   @implicitNotFound("${F}[${T}] is not a valid result type because:\n#{forResponseType}")
   implicit def effAsyncAsRealNotFound[F[_], T](implicit
@@ -219,6 +223,16 @@ object StreamedRestResponse extends StreamedRestResponseLowPrio {
     forResponseType: ImplicitNotFound[AsRaw[StreamedRestResponse, T]]
   ): ImplicitNotFound[AsRaw[Task[StreamedRestResponse], Try[F[T]]]] = ImplicitNotFound()
 
+  @implicitNotFound("Observable[${T}] is not a valid result type because:\n#{forResponseType}")
+  implicit def observableAsRealNotFound[T](implicit
+    forResponseType: ImplicitNotFound[AsReal[StreamedBody, Observable[T]]]
+  ): ImplicitNotFound[AsReal[Task[StreamedRestResponse], Try[Observable[T]]]] = ImplicitNotFound()
+
+  @implicitNotFound("Observable[${T}] is not a valid result type because:\n#{forResponseType}")
+  implicit def observableAsRawNotFound[T](implicit
+    forResponseType: ImplicitNotFound[AsRaw[StreamedBody, Observable[T]]]
+  ): ImplicitNotFound[AsRaw[Task[StreamedRestResponse], Try[Observable[T]]]] = ImplicitNotFound()
+
   // following two implicits provide nice error messages when result type of HTTP method is totally wrong
 
   @implicitNotFound("#{forResponseType}")

rest/src/main/scala/io/udash/rest/raw/StreamedBody.scala

@@ -98,12 +98,12 @@ trait StreamedBodyLowPrio { this: StreamedBody.type =>
   implicit def bodyJsonListAsReal[T](implicit jsonAsReal: AsReal[JsonValue, T]): AsReal[StreamedBody, Observable[T]] =
     v => StreamedBody.castOrFail[StreamedBody.JsonList](v).elements.map(jsonAsReal.asReal)
 
-  @implicitNotFound("Cannot deserialize ${T} from StreamedBody, because:\n#{forJson}")
+  @implicitNotFound("Cannot deserialize Observable[${T}] from StreamedBody, because:\n#{forJson}")
   implicit def asRealNotFound[T](
     implicit forJson: ImplicitNotFound[AsReal[JsonValue, T]]
   ): ImplicitNotFound[AsReal[StreamedBody, Observable[T]]] = ImplicitNotFound()
 
-  @implicitNotFound("Cannot serialize ${T} into StreamedBody, because:\n#{forJson}")
+  @implicitNotFound("Cannot serialize Observable[${T}] into StreamedBody, because:\n#{forJson}")
   implicit def asRawNotFound[T](
     implicit forJson: ImplicitNotFound[AsRaw[JsonValue, T]]
   ): ImplicitNotFound[AsRaw[StreamedBody, Observable[T]]] = ImplicitNotFound()

rest/src/test/scala/io/udash/rest/CompilationErrorsTest.scala

@@ -146,15 +146,10 @@ class CompilationErrorsTest extends AnyFunSuite with CompilationErrorAssertions
       """cannot translate between trait MissingObservableSerializerForResult and trait RawRest:
         |problem with method streamMeth:
         | * it cannot be translated into an HTTP GET method:
-        |   monix.reactive.Observable[Any] is not a valid result type because:
-        |   Cannot serialize monix.reactive.Observable[Any] into RestResponse, because:
-        |   Cannot serialize monix.reactive.Observable[Any] into HttpBody, because:
-        |   Cannot serialize monix.reactive.Observable[Any] into JsonValue, because:
-        |   No GenCodec found for monix.reactive.Observable[Any]
+        |   monix.reactive.Observable[Any] is not a valid result type of HTTP REST method - it must be a Future
         | * it cannot be translated into an HTTP GET stream method:
-        |   monix.reactive.Observable[Any] is not a valid result type because:
-        |   Cannot serialize monix.reactive.Observable[Any] into StreamedRestResponse, because:
-        |   Cannot serialize Any into StreamedBody, because:
+        |   Observable[Any] is not a valid result type because:
+        |   Cannot serialize Observable[Any] into StreamedBody, because:
         |   Cannot serialize Any into JsonValue, because:
         |   No GenCodec found for Any""".stripMargin)
   }
@@ -177,7 +172,7 @@ class CompilationErrorsTest extends AnyFunSuite with CompilationErrorAssertions
         | * it cannot be translated into an HTTP GET stream method:
         |   monix.eval.Task[monix.reactive.Observable[Any]] is not a valid result type because:
         |   Cannot serialize monix.reactive.Observable[Any] into StreamedRestResponse, because:
-        |   Cannot serialize Any into StreamedBody, because:
+        |   Cannot serialize Observable[Any] into StreamedBody, because:
         |   Cannot serialize Any into JsonValue, because:
         |   No GenCodec found for Any""".stripMargin)
   }