Dado el valor de algún tipo de ruta dependiente, ¿cómo puedo obtener una instancia del "contenedor"?

Question

Se explica más fácilmente en código:

class Bippy { 
    val x = 42 

    class Boppy { 
    val y = "hello world" 
    } 

    val bop = new Boppy 
} 

val bip = new Bippy 
val bop: Bippy#Boppy = bip.bop 

bop se suministra a continuación a otro método, que necesita para encontrar el valor de la x contiene instancia de Bippy. ¿Cuál es el hechizo mágico para hacerlo?

La instancia bop proviene de un código que no controlo, por lo que agregar métodos nuevos al Boppy no es una opción aquí.

Answer 1

No se puede. Al menos no sin hacer trampa. He aquí cómo hacer trampa.

def getOuter(bop : Bippy#Boppy) = 
    bop.asInstanceOf[{def Bippy$Boppy$$$outer() : Bippy}].Bippy$Boppy$$$outer() 

Obviamente eso es muy dependiente de los detalles de cómo funciona en la actualidad scalac y no hay garantías de que va a trabajar mañana.

Answer 2

Como dijo James, no se puede. Su trampa hace que mis ojos sangren, y sugiero que hagas otra cosa ;-)

Recomiendo encarecidamente modificar los consumidores de bop si puedes. En lugar de ellos entregando una instancia de Bippy # Boppy, ellos entregar un par que comprende el valor del tipo dependiente y el valor que el tipo depende,

trait DependentPack { 
    val bippy : Bippy 
    val boppy : bippy.Boppy 
} 

val bip = new Bippy 
val bop = bip.bop 
val dep = new DependentPack { val bippy = bip ; val boppy = bop } 
foo(dep) 

def foo(dp : DependentPack) = { 
    import dp._ 
    // use bippy ... 
    // use boppy ... 
} 

Tenga en cuenta que esto es en parte una solución para la falta de tipos de métodos dependientes (habilitados en scalac agregando los tipos de método -Ydependent o -Xexperimental switches de línea de comando). Si los tuviéramos, entonces podríamos caer artefactos como DependentPack y volver a escribir lo anterior como,

val bip = new Bippy 
val bop = bip.bop 
foo(bip)(bop) 

def foo(bippy : Bippy)(boppy : bippy.Boppy) = { 
    // use bippy ... 
    // use boppy ... 
} 

Ni que decir tiene, creo que tener tipos de métodos dependientes activadas por defecto sería muy deseable. Los usos no triviales de los tipos dependientes traen consigo un mundo de dolor en su ausencia a menos que sea muy cuidadoso.