scala inquinamento caso oggetto

Question

Mi spiego ;-)

entrambe le classi inferiori sono in pacchetto com.company.foo

RoleGroup.scala 
abstract class RoleGroup 
case object ADMIN extends RoleGroup 
case object MEMBER extends RoleGroup 

MailSender.scala 
abstract class MailSender 
case object ADMIN extends MailSender 
case object STAFF extends MailSender 
case object ACCOUNTANT extends MailSender 

Il problema qui è che ADMIN è ambiguo dal momento che non v'è separazione spazio dei nomi con caso degli oggetti. Sembra che ci possa essere solo un caso caso con nome univoco per pacchetto.

Suppongo di poter denominare gli oggetti case in base alla funzione a la mailADMIN, al ruoloADMIN e così via. O dovrei semplicemente creare Enum corretto e dimenticare gli oggetti del caso? O prendere qualche altro approccio?

Answer 1

si potrebbe fare qualcosa di simile:

object RoleGroup { 
    sealed trait RoleGroup 
    case object ADMIN extends RoleGroup 
    case object MEMBER extends Rolegroup 
} 

e allo stesso modo per MailSender. Poi nelle situazioni in cui si sta utilizzando solo uno, si può fare import MailSender._ o viceversa, ma quando si utilizza entrambi si fa riferimento a loro come RoleGroup.ADMIN, ecc

Sia che tu voglia adottare questo approccio o utilizzare enumerazioni dipende in gran parte da come hai intenzione di usarli. In questo approccio, ogni "enum" è un tipo, mentre con Enum ogni enum è un valore. Il primo funziona meglio per la corrispondenza dei pattern, dal momento che il compilatore può verificare se le corrispondenze sono esaustive, la seconda è migliore (IMO) per lavorare con la serializzazione.

Answer 2

Non hai bisogno di enumerazione qui, probabilmente come altrove. Tutto ciò di cui hai bisogno è il giusto namespacing. Trovo l'approccio compagna oggetto per essere il più benefitial:

sealed abstract class RoleGroup 
object RoleGroup { 
    case object Admin extends RoleGroup 
    case object Member extends RoleGroup 
    // also just in case 
    sealed case class SomeParameterizedGroup (
    param1: Any, 
    param2: Int 
) extends RoleGroup 
} 

Utilizzando in questo modo sarà molto vi ricorderà enumerazioni di Java, mentre anche fornendo con punti di forza di Scala:

def foo (roleGroup: RoleGroup) = 
    roleGroup match { 
    case RoleGroup.Admin => 
    case RoleGroup.SomeParameterizedGroup(param1, param2) => 
    } 

Si prega di notare che nella soluzione di Dan il tipo di roleGroup sarebbe RoleGroup.RoleGroup, il che sembra un po 'innaturale. Nota anche che i nomi in maiuscolo violano le convenzioni stilistiche di Scala e dagli esempi sopra puoi vedere perché.