Cannot convert HList to tuple after Shapeless FoldRight

Question

I'm trying to create a parser of CSV files using Scala into a case class and I'm trying to make it generic using Shapeless.

I want my parser to allow the user to specify an extraction function extract: CsvRow => String rather than having aa 1-to-1 correspondence and typeclasses for specific field types because the files I'm parsing are in different formats and a parsing operation that works for one file doesn't work for another. I thought if I can avoid this step by first doing a "dumb" parsing and then applying the conversion functions but at the end of the day I'm simply shifting where this problem needs to be solved.

After this I want to convert my resulting HList into a tuple and do a mapN to create a new instance of a case class

I tried several strategies but I always have something that doesn't work. I found very helpful this specific answer that I adapted below.

At the moment I keep getting

could not find implicit value for parameter tupler

when I try to convert the resulting HList into a tuple. I notice that my resulting HList terminates in HNil.type instead of HNil that is what I would expect

UPDATE: I added a more complete code on Scastie with more comments and data.

Versions:

• SBT 1.2.8
• Scala 2.13.0
• Shapeless 2.3.3

import CsvDefinitions._
import CsvTypeParser._
import CsvConverter._
import cats.data._
import cats.implicits._
import scala.util.Try
import shapeless._
import shapeless.ops.hlist.RightFolder
import shapeless.syntax.std.tuple._

object CsvDefinitions {
  type CsvRow = List[String]
  type CsvValidated[A] = ValidatedNec[Throwable, A]
  // A parser is a function that given a row returns a validted result
  type CsvRowParser[A] = Kleisli[CsvValidated, CsvRow, A]
}

trait CsvTypeParser[A] {
  def parseCell(cell: String): CsvValidated[A]
}

object CsvTypeParser {
  def parse[A](extract: CsvRow => String)(implicit parser: CsvTypeParser[A]): CsvRowParser[A] =
    Kleisli { row =>
      val extracted = Try(extract(row)).toEither.toValidatedNec
      val parsed = parser.parseCell _
      (extracted) andThen parsed
    }
  def apply[A](f: String => A): CsvTypeParser[A] = new CsvTypeParser[A] {
    def parseCell(cell: String): CsvValidated[A] = Try(f(cell)).toEither.toValidatedNec
  }
  implicit val stringParser: CsvTypeParser[String] = CsvTypeParser[String] {
    _.trim
  }
  implicit val intParser: CsvTypeParser[Int] = CsvTypeParser[Int] {
    _.trim.toInt
  }
  implicit val doubleParser: CsvTypeParser[Double] = CsvTypeParser[Double] {
    _.trim.toDouble
  }
}

object CsvConverter {
  // The following has been adapted from https://stackoverflow.com/a/25316124:
  private object ApplyRow extends Poly2 {
    // The "trick" here is to pass the row as the initial value of the fold and carry it along
    // during the computation. Inside the computation we apply a parser using row as parameter and
    // then we append it to the accumulator.
    implicit def aDefault[T, V <: HList] = at[CsvRowParser[T], (CsvRow, V)] {
      case (rowParser, (row, accumulator)) => (row, rowParser(row) :: accumulator)
    }
  }

  def convertRowGeneric[
    HP <: HList,    // HList Parsers
    HV <: HList](   // HList Validated
      input: HP,
      row: CsvRow)(
      implicit
        // I tried to use the RightFolder.Aux reading https://stackoverflow.com/a/54417915
        folder: RightFolder.Aux[
          HP,                   // Input type
          (CsvRow, HNil.type),  // Initial value of accumulator
          ApplyRow.type,        // Polymorphic function
          (CsvRow, HV)          // Result type
        ]
      ): HV = {
    input.foldRight((row, HNil))(ApplyRow)._2
  }
}

// Case class containing the final result of the conversion
case class FinalData(id: Int, name: String, score: Double)

object Main extends App {

  // Definition of parsers and how they obtain the value to parse
  val parsers =
    parse[Int   ](r => r(0)) ::          // Extract field 0 and convert it to Int
    parse[String](r => r(1)+" "+r(2)) :: // Get field 1 and 2 together
    parse[Double](r => r(3).trim) ::     // Trim field 3 before converting to double
    HNil

  // One line in the CSV file
  val row = List("123", "Matt", "Smith", "45.67")

  val validated = convertRowGeneric(parsers, row)
  println(validated)  

  // Could not find implicit value for parameter tupler
  // The "validated" HList terminates with HNil.type
  val finalData = validated
    .tupled
    .mapN(FinalData)
  println(finalData)
}

Answer 1

Fix convertRowGeneric (replace type HNil.type with HNil and value HNil with ascription HNil: HNil )

def convertRowGeneric[
  HP <: HList,    // HList Parsers
  HV <: HList](   // HList Validated
                  input: HP,
                  row: CsvRow)(
                implicit
                folder: RightFolder.Aux[
                  HP,                   // Input type
                  (CsvRow, HNil),  // Initial value of accumulator
                  ApplyRow.type,        // Polymorphic function
                  (CsvRow, HV)          // Result type
                ]
              ): HV = {
  input.foldRight((row, HNil: HNil))(ApplyRow)._2
}