♻️ refactor: remove Compat methods in favour on their implementation

build.sbt

@@ -221,7 +221,9 @@ lazy val `anorm-core` = project
         ProblemFilters.exclude[DirectMissingMethodProblem]("anorm.ToStatement.jodaDateTimeToStatement"),
         ProblemFilters.exclude[DirectMissingMethodProblem]("anorm.ToStatement.jodaLocalDateTimeToStatement"),
         ProblemFilters.exclude[DirectMissingMethodProblem]("anorm.ToStatement.jodaLocalDateToStatement"),
-        ProblemFilters.exclude[DirectMissingMethodProblem]("anorm.ToStatement.jodaInstantToStatement")
+        ProblemFilters.exclude[DirectMissingMethodProblem]("anorm.ToStatement.jodaInstantToStatement"),
+        ProblemFilters.exclude[MissingClassProblem]("anorm.Compat"),
+        ProblemFilters.exclude[MissingClassProblem]("anorm.Compat$")
       ),
       libraryDependencies ++= {
         Seq(

core/src/main/scala-2/anorm/macros/Inspect.scala

@@ -6,8 +6,6 @@ package anorm.macros
 
 import scala.reflect.macros.whitebox
 
-import anorm.Compat
-
 private[anorm] object Inspect {
   def directKnownSubclasses(c: whitebox.Context)(tpe: c.Type): List[c.Type] = {
     // Workaround for SI-7046: https://issues.scala-lang.org/browse/SI-7046
@@ -16,7 +14,7 @@ private[anorm] object Inspect {
     val tpeSym = tpe.typeSymbol.asClass
 
     @annotation.tailrec
-    def allSubclasses(path: Compat.Trav[Symbol], subclasses: Set[Type]): Set[Type] = path.headOption match {
+    def allSubclasses(path: Iterable[Symbol], subclasses: Set[Type]): Set[Type] = path.headOption match {
       case Some(cls: ClassSymbol) if tpeSym != cls && cls.selfType.baseClasses.contains(tpeSym) => {
         val newSub: Set[Type] = if (!cls.isCaseClass) {
           c.warning(c.enclosingPosition, s"cannot handle class ${cls.fullName}: no case accessor")
@@ -74,10 +72,13 @@ private[anorm] object Inspect {
       if (apply.paramLists.isEmpty) {
         Map.empty
       } else {
-        Compat.toMap(Compat.lazyZip(apply.typeParams, tpeArgs)) {
-          case (sym, ty) =>
-            sym.fullName -> ty
-        }
+        apply.typeParams
+          .lazyZip(tpeArgs)
+          .map {
+            case (sym, ty) =>
+              sym.fullName -> ty
+          }
+          .to(Map)
       }
     }
   }

core/src/main/scala-2/anorm/macros/ToParameterListImpl.scala

@@ -6,7 +6,7 @@ package anorm.macros
 
 import scala.reflect.macros.whitebox
 
-import anorm.{ Compat, ToParameterList, ToSql, ToStatement }
+import anorm.{ ToParameterList, ToSql, ToStatement }
 import anorm.Macro.{ debugEnabled, ParameterProjection }
 import anorm.macros.Inspect.pretty
 
@@ -210,25 +210,29 @@ private[anorm] object ToParameterListImpl {
     val bufVal        = q"val ${bufName} = ${ImuList}.newBuilder[${NamedParamTpe}]"
 
     // def of functions to append named parameters to a local list buffer
-    val appendDefs = Compat.mapValues(appendParameters)(_._2).values.toSeq
+    val appendDefs = appendParameters.view.mapValues(_._2).values.toSeq
 
     // applies/call of the functions according the projection
     val effectiveProj: Map[String, String] = {
       if (compiledProj.nonEmpty) {
-        Compat.toMap(compiledProj) {
-          case ParameterProjection(propName, Some(paramName)) =>
-            propName -> paramName
+        compiledProj.view
+          .map {
+            case ParameterProjection(propName, Some(paramName)) =>
+              propName -> paramName
 
-          case ParameterProjection(propName, _) =>
-            propName -> propName
-        }
+            case ParameterProjection(propName, _) =>
+              propName -> propName
+          }
+          .to(Map)
       } else
-        Compat.collectToMap(properties) {
-          case term: TermSymbol => {
-            val propName = term.name.toString
-            propName -> propName
+        properties.view
+          .collect {
+            case term: TermSymbol => {
+              val propName = term.name.toString
+              propName -> propName
+            }
           }
-        }
+          .to(Map)
     }
 
     val appendCalls = effectiveProj.flatMap {

core/src/main/scala-3/anorm/macros/Inspect.scala

@@ -6,8 +6,6 @@ package anorm.macros
 
 import scala.quoted.{ Expr, Quotes, Type }
 
-import anorm.Compat
-
 private[anorm] object Inspect:
 
   /**

core/src/main/scala-3/anorm/macros/ToParameterListImpl.scala

@@ -6,7 +6,7 @@ package anorm.macros
 
 import scala.quoted.{ Expr, Quotes, Type }
 
-import anorm.{ Compat, Macro, NamedParameter, ToParameterList, ToParameterValue, ToSql, ToStatement }
+import anorm.{ Macro, NamedParameter, ToParameterList, ToParameterValue, ToSql, ToStatement }
 
 import Macro.{ debugEnabled, ParameterProjection }
 

core/src/main/scala/anorm/BatchSql.scala

@@ -58,7 +58,7 @@ sealed trait BatchSql {
    */
   @throws[IllegalArgumentException](BatchSqlErrors.MissingParameter)
   @throws[IllegalArgumentException](BatchSqlErrors.ParameterNamesNotMatchingPlaceholders)
-  def addBatchParamsList(args: Compat.Trav[Seq[ParameterValue]]): BatchSql = {
+  def addBatchParamsList(args: Iterable[Seq[ParameterValue]]): BatchSql = {
     if (params.isEmpty) {
       BatchSql.Checked(sql, args.map(Sql.zipParams(sql.paramsInitialOrder, _, Map.empty)))
 
@@ -222,7 +222,7 @@ object BatchSql {
   @throws[IllegalArgumentException](BatchSqlErrors.HeterogeneousParameterMaps)
   @throws[IllegalArgumentException](BatchSqlErrors.ParameterNamesNotMatchingPlaceholders)
   @SuppressWarnings(Array("MethodNames"))
-  private[anorm] def Checked[M](query: SqlQuery, ps: Compat.Trav[Map[String, ParameterValue]]): BatchSql =
+  private[anorm] def Checked[M](query: SqlQuery, ps: Iterable[Map[String, ParameterValue]]): BatchSql =
     ps.headOption.fold(Copy(query, Set.empty, Nil)) { m =>
       val ks = m.keySet
 
@@ -249,7 +249,7 @@ object BatchSql {
 
   /** Get parameter names */
   @annotation.tailrec
-  private def paramNames(ps: Compat.Trav[Map[String, ParameterValue]], ns: Set[String]): Either[String, Set[String]] =
+  private def paramNames(ps: Iterable[Map[String, ParameterValue]], ns: Set[String]): Either[String, Set[String]] =
     ps.headOption match {
       case Some(m) =>
         if (ns.intersect(m.keySet).size != m.size)

core/src/main/scala/anorm/Column.scala

@@ -54,7 +54,7 @@ trait Column[A] extends ((Any, MetaDataItem) => Either[SqlRequestError, A]) { pa
    */
   final def mapResult[B](f: A => Either[SqlRequestError, B]): Column[B] =
     Column[B] { (v: Any, m: MetaDataItem) =>
-      Compat.rightFlatMap(parent(v, m))(f)
+      parent(v, m).flatMap(f)
     }
 
   /**
@@ -365,7 +365,7 @@ object Column extends JavaTimeColumn {
    * }}}
    */
   implicit val columnToBigInt: Column[BigInt] = nonNull { (value, meta) =>
-    Compat.rightMap(anyToBigInteger(value, meta))(BigInt(_))
+    anyToBigInteger(value, meta).map(BigInt(_))
   }
 
   implicit val columnToUUID: Column[UUID] = nonNull { (value, meta) =>
@@ -447,7 +447,7 @@ object Column extends JavaTimeColumn {
    * }}}
    */
   implicit val columnToScalaBigDecimal: Column[BigDecimal] =
-    nonNull((value, meta) => Compat.rightMap(anyToBigDecimal(value, meta))(BigDecimal(_)))
+    nonNull((value, meta) => anyToBigDecimal(value, meta).map(BigDecimal(_)))
 
   /**
    * Parses column as Java Date.
@@ -475,7 +475,7 @@ object Column extends JavaTimeColumn {
 
   implicit def columnToOption[T](implicit transformer: Column[T]): Column[Option[T]] = Column { (value, meta) =>
     if (value != null) {
-      Compat.rightMap(transformer(value, meta))(Some(_))
+      transformer(value, meta).map(Some(_))
     } else Right[SqlRequestError, Option[T]](None)
   }
 

core/src/main/scala/anorm/Cursor.scala

@@ -70,8 +70,8 @@ object Cursor {
   /** Result row to be parsed. */
   private case class ResultRow(metaData: MetaData, data: List[Any]) extends Row {
 
-    override lazy val toString = "Row(" + Compat
-      .lazyZip(metaData.ms, data)
+    override lazy val toString = "Row(" + metaData.ms
+      .lazyZip(data)
       .map((m, v) => s"'${m.column}': ${v} as ${m.clazz}")
       .mkString(", ") + ")"
   }

core/src/main/scala/anorm/MetaData.scala

@@ -27,19 +27,23 @@ private[anorm] case class MetaData(ms: Seq[MetaDataItem]) {
   }
 
   private lazy val dictionary: Map[String, MetaDataItem] =
-    Compat.toMap(ms) { m => m.column.qualified.toUpperCase() -> m }
+    ms.view.map { m => m.column.qualified.toUpperCase() -> m }.to(Map)
 
   private lazy val dictionary2: Map[String, MetaDataItem] =
-    Compat.toMap(ms) { m =>
-      val column = m.column.qualified.split('.').last
+    ms.view
+      .map { m =>
+        val column = m.column.qualified.split('.').last
 
-      column.toUpperCase() -> m
-    }
+        column.toUpperCase() -> m
+      }
+      .to(Map)
 
   private lazy val aliasedDictionary: Map[String, MetaDataItem] =
-    Compat.toFlatMap(ms) { m =>
-      m.column.alias.map(a => Map(a.toUpperCase() -> m)).getOrElse(Map.empty)
-    }
+    ms.view
+      .flatMap { m =>
+        m.column.alias.map(a => Map(a.toUpperCase() -> m)).getOrElse(Map.empty)
+      }
+      .to(Map)
 
   lazy val columnCount = ms.size
 

core/src/main/scala/anorm/Row.scala

@@ -23,8 +23,8 @@ trait Row {
    *
    * @see #as
    */
-  lazy val asList: List[Any] = Compat
-    .lazyZip(data, metaData.ms)
+  lazy val asList: List[Any] = data
+    .lazyZip(metaData.ms)
     .map { (v, m) =>
       if (m.nullable) Option(v) else v
     }
@@ -42,12 +42,15 @@ trait Row {
    * @see #as
    */
   lazy val asMap: Map[String, Any] =
-    Compat.toMap(Compat.lazyZip(data, metaData.ms)) {
-      case (v, m) =>
-        val k = m.column.qualified
+    data
+      .lazyZip(metaData.ms)
+      .map {
+        case (v, m) =>
+          val k = m.column.qualified
 
-        if (m.nullable) k -> Option(v) else k -> v
-    }
+          if (m.nullable) k -> Option(v) else k -> v
+      }
+      .to(Map)
 
   /**
    * Returns row as `T`.
@@ -117,10 +120,13 @@ trait Row {
 
   // Data per column name
   private lazy val columnsDictionary: Map[String, Any] =
-    Compat.toMap(Compat.lazyZip(metaData.ms, data)) {
-      case (m, v) =>
-        m.column.qualified.toUpperCase -> v
-    }
+    metaData.ms
+      .lazyZip(data)
+      .map {
+        case (m, v) =>
+          m.column.qualified.toUpperCase -> v
+      }
+      .to(Map)
 
   // Data per column alias
   private lazy val aliasesDictionary: Map[String, Any] = {
@@ -138,7 +144,7 @@ trait Row {
    * @param a Column qualified name, or label/alias
    */
   private[anorm] def get(a: String): Either[SqlRequestError, (Any, MetaDataItem)] =
-    Compat.rightFlatMap(metaData.get(a.toUpperCase).toRight(ColumnNotFound(a, this))) { m =>
+    metaData.get(a.toUpperCase).toRight(ColumnNotFound(a, this)).flatMap { m =>
       def d = if (a.indexOf(".") > 0) {
         // if expected to be a qualified (dotted) name
         columnsDictionary.get(m.column.qualified.toUpperCase).orElse(m.column.alias.flatMap(aliasesDictionary.get(_)))
@@ -149,13 +155,13 @@ trait Row {
           .orElse(columnsDictionary.get(m.column.qualified.toUpperCase))
       }
 
-      Compat.rightMap(d.toRight(ColumnNotFound(m.column.qualified, metaData.availableColumns))) { _ -> m }
+      d.toRight(ColumnNotFound(m.column.qualified, metaData.availableColumns)).map { _ -> m }
     }
 
   /** Try to get data matching index. */
   private[anorm] def getIndexed(i: Int): Either[SqlRequestError, (Any, MetaDataItem)] =
-    Compat.rightFlatMap(metaData.ms.lift(i).toRight(ColumnNotFound(s"#${i + 1}", metaData.availableColumns))) { m =>
-      Compat.rightMap(data.lift(i).toRight(ColumnNotFound(m.column.qualified, metaData.availableColumns))) { _ -> m }
+    metaData.ms.lift(i).toRight(ColumnNotFound(s"#${i + 1}", metaData.availableColumns)).flatMap { m =>
+      data.lift(i).toRight(ColumnNotFound(m.column.qualified, metaData.availableColumns)).map { _ -> m }
     }
 }
 

core/src/main/scala/anorm/SqlParser.scala

@@ -28,9 +28,7 @@ object SqlParser extends FunctionAdapter with DeprecatedSqlParser {
           v <- row.data.headOption
         } yield v -> m).toRight(NoColumnsInReturnedResult)
 
-        val parsed = Compat.rightFlatMap[SqlMappingError, SqlRequestError, (Any, MetaDataItem), T](input) { in =>
-          parseColumn(c, in)
-        }
+        val parsed = input.flatMap { in => parseColumn(c, in) }
 
         parsed.fold(Error(_), Success(_))
       }
@@ -488,10 +486,9 @@ object SqlParser extends FunctionAdapter with DeprecatedSqlParser {
    */
   def get[T](name: String)(implicit @deprecatedName(Symbol("extractor")) c: Column[T]): RowParser[T] = RowParser {
     row =>
-      Compat
-        .rightFlatMap(row.get(name)) { in =>
-          parseColumn(c, in)
-        }
+      row
+        .get(name)
+        .flatMap { in => parseColumn(c, in) }
         .fold(Error(_), Success(_))
   }
 
@@ -511,10 +508,9 @@ object SqlParser extends FunctionAdapter with DeprecatedSqlParser {
    */
   def get[T](position: Int)(implicit @deprecatedName(Symbol("extractor")) c: Column[T]): RowParser[T] =
     RowParser { row =>
-      Compat
-        .rightFlatMap(row.getIndexed(position - 1)) { in =>
-          parseColumn(c, in)
-        }
+      row
+        .getIndexed(position - 1)
+        .flatMap { in => parseColumn(c, in) }
         .fold(Error(_), Success(_))
     }
 

core/src/main/scala/anorm/ToSql.scala

@@ -74,8 +74,8 @@ object ToSql {
   /**
    * Returns fragment for each value, separated by ", ".
    */
-  implicit def streamToSql[A](implicit conv: ToSql[A] = ToSql.missing[A]): ToSql[Compat.LazyLst[A]] =
-    traversableToSql[A, Compat.LazyLst[A]]
+  implicit def streamToSql[A](implicit conv: ToSql[A] = ToSql.missing[A]): ToSql[LazyList[A]] =
+    traversableToSql[A, LazyList[A]]
 
   /**
    * Returns fragment for each value, separated by ", ".
@@ -109,7 +109,7 @@ object ToSql {
       sql._1.toString -> sql._2
     }
 
-  @inline private def traversableToSql[A, T <: Compat.Trav[A]](implicit conv: ToSql[A]) = ToSql[T] { values =>
+  @inline private def traversableToSql[A, T <: Iterable[A]](implicit conv: ToSql[A]) = ToSql[T] { values =>
     val c: A => (String, Int) =
       if (conv == null) _ => "?" -> 1 else conv.fragment