Comment utiliser les types d'objets singleton de Scala?

Question

J'écris une classe qui sert de classe de base pour une série d'objets singleton. Dans chaque objet singleton, il y aura des vals représentant certaines propriétés, et je veux écrire une méthode qui, pour chaque objet singleton, n'accepte que des objets créés par lui.

Je donne les résultats suivants:

class Obj[M <: Maker] 

class Maker { 
    implicit val me: this.type = this 
    def make[M <: Maker](implicit maker: M) = new Obj[M] 
    def accept(obj: Obj[this.type]) = {...} 
} 

Jusqu'à présent, si bon. Ensuite, je veux déclarer un de ces objets singleton:

object M extends Maker { 
    val a = make 
} 

Mais, si j'essaie ceci:

M.accept(M.a) 

je reçois une erreur de compilation:

type mismatch; found : com.test.Obj[object com.test.M] required: com.test.Obj[com.test.M.type] 

Mon questions:

1. Quel est le type object com.test.M, et comment est-il différent de com.test.M.type?
2. Comment puis-je faire cela plus intelligemment?

Answer 1

Obtenez avec le temps, mon brave homme! J'ai corrigé cela il y a plus de 24 heures. Ensuite, je m'attends à voir des vélociraptors courir après des dodos, en train de craquer furieusement leurs fouets tout en regardant des citations boursières sur leurs écrans de veille pointés.

Le commit en question est: http://lampsvn.epfl.ch/trac/scala/changeset/23622

// 1130.scala 
class Obj[M <: Maker] 

class Maker { 
    implicit val me: this.type = this 
    def make[M <: Maker](implicit maker: M) = new Obj[M] 
    def accept(obj: Obj[this.type]) =() 
} 

object M extends Maker { 
    val a = make 
} 

object Test { 
    def main(args: Array[String]): Unit = { 
    M.accept(M.a) 
    } 
} 

// too old 
% /scala/inst/scala-2.9.0.r23619/bin/scalac ./1130.scala 
./1130.scala:15: error: type mismatch; 
found : Obj[object M] 
required: Obj[M.type] 
    M.accept(M.a) 
      ^
one error found 

// fresh enough 
% /scala/inst/scala-2.9.0.r23624/bin/scalac ./1130.scala 
% 

Answer 2

Utilisez this.type au lieu de M. Cet exemple simplifié devrait fonctionner:

class Obj[M <: Maker] 

class Maker { 
    def make() = new Obj[this.type] 
    def accept(obj: Obj[this.type]) = println(obj) 
} 

object M extends Maker 

object N extends Maker 

M.accept(M.make()) //works! 
M.accept(N.make()) //error! type mismatch! 

Answer 3

Cela fonctionne:

La "sauce" secret utilise make[M.type] l'intérieur de l'objet singleton.

@retronym revient le mérite d'expliquer ceci: How to correctly type-annotate this HList?

Answer 4

Votre première question: « Quel est le type object com.test.M, et comment est-il différent de com.test.M.type? », N'a pas encore reçu de réponse. Je n'ai pas trouvé documenté dans la spécification, mais il semble que le type object M est le type interne représentant la classe implicitement créée lorsque vous définissez un objet M. Bien sûr, M est la seule instance de cette classe donc on s'attendrait à ce que le type object M soit équivalent à M.type, mais le compilateur ne le voit apparemment pas de cette façon. Le problème que vous rencontrez, en tant que @retronym explained, est que le type singleton M.type n'est pas inféré pour le paramètre type lorsque vous appelez votre méthode make. Ceci est pour la même raison que String est inférée plutôt que v.type dans la session ci-dessous:

scala> val v = "asdf"      
v: java.lang.String = asdf 

scala> identity(v) 
res0: java.lang.String = asdf 

où identity est défini comme

def identity[T](v: T) = v