¿Cómo importar clases internas sin dependencia de ruta en Scala?

Question

TL & DR: ¿Es posible (localmente) deshabilitar la escritura dependiente de la ruta? Me gustaría emitir una sola declaración de importación similar a import x._, pero para hacer C consulte X#C en lugar de x.C (X siendo el tipo de x)?

Tengo un montón de tipos:

class Button[M] { ... } 
class Label[M] { ... } 
... 

Y resulta que usarlas juntas pasar el mismo tipo de argumento a todos ellos:

class UseSite[M] (
    btn1 : Button[M] 
, btn2 : Button[M] 
, lbl1 : Label[M]) { 
    ... 
} 

pensé que sería bueno para empaquetar todos esos tipos de modo que sólo tengo que pasar el parámetro de tipo de una vez:

class Swing[M] { 
    class Button { ... } 
    class Label { ...} 
} 

Luego, en el lugar de uso I 'D como para ser capaz de hacer esto:

class WithSwing[M] { 
    val swing = new Swing[M] 
    import swing._ 
    class UseSite(
    btn1 : Button 
    , btn2 : Button 
    , lbl1 : Label) { 
    ... 
    } 
} 

Sin embargo, esto no funciona correctamente debido a la tipificación dependiente de la trayectoria: Button se refiere a swing.Button en lugar de Swing[M]#Button por lo que el código externo tiene un tiempo muy difícil pasar la correcta argumentos al constructor UseSite.

¿Hay una manera agradable de hacer Button referirse a Swing[M]#Button en lugar de a swing.Button?

Answer 1

Uno podría imaginar algo así como

import Swing[M]#_ 

llevar a todos los miembros de tipo de tipo Swing[M] en alcance, pero esto no existe (import espera un valor, no un tipo). A efectos prácticos, ¿qué tal un alias de tipo para reducir la caldera de la placa,

type S = Swing[M] 
val b: S#Button = ... // Shorter than Swing[M]#Button 

Answer 2

Suponiendo que el camino dependencias realmente son accidentales, a continuación, en lugar de las proyecciones de tipo de persecución de todo el camino a través de su base de código, podría intentar algo como esto ,

class Button[M] 
class Label[M] 

trait Swing[M] { 
    type ButtonM = Button[M] 
    type LabelM = Label[M] 
} 

class WithSwing[M] { 
    val swing = new Swing[M] {} 
    import swing._ 
    class UseSite(btn1 : ButtonM, btn2 : ButtonM, lbl1 : LabelM) 
} 

uso fuera de WithSwing se vería así,

val ws = new WithSwing[String] 
import ws.swing._ 
new ws.UseSite(new ButtonM {}, new ButtonM {}, new LabelM {}) 

herencia aumenta un poco la brevedad,

class WithSwing[M] extends Swing[M] { 
    class UseSite(btn1 : ButtonM, btn2 : ButtonM, lbl1 : LabelM) 
} 

// Usage ... 
val ws = new WithSwing[String] 
import ws._ 
new ws.UseSite(new ButtonM {}, new ButtonM {}, new LabelM {})