Come importare classi interne senza dipendenza da percorso in Scala?

Question

TL & DR: È possibile (localmente?) Disabilitare la digitazione dipendente dal percorso? Vorrei rilasciare una singola dichiarazione di importazione simile a import x._, ma per rendere C fare riferimento a X#C anziché a x.C (X è il tipo di x)?

Ho un sacco di tipi:

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

E mi capita di usarli insieme passando lo stesso argomento di tipo a tutti loro:

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

ho pensato che sarebbe stato bello per confezionare tutti quei tipi in modo che ho solo bisogno di passare il parametro tipo di una volta:

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

Poi sul sito uso I 'D piace essere in grado di fare questo:

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

Tuttavia, questo non funziona correttamente a causa di battitura dipendente dal percorso: Button riferisce a swing.Button anziché Swing[M]#Button modo che il codice esterno ha un tempo molto duro che passa la corretta argomenti al costruttore UseSite.

C'è un bel modo per fare riferimento a ButtonSwing[M]#Button piuttosto che swing.Button?

Answer 1

Si potrebbe immaginare una cosa del genere

import Swing[M]#_ 

per portare tutti i membri di tipo di tipo Swing[M] nel campo di applicazione, ma questo non esiste (import si aspetta un valore, non un tipo). Ai fini pratici, come su di un tipo di alias per ridurre caldaia-piastra,

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

Answer 2

Supponendo che il percorso dipendenze davvero sono accidentali, quindi piuttosto che le proiezioni di tipo Chase tutto il percorso attraverso il vostro codice di base, si potrebbe provare qualcosa di simile ,

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) 
} 

Fuori WithSwing utilizzo sarà simile,

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

Inheritance aumenta brevità un po ',

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 {})