2012-01-23 10 views
5

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)?Come importare classi interne senza dipendenza da percorso in Scala?

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?

+0

Rinominare "val swing" in qualcos'altro (per eliminare l'ambiguità di importazione) funziona? – Rogach

+0

Perché non evitare del tutto questo problema inserendo le classi in un oggetto anziché in un'altra classe? –

+0

Daniel, perché gli oggetti non possono avere parametri. – Rotsor

risposta

3

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 
4

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