Scala polymorphic method (or higher kind??) - scala

Question

I want to define a compression method that compresses a collection of a certain type Int or String into a string. I wanted to combine the two methods that I currently have:
def compressString[T <: IndexedSeq[String]]: (T) =>
String = (array: T) => array.mkString(" ")
def compressInt[T <: IndexedSeq[Int]]: (T) =>
String = (array: T) => array.mkString(" ")
Into one method. I tried to do higher kinded type with T[Int] but it didn't work that way. I also tried to do:
def compress[U, T <: IndexedSeq[U]]: (T) => String =
(array: T) => array.mkString(" ")
However, the compiler gives me this error:
[error] type mismatch;
[error] found : Iterator[Int(in method compress)]
[error] required: Iterator[scala.Int]
[error] collect(array.iterator, Vector.empty[String], 0).mkString("\t")
[error] ^
[error] SVM.scala:55: type mismatch;
[error] found : java.lang.String
[error] required: String(in method compress)
[error] override def compress[String, T <: IndexedSeq[String]]: (T) => String = (array: T) => array.mkString("\t")
In general, I want to eventually override this method and provide concrete implementation (the method that deals with Int is different from String). How do I combine these two methods??

Answer 1

In order to make your generic method compile, you need to pass the first type argument as the type of IndexedSeq, i.e.
def compress[U, T <: IndexedSeq[U]]: (T) => String = {
(array: T) => array.mkString(" ")
}
then you can invoke it like,
val strings = compress[String,Vector[String]](Vector("a","b")) // strings: String = a b
val ints = compress[Int,Vector[Int]](Vector(1,2)) // ints: String = 1 2
However, I think a type class would fit much better in the case that you want to have ad hoc polymorphism.
For example, you can define the following type class:
#implicitNotFound("No compressor found for type ${T}")
trait Compressor[T] {
def compress(array: IndexedSeq[T]): String
}
and create an implementation for every type that you want to support compression
implicit val stringCompressor = new Compressor[String] {
override def compress(array: IndexedSeq[String]): String = array.mkString(" ")
}
implicit val intCompressor = new Compressor[Int] {
override def compress(array: IndexedSeq[Int]): String = array.mkString(" ")
}
then you can call the methods directly
val strings = stringCompressor.compress(Vector("a","b")) // strings: String = a b
val ints = intCompressor.compress(Vector(1,2)) // ints: String = 1 2
or you can define a generic method that takes an implicit parameter
def compress[T](array: IndexedSeq[T])(implicit compressor: Compressor[T]): String = {
compressor.compress(array)
}
// or equivalently
def compress[T: Compressor](array: IndexedSeq[T]): String = {
implicitly[Compressor[T]].compress(array)
}
and use like this
val strings = compress(Vector("a","b")) // strings: String = a b
val ints = compress(Vector(1,2)) // ints: String = 1 2
if there is no implicit compressor defined in the scope, the compiler will give you an error, e.g.
compress(Vector(true, false))
error: No compressor found for type Boolean
compress(Vector(true, false))
^
Hope it helps.