Scala類型推斷限制

Question

我正在開發一個ORM風格的庫在ReactiveMongo之上。目前我試圖實現一個嵌套的文檔表示 - 但是我一直堅持Scala的類型推理爲我的課程。我對Scala相當陌生，所以每一個幫助都是值得歡迎的。

這是我的嘗試：

trait MongoDocument[T <: MongoDocument[T]] { 
    self: T => 

    val db: DefaultDB 
    val collection: String 

    var fields: List[MongoField[T,_]] = List.empty 
    def apply(doc: TraversableBSONDocument): T = { // loads the content of supplied document 
    fields.foreach { field => 
     doc.get(field.field).foreach(field.load(_)) 
    } 
    this 
    } 
} 
trait MongoMetaDocument[T <: MongoDocument[T]] extends MongoDocument[T] { 
    self: T => 

    type DocType = T 

    protected val clazz = this.getClass.getSuperclass 
    def create: T = clazz.newInstance().asInstanceOf[T] 

    def find(id: String): Future[Option[T]] = { 
    db(collection).find(BSONDocument("_id" -> BSONObjectID(id))) 
     .headOption().map(a => a.map(create.apply(_))) 
    } 
} 

abstract class MongoField[Doc <: MongoDocument[Doc], T](doc: MongoDocument[Doc], val field: String) { 
    var value: Option[T] = None 

    def is: Option[T] = value 
    def apply(in: T) { value = Some(in) } 
    def unset() { value = None } 

    def load(bson: BSONValue) 

    doc.fields ::= this 
} 

class MongoInteger[Doc <: MongoDocument[Doc]](doc: Doc, field: String) 
    extends MongoField[Doc, Int](doc, field) { 

    def load(bson: BSONValue) { value = Try(bson.asInstanceOf[BSONNumberLike].toInt).toOption } 
} 

class MongoDoc[Doc <: MongoDocument[Doc], SubDocF <: MongoMetaDocument[SubDoc], SubDoc <: MongoDocument[SubDoc]](doc: Doc, field: String, meta: SubDocF) 
    extends MongoField[Doc, SubDocF#DocType](doc, field) { 

    def load(bson: BSONValue) { 
    value = Try(bson.asInstanceOf[TraversableBSONDocument]).toOption.map { doc => 
     meta.create.apply(doc) 
    } 
    } 
} 

假設我有以下代碼：

class SubEntity extends MongoDocument[SubEntity] { 
    val db = Db.get 
    val collection = "" 

    val field = new MongoInteger(this, "field") 
} 
object SubEntity extends SubEntity with MongoMetaDocument[SubEntity] 

我還想寫另一個實體爲：

class Another extends MongoDocument[Another] { 
    val db = Db.get 
    val collection = "test" 

    val subEntity = new MongoDoc(this, "subEntity", SubEntity) 
} 
object Another extends Another with MongoMetaDocument[Another] 

凡Db.get只是返回一個DefaultDB。

但是斯卡拉不能推斷該類型的MongoDoc例如，即使我想他們可能是inferrable（如Doc很容易推斷出，SubDocF可以推斷SubEntity.type和SubEntity混入只是MongoMetaDocument[SubEntity]那麼SubDoc類型必須是SubEntity） 。如果我使用下面的代碼，一切都很好：

val subEntity = new MongoDoc[Another,SubEntity.type,SubEntity](this, "subEntity", SubEntity) 

有沒有一些解決方案，類型不需要明確設置？由於我需要構建一個擴展自MongoDocument特徵的類的實例，我試圖通過使用具有create方法的元對象來解決這個問題。

目前我唯一提出的解決方法是使用implicitly，但這會使實體定義更加噁心。

謝謝你幫我理清了這一點（或者給我一些提示如何安排我的類層次結構，這將不會是一個問題）

Answer 1

，如果你擺脫你會得到更好的類型推斷的「F-界多態性」。 （也就是當你發現你自己寫了「T <：Foo [T]」形式的類型參數），而是在具體類中指定的特徵中使用抽象類型成員。

你會發現，推斷在這裏工作：

trait MongoDocument 
    type DocType <: MongoDocument 

    def apply(doc: TraversableBSONDocument): DocType = ??? // loads the content of supplied document 
} 
trait MongoMetaDocument extends MongoDocument { 

    protected val clazz = this.getClass.getSuperclass 
    def create: DocType = clazz.newInstance().asInstanceOf[DocType] 

    def find(id: String): Future[Option[DocType]] = ??? 
} 

abstract class MongoField[Doc <: MongoDocument, T](doc: MongoDocument, field: String) { 
    type DocType <: MongoDocument 
    var value: Option[T] 

    def is: Option[T] = value 
    def apply(in: T) { value = Some(in) } 
    def unset() { value = None } 

    def load(bson: BSONValue) 

} 

class MongoDoc[Doc <: MongoDocument, SubDocF <: MongoMetaDocument, SubDoc <: MongoDocument](doc: Doc, field: String, meta: SubDocF) 
    extends MongoField[Doc, SubDocF#DocType](doc, field) { 
    type DocType = Doc 

    def load(bson: BSONValue) { 
    value = Try(bson.asInstanceOf[TraversableBSONDocument]).toOption.map { doc => 
     ??? 
    } 
    } 
} 

class SubEntity extends MongoDocument { 
    type DocType = SubEntity 
    ??? 
} 
object SubEntity extends SubEntity with MongoMetaDocument 

class Another extends MongoDocument { 
    type DocType = Another 
    val subEntity = new MongoDoc(this, "subEntity", SubEntity) 
} 
object Another extends Another with MongoMetaDocument