I would like to read a CSV String/File in Scala such that given a case class C
and an error type Error
, the parser fills an Iterable[Either[Error,C]]
. Is there any library that does this or something similar?
For instance, given a class and error
case class Person(name: String, age: Int)
type Error = String
and the CSV String
Foo,19
Ro
Bar,24
the parser would output
Stream(Right(Person("Foo",1)), Left("Cannot read 'Ro'"), Right(Person("Bar", 24)))
UPDATE:
I think my question wasn't clear, so let me clarify: is there a way read CSV in Scala without defining boilerplate? Given any case class, is there a way to load it automatically? I would like to use it in this way:
val iter = csvParserFor[Person].parseLines(lines)
Here's a Shapeless implementation that takes a slightly different approach from the one in your proposed example. This is based on some code I've written in the past, and the main difference from your implementation is that this one is a little more general—for example the actual CSV parsing part is factored out so that it's easy to use a dedicated library.
First for an all-purpose Read
type class (no Shapeless yet):
import scala.util.{ Failure, Success, Try }
trait Read[A] { def reads(s: String): Try[A] }
object Read {
def apply[A](implicit readA: Read[A]): Read[A] = readA
implicit object stringRead extends Read[String] {
def reads(s: String): Try[String] = Success(s)
}
implicit object intRead extends Read[Int] {
def reads(s: String) = Try(s.toInt)
}
// And so on...
}
And then for the fun part: a type class that provides a conversion (that may fail) from a list of strings to an HList
:
import shapeless._
trait FromRow[L <: HList] { def apply(row: List[String]): Try[L] }
object FromRow {
import HList.ListCompat._
def apply[L <: HList](implicit fromRow: FromRow[L]): FromRow[L] = fromRow
def fromFunc[L <: HList](f: List[String] => Try[L]) = new FromRow[L] {
def apply(row: List[String]) = f(row)
}
implicit val hnilFromRow: FromRow[HNil] = fromFunc {
case Nil => Success(HNil)
case _ => Failure(new RuntimeException("No more rows expected"))
}
implicit def hconsFromRow[H: Read, T <: HList: FromRow]: FromRow[H :: T] =
fromFunc {
case h :: t => for {
hv <- Read[H].reads(h)
tv <- FromRow[T].apply(t)
} yield hv :: tv
case Nil => Failure(new RuntimeException("Expected more cells"))
}
}
And finally to make it work with case classes:
trait RowParser[A] {
def apply[L <: HList](row: List[String])(implicit
gen: Generic.Aux[A, L],
fromRow: FromRow[L]
): Try[A] = fromRow(row).map(gen. from)
}
def rowParserFor[A] = new RowParser[A] {}
Now we can write the following, for example, using OpenCSV:
case class Foo(s: String, i: Int)
import au.com.bytecode.opencsv._
import scala.collection.JavaConverters._
val reader = new CSVReader(new java.io.FileReader("foos.csv"))
val foos = reader.readAll.asScala.map(row => rowParserFor[Foo](row.toList))
And if we have an input file like this:
first,10
second,11
third,twelve
We'll get the following:
scala> foos.foreach(println)
Success(Foo(first,10))
Success(Foo(second,11))
Failure(java.lang.NumberFormatException: For input string: "twelve")
(Note that this conjures up Generic
and FromRow
instances for every line, but it'd be pretty easy to change that if performance is a concern.)
kantan.csv seems like what you want. If you want 0 boilerplate, you can use its shapeless module and write:
import kantan.csv.ops._
import kantan.csv.generic.codecs._
new File("path/to/csv").asCsvRows[Person](',', false).toList
Which, on your input, will yield:
res2: List[kantan.csv.DecodeResult[Person]] = List(Success(Person(Foo,19)), DecodeFailure, Success(Person(Bar,24)))
Note that the actual return type is an iterator, so you don't actually have to hold the whole CSV file in memory at any point like your example does with Stream
.
If the shapeless dependency is too much, you can drop it and provide your own case class type classes with minimal boilerplate:
implicit val personCodec = RowCodec.caseCodec2(Person.apply, Person.unapply)(0, 1)
Full disclosure: I'm the author of kantan.csv.
Starting Scala 2.13
, it's possible to pattern match a String
s by unapplying a string interpolator:
// case class Person(name: String, age: Int)
val csv = "Foo,19\nRo\nBar,24".split("\n")
csv.map {
case s"$name,$age" => Right(Person(name, age.toInt))
case line => Left(s"Cannot read '$line'")
}
// Array(Right(Person("Foo", 19)), Left("Cannot read 'Ro'"), Right(Person("Bar", 24)))
Note that you can also use regex
es within the extractor.
It could help in our case to consider a row invalid if the age isn't an integer:
// val csv = "Foo,19\nRo\nBar,2R".split("\n")
val Age = "(\\d+)".r
csv.map {
case s"$name,${Age(age)}" => Right(Person(name, age.toInt))
case line @ s"$name,$age" => Left(s"Age is not an integer in '$line'")
case line => Left(s"Cannot read '$line'")
}
//Array(Right(Person("Foo", 19)), Left("Cannot read 'Ro'"), Left("Age is not an integer in 'Bar,2R'"))
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With