Scala generic invocation on overloaded methods - scala

Question

I am new to Scala - and while generating Excel files with Apache POI, I tried removing duplication in my code via this generic:
def addCell[A](
row: org.apache.poi.ss.usermodel.Row,
idxColumn: Int,
data: A)
:
Unit =
{
row.createCell(idxColumn).setCellValue(data)
}
Unfortunately, the compiler reported:
[error] .../mycode.scala:32: overloaded method value setCellValue \
with alternatives:
[error] (x$1: Boolean)Unit <and>
[error] (x$1: String)Unit <and>
[error] (x$1: org.apache.poi.ss.usermodel.RichTextString)Unit <and>
[error] (x$1: java.util.Calendar)Unit <and>
[error] (x$1: java.util.Date)Unit <and>
[error] (x$1: Double)Unit
[error] cannot be applied to (A)
[error] row.createCell(idxColumn).setCellValue(data)
[error] ^
[error] one error found
[error] (compile:compile) Compilation failed
I don't get it - whoever calls addCell will be passing a specific type A (the type of the 3rd argument, data) so the generic form should be able to dispatch to the proper overloaded form of setCellValue.
I am probably missing something obvious - any help most appreciated.
EDIT: To make it clear - my code is currently doing this:
field match {
case i:Int => row.createCell(idxCol).setCellValue(i)
case l:Long => row.createCell(idxCol).setCellValue(l)
case f:Float => row.createCell(idxCol).setCellValue(f)
case d:Double => row.createCell(idxCol).setCellValue(d)
case s:String => row.createCell(idxCol).setCellValue(s)
...
And I'd like to avoid the obvious repetition via a generic call to something like
field match {
case i:Int => setCell(row, idxCol, i)
case l:Long => setCell(row, idxCol, l)
case f:Float => setCell(row, idxCol, f)
...
Is it possible?

Answer 1

The most straightforward way is writing a separate method for each type:
def addCell(
row: org.apache.poi.ss.usermodel.Row,
idxColumn: Int,
data: Boolean)
:
Unit =
{
row.createCell(idxColumn).setCellValue(data)
}
def addCell(
row: org.apache.poi.ss.usermodel.Row,
idxColumn: Int,
data: String)
:
Unit =
{
row.createCell(idxColumn).setCellValue(data)
}
This is OK if you need just addCell to write this way.
If you need some code for more methods, you may consider a more advanced approach that limits the boilerplate per method.
A sketch of the more advanced approach:
Define a cellSetter trait, which can set a value of given type to the cell.
trait CellSetter[A]{
def setCell(cell: Cell, data: A): Unit
}
Implement CellSetters for all the relevant types, e.g.:
implicit val stringCellSetter = new CellSetter[String](){
def setCell(cell: Cell, data: String){
cell.setCellValue(data)
}
}
Make some sugar:
implicit class RichCell(cell: Cell){
def setCellValue[A](data: A)(implicit cellSetter: CellSetter[A]) = cellSetter.setCell(cell, data)
}
Create some nice generic code for addCell:
def addCell[A: CellSetter](
row: org.apache.poi.ss.usermodel.Row,
idxColumn: Int,
data: A)
:
Unit =
{
row.createCell(idxColumn).setCellValue(data)
}

Answer 2

Not that I ever do anything like this, but I was curious whether specialization helps.
Minimally, you'd like to avoid boxing the primitives.
It turns out that specialization doesn't help much, because specialized methods don't dispatch to unspecialized ones. I think I've read about this problem before.
In the following, specializing add works OK. One version uses a ClassTag to select a reference type, or the other one handles primitives. But the commented-out code just calls setCellValue(Any); it's not true that the boolean version calls setCellValue(Boolean).
The version commented-in seems to crash the back-end...
import scala.reflect.ClassTag
import java.util.Date
trait Setter {
def setCellValue(b: Boolean) = println("bool")
def setCellValue(s: String) = println("str")
def setCellValue(n: Double) = println("double")
def setCellValue(d: Date) = println("date")
}
object Test extends App {
def add[#specialized(Boolean, Double) A <: AnyVal](s: Setter, a: A) = {
/*
class ASetter extends Setter {
override def setCellValue(b: Boolean) = s setCellValue b
override def setCellValue(n: Double) = s setCellValue n
def setCellValue(x: Any) = ???
}
(new ASetter) setCellValue a
*/
a match {
case b: Boolean => s setCellValue b
case d: Double => s setCellValue d
case _ => ???
}
}
def add[A: ClassTag](s: Setter, a: A) = a match {
//case _: Boolean | _: Double => s setCellValue a
case d: Date => s setCellValue d
case x: String => s setCellValue x
case _ => ???
}
val s = new Setter {}
add(s, new Date)
add(s, true)
}