Comment définir le type structurel que la méthode renvoie cette

Question

J'ai un nombre de Builder s qui provient de la bibliothèque dont le code source est généré automatiquement en Java et au-delà de mon contrôle. Ces Builder ne sont pas liés les uns aux autres, mais ils ont un certain nombre de méthodes qui sont structurellement exactement les mêmes. En utilisant le type structurel de Scala, comment puis-je retourner le constructeur pour lui-même?

type StructurallyBuilder = { 
    def setA(xxx): StructurallyBuilder 
    def setB(yyy): StructurallyBuilder 
} 

Quand je veux utiliser Seta et SetB sur le StructurallyBuilder, le compilateur se plaint qu'il ne peut pas résoudre.

Answer 1

Il est pas tout à fait simple, mais je crois que vous pouvez utiliser F-bounded polymorphism pour y parvenir:

type StructurallyBuilder[F <: StructurallyBuilder[F]] = { 
    def setA(xxx: Int): F 
    def setB(yyy: Int): F 
} 

Vous devez garder cette signature complexe lors de la définition des classes ou des méthodes qui prennent ces constructeurs. Par exemple:

def setA[T <: StructurallyBuilder[T]](
    xxx: Int, 
    builder: StructurallyBuilder[T] 
): T = builder.setA(xxx) 

Mais il semble que vous pouvez utiliser ces méthodes normalement:

val bld: a.c.Builder = setA(10, new a.c.Builder()) 

Answer 2

Vous pouvez faire le constructeur réel un paramètre de type de type structural:

import scala.language.reflectiveCalls 
import scala.language.existentials 

type StructurallyBuilder[T <: AnyRef] = AnyRef { 
    def setA(xxx): T 
    def setB(yyy): T 
} 

Voici un petit test que j'ai écrit pour prouver que vous pouvez l'utiliser pour faire circuler n'importe quel constructeur en utilisant 'StructurallyBuilder' comme un type de paramètre:

import scala.language.reflectiveCalls 
import scala.language.existentials 

type StructurallyBuilder[T <: AnyRef] = AnyRef { 
    def setA(a: Int): T 
    def setB(b: String): T 
} 


class Builder1 { 
    var a: Int = _ 
    var b: String = _ 

    def setA(a: Int): Builder1 = { 
    this.a = a 
    this 
    } 

    def setB(b: String): Builder1 = { 
    this.b = b 
    this 
    } 
} 

val builder: StructurallyBuilder[_] = new Builder1 

val b2 = builder.setA(1) 
val b3 = builder.setB("B") 

val builder2 = new Builder1 

def test(builder: StructurallyBuilder[_]): String = { 
    builder.toString 
} 

val t2 = test(builder2) |-> t2: String = Builder1@7a067558 

Answer 3

pourquoi ne pas utiliser this.type?

type StructurallyBuilder = { 
    def setA(x: Int): this.type 
    def setB(y: Double): this.type 
} 

Exemple de cette utilisation:

object App 
{ 

    class A { 
    def setA(x: Int): this.type = { this } 
    def setB(y: Double): this.type = { this } 
    } 

    type StructurallyBuilder = { 
    def setA(x: Int): this.type 
    def setB(y: Double): this.type 
    } 


    def main(args: Array[String]):Unit = 
    { 
    val a = new A() 
    if (a.isInstanceOf[StructurallyBuilder]) { 
     System.out.println("qqq") 
    } 
    System.out.println(a) 
    } 

} 

Alors, en essayant de courir:

[info] Running X.App 
qqq 
X.App$A@8f59676