underscoreio/scala

One more question, related to fail slow. Here is an example, in which 2 dates are taken from map and validation checks if one dates comes after another. Most methods are copied from Cats with Scala, except the oneDateAfterAnother:

object DateFailSlow {

 import cats.syntax.either._ // for ensure and for catchOnly
 import java.text.{ParseException, SimpleDateFormat}
 import java.util.Date
 import cats.data.Validated
 import cats.Semigroupal

 type FailFast[A] = Either[List[String], A]
 type FailSlow[A] = Validated[List[String], A]

 def oneDateAfterAnotherFailFast(dateBefore: String, dateAfter: String)
                                (map: Map[String, String])(format: SimpleDateFormat)
  : FailFast[Boolean]=
  for {
   dateBefore <- readDate(dateBefore)(map)(format)
   dateAfter <- readDate(dateAfter)(map)(format)
  } yield dateAfter.compareTo(dateBefore) > 0

 def readDate(name:String)(map: Map[String, String])(format: SimpleDateFormat):FailFast[Date] =
  for {
   value <- readValue(name)(map)
   res <- parseDate(name)(value)(format)
  } yield res

 def readValue(name: String)(map: Map[String, String]): FailFast[String] =
  for {
   value <- getValue(name)(map)
   _ <- nonNullable(name)(value)
   res <- nonBlank(name)(value)
  } yield res

 def getValue(name: String)(map: Map[String, String]): FailFast[String] =
  map.get(name)
    .toRight(List(s"$name field not specified"))

 def nonNullable(name: String)(data: String): FailFast[String] =
  Right(data).ensure(List(s"$name cannot be nullable"))(_ != null)

 def nonBlank(name: String)(data: String): FailFast[String] =
  Right(data).ensure(List(s"$name cannot be blank"))(_.nonEmpty)

 def parseDate(name: String)(data: String)(format: SimpleDateFormat): FailFast[Date] =
  Either.catchOnly[ParseException](format.parse(data)).
    leftMap(_ => List(s"$name must be a date"))

}

It works fine, but I want to accumulate error s in oneDateAfterAnother. And it is an issue for me. Here is my try:

 def oneDateAfterAnotherFailSlow(dateBefore: String, dateAfter: String)
                                (map: Map[String, String])(format: SimpleDateFormat)
  : FailSlow[Boolean]=
  Semigroupal.map2(
   readDate(dateBefore)(map)(format).toValidated,
   readDate(dateAfter)(map)(format).toValidated
  )(_.compareTo(_) > 0)

As I understand map2 accepts 2 contexts, in my case it is to Validated and a function, that converts 2 arguments into the 3rd. Boolean in my case. But I am getting the error:

Error:(23, 4) type mismatch;
 found   : cats.data.Validated[List[String],java.util.Date]
 required: ?F[?A0]
Note that implicit conversions are not applicable because they are ambiguous:
 both method ArrowAssoc in object Predef of type [A](self: A)ArrowAssoc[A]
 and method Ensuring in object Predef of type [A](self: A)Ensuring[A]
 are possible conversion functions from cats.data.Validated[List[String],java.util.Date] to ?F[?A0]
  )(_.compareTo(_) > 0)

Can you please explain, what I am doing wrong?