No Implicit arguments of Type: Any - scala

Question

I followed this article to create union types. The articles has few answers about the Primitive type but my scenario is an extension to it.
So, I am trying to define a method which takes Map[String, A] where A is the set of allowed type.
This is my class of union types:
sealed trait SupportedType[A]
object SupportedType {
implicit val byteBufferColumn : SupportedType[ByteBuffer] = new SupportedType[ByteBuffer] {}
implicit val longColumn : SupportedType[java.lang.Long] = new SupportedType[java.lang.Long] {}
implicit val byteArrayColumn : SupportedType[Array[Byte]] = new SupportedType[Array[Byte]] {}
implicit val stringColumn : SupportedType[String] = new SupportedType[String] {}
}
This is my method I defined:
def upsert[A: SupportedType](key: T, values: Map[String, A], timestamp: Long, ttl: Duration): Future[Unit]
This is how I am calling the method:
dataStore.upsert(
cacheKey,
Map(
itColumn -> ByteBuffer.wrap(Utils.compress(iti.toByteArray)),
cacheWriteTimeColumn -> writeTime.toEpochMilli
),
writeTime.toEpochMilli,
ttl
)
error: No implicit arguments of type: SupportedType[Any]
My guess is writeTime.toEpochMilli returns java.long type and as you can see in SupportedType, I tried to define java.lang.Long but thats not working.
Any help would be appreciated.

Answer 1

You can use the magnet pattern in combination to a typeclass like this:
import scala.language.implicitConversions
trait ColumnValue {
def serialize(): String
}
object ColumnValue {
trait SupportedType[A] {
def toColumn(a: A): ColumnValue
}
object SupportedType {
implicit final val stringSupportedType: SupportedType[String] =
new SupportedType[String] {
override def toColumn(str: String): ColumnValue =
new ColumnValue {
override def serialize(): String =
"\"" + str + "\""
}
}
implicit final val intSupportedType: SupportedType[Int] =
new SupportedType[Int] {
override def toColumn(int: Int): ColumnValue =
new ColumnValue {
override def serialize(): String =
int.toString
}
}
implicit final val booleanSupportedType: SupportedType[Boolean] =
new SupportedType[Boolean] {
override def toColumn(bool: Boolean): ColumnValue =
new ColumnValue {
override def serialize(): String =
if (bool) "1" else "0"
}
}
implicit final def listSupportedType[A](implicit ev: SupportedType[A]): SupportedType[List[A]] =
new SupportedType[List[A]] {
override def toColumn(list: List[A]): ColumnValue =
new ColumnValue {
override def serialize(): String =
list.map(a => ev.toColumn(a).serialize()).mkString("[", ",", "]")
}
}
}
def apply[A](a: A)(implicit ev: SupportedType[A]): ColumnValue =
ev.toColumn(a)
implicit def supportedType2Column[A : SupportedType](a: A): ColumnValue =
apply(a)
}
You may create some helper functions to reduce some of the boilerplate.
Which can be used like this:
final case class Table(data: Map[String, ColumnValue]) {
def upsert(values: Map[String, ColumnValue]): Table =
copy(this.data ++ values)
}
object Table {
val empty: Table =
Table(data = Map.empty)
}
val result = Table.empty.upsert(Map(
"a" -> "foo",
"b" -> 10,
"c" -> List(true, false, true)
))
See the code running here.