类型化 Scala 对象如何丢失其类型？

Question

In the following piece of code, entities is a Map[String, Seq[String]] object that I receive from some other piece of code. The goal is to map the entities object into a two column Spark DataFrame; but, before I get there, I found some very unusual results.

val data: Map[String, Seq[String]] = Map("idtag" -> Seq("things", "associated", "with", "id"))

println(data)
println(data.toSeq)
data.toSeq.foreach{println}
data.toSeq.map{case(id: String, names: Seq[String]) => names}.foreach{println}

val eSeq: Seq[(String, Seq[String])] = entities.toSeq

println(eSeq.head)
println(eSeq.head.getClass)
println(eSeq.head._1.getClass)
println(eSeq.head._2.getClass)

eSeq.map{case(id: String, names: Seq[String]) => names}.foreach{println}

The output of the above on the console is:

Map(idtag -> List(things, associated, with, id))
ArrayBuffer((idtag,List(things, associated, with, id)))
(idtag,List(things, associated, with, id))
List(things, associated, with, id)

(0CY4NZ-E,["MEC", "Marriott-MEC", "Media IQ - Kimberly Clark c/o Mindshare", "Mindshare", "WPP", "WPP Plc", "Wavemaker Global", "Wavemaker Global Ltd"])
class scala.Tuple2
class java.lang.String
class java.lang.String
Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to scala.collection.Seq
        at package.EntityList$$anonfun$toStorage$4.apply(EntityList.scala:31)

The data object that I hardcoded acts as expected. The .toSeq function on the entities map produces a Seq (implemented as an ArrayBuffer) of tuples; and these tuples can be processed through mapping.

But using the entities object, you can see that when I take the first element using .head and it is a Tuple2[String, String] . How can that possibly happen? How does the second element of the tuple turn into a String and cause the exception?

Further confusing me, if the last line is changed to reflect the Tuple2[String, String] :

eSeq.map{case(id: String, names: String) => names}.foreach{println}

then we get a compile error:

/path/to/repo/src/main/scala/package/EntityList.scala:31: error: pattern type is incompatible with expected type;
  found   : String
  required: Seq[String]
     eSeq.map{case(id: String, names: String) => names}.foreach{println}

I can't replicate this odd behavior with a Map[String, Seq[String]] that I create myself, as you can see in this code. Can anyone explain this behavior and why it happens?

Answer 1

The problem appears to be that entities.toSeq is lying about the type of the data that it is returning, so I would look at "some other piece of code" and check it is doing the right thing.

Specifically, it claims to return Seq[(String, Seq[String])] and the compiler believes it. But getClass shows that the second object in the tuple is actually java.lang.String not Seq[String] .

If this were correct then the match statement would be using unapply to extract the value and then getting an error when it tried to convert names to the stated type.

I note that the string appears to be a list of strings enclosed in [ ] , so it seems possible that whatever is creating entities is failing to parse this into a Seq but claiming that it has succeeded.