Konvertieren Sie eine Seq [String] auf typsichere Weise in eine Case-Klasse

Ich habe einen Parser geschrieben, der einen String nach einigen Regeln in einen Seq [String] umwandelt. Dies wird in einer Bibliothek verwendet.

Ich versuche, diese Seq [String] in eine Case-Klasse umzuwandeln. Die Fallklasse wird vom Benutzer bereitgestellt (daher kann nicht erraten werden, wie sie lauten wird).

Ich habe an eine formlose Bibliothek gedacht, weil sie die guten Funktionen zu implementieren scheint und ausgereift zu sein scheint, aber ich habe keine Ahnung, wie ich vorgehen soll.

Ich habe diese Frage gefundenmit einer interessanten Antwort aber ich finde nicht, wie ich es für meine Bedürfnisse umwandeln kann. Tatsächlich gibt es in der Antwort nur einen Typ zum Parsen (String), und die Bibliothek iteriert innerhalb des Strings. Es erfordert wahrscheinlich eine tiefgreifende Änderung in der Art und Weise, wie die Dinge gemacht werden, und ich habe keine Ahnung, wie.

Darüber hinaus möchte ich dem Benutzer meiner Bibliothek diesen Vorgang nach Möglichkeit so einfach wie möglich gestalten. Im Gegensatz zu der Antwort im obigen Link würde der HList-Typ nach Möglichkeit von der Case-Klasse selbst stammen (meiner Suche nach scheint der Compiler diese Informationen zu benötigen).

Ich bin ein bisschen neu im Typensystem und all diesen schönen Dingen, wenn mir jemand einen Rat geben kann, wie es geht, würde ich mich sehr freuen!

Mit freundlichen Grüßen

--- EDIT ---

Wie im Zickzack gewünscht, sind hier einige mögliche Unterschriften:

//Let's say we are just parsing a CSV.

@onUserSide
case class UserClass(i:Int, j:Int, s:String)
val list = Seq("1,2,toto", "3,4,titi")

// User transforms his case class to a function with something like:
val f = UserClass.curried

// The function created in 1/ is injected in the parser
val parser = new Parser(f)

// The Strings to convert to case classes are provided as an argument to the parse() method.
val finalResult:Seq[UserClass] = parser.parse(list) 
// The transfomation is done in two steps inside the parse() method:
// 1/ first we have: val list = Seq("1,2,toto", "3,4,titi")
// 2/ then we have a call to internalParserImplementedSomewhereElse(list)
//    val parseResult is now equal to Seq(Seq("1", "2", "toto"), Seq("3","4", "titi"))
// 3/ finally Shapeless do its magick trick and we have Seq(UserClass(1,2,"toto"), UserClass(3,4,"titi))



@insideTheLibrary
class Parser[A](function:A) {

 //The internal parser takes each String provided through argument of the method and transforms each String to a Seq[String]. So the Seq[String] provided is changed to Seq[Seq[String]]. 
 private def internalParserImplementedSomewhereElse(l:Seq[String]): Seq[Seq[String]] = {
  ...
 }

 /*
 * Class A and B are both related to the case class provided by the user: 
 * - A is the type of the case class as a function, 
 * - B is the type of the original case class (can be guessed from type A).
 */
 private def convert2CaseClass[B](list:Seq[String]): B {
    //do  something with Shapeless
    //I don't know what to put inside ???
 }

 def parse(l:Seq[String]){
   val parseResult:Seq[Seq[String]] = internalParserImplementedSomewhereElse(l:Seq[String])
   val finalResult = result.map(convert2CaseClass)
   finalResult // it is a Seq[CaseClassProvidedByUser]       
 }
}    

In der Bibliothek stehen implizite Optionen zur Verfügung, mit denen der String in den richtigen Typ konvertiert werden kann, der von Shapeless erraten wird (ähnlich der im obigen Link vorgeschlagenen Antwort). Wie string.toInt, string.ToDouble und so weiter ...

Möglicherweise gibt es andere Möglichkeiten, es zu gestalten. Es ist genau das, was ich mir vorgestellt habe, nachdem ich einige Stunden mit Shapeless gespielt habe.