Scala这个“_1”的类型是什么？

Question

I would like to understand this error:

found   : row.type (with underlying type _#TableElementType)
required: _1#TableElementType

Looks like I was very close, but what is this "1" in _1#TableElementType ? Can I convert one in the other?

Edit : useful bits of codes for context (Play + Slick):

abstract class GenericDAO[T <: AbstractTable[_]](...) {
  def table: TableQuery[T]
  def insert(model: T#TableElementType) = db run (table += model)
}

trait TableObject[T <: AbstractTable[_]] {
  def rowFromJson(jsObject: JsObject): T#TableElementType
  def dao(driver: JdbcProfile, db: Database): GenericDAO[T]
}

// Controller Action with an instance implementing `tableObject` above:
val tableObject = tableObjectFactory("test")
val row = tableObject.rowFromJson(request.body.asJson.get)
val dao = tableObject.dao(driver, db)  // tableObject has a DOA extending GenericDAO
dao.insert(row)

Example of tableObject :

object TestTable extends TableObject[Test] {
  def dao(driver: JdbcProfile, db: Database) = new TestDAO(driver, db)
  def rowFromJson(j: JsObject): TestRow = { TestRow(...) }
  class TestDAO(...) extends GenericDAO[Test](driver, db) { ... }
}

I use a factory to get the right one from the url:

object TableObjectFactory {
  def tableObjectFactory(name: String) = {
    name match {
      case "test" => TestTable
      case "projects" => ProjectsTable
      case "people" => PeopleTable
      ...
    }
  }
}

Answer 1

Although it doesn't explain much, it works if I make the DAO parse the request body and insert, instead of producing the row object separately and applying one of the DAO's methods on it.

I got all kinds of similar errors with names such as _$1#TableElementType , _1$u#TableElementType etc., but I think they are compiler aliases for different instances of the same class.

So the solution was to do

val j: JsValue = request.body.asJson.get
val tableObject: TableObject[_] = tableObjectFactory(table)
val dao = tableObject.dao(driver, db)
val res: Future[Int] = dao.insert(j)

where this new insert method now is abstract in GenericDAO , and in the concrete implementations takes a JsValue and parses it, then inserts:

class TestDAO(override val driver: JdbcProfile, override val db: Database) extends GenericDAO[Test](driver, db) {
  import this.driver.api._

  val table = TableQuery[Test]

  //def insert(model: TestRow) = db run (table += model)   // NO!

  def insert(j: JsValue): Future[Int] = {
    val row = TestRow(
      (j \ "id").as[Int],
      (j \ "name").as[String],
      (j \ "value").as[Float],
      (j \ "other").as[String]
    )
    db run (table += row)
  }
}

At the same time, it makes Play forms completely useless, which is a good thing anyway.