comment exposer test pour un match de modèle

Question

Je suis noteur nouveau à scala, mais au fond ont trouvé mon chemin ...

Ici, je demande la méthode recommandée/meilleures pratiques/idiomatiques de la mise en œuvre ceci:

• interne, MyClass utilise un état de type, qui est mis en œuvre par une hiérarchie fermée des classes de cas
• mais sur l'API, seule une partie prédicat booléen doit être exposé, qui obtient mis en œuvre par correspondance contre l'état (interne).

Actuellement, ma mise en œuvre est le long des lignes de ...

def isSane: Boolean = state match { 
    case Ok(_,'valid) => true 
    case _   => false 
} 

Mais cette solution me sent maladroit, comme si quelque chose dans l'expression 3 lignes de code qui ne dispose que le contenu de l'information vaut une ligne de code. En fait, ce que je voudrais écrire serait:

def isSane: boolean = state matches Ok(_, 'valid) 

Probablement/probable qu'il est possible de mettre en œuvre un opérateur approprié vous dans scala, mais avant que je regarde dans cela, je voudrais savoir quelle serait la d'habitude façon de résoudre ce problème. Peut-être y a-t-il aussi une implémentation de bibliothèque existante?

Answer 1

Si la propriété est Symbol statiquement connu pour être une propriété du type de state:

def isSane: Boolean = 
    state.secondSymbolPropertyWhateverItsCalled == 'valid 

Si vous ne savez pas que state est un Ok, puis:

def isSane: Boolean = 
    state.isInstanceOf[Ok] && state.asInstanceOf[Ok].symbolProp == 'valid 

mais à ce stade, ce n'est pas vraiment supérieur à ce que vous avez écrit.

Enfin, vous pouvez simplement définir isSane sur la hiérarchie des types et déléguer:

def isSane: Boolean = 
    state.isSane 

Answer 2

je peux être vieux jeu, mais pourquoi ne pas utiliser le polymorphisme?

trait State { def sane: Boolean } 

trait InvalidState extends State { def sane = false } 

case class Ok(whatever: Whatever, s: Symbol) extends State { 
    def sane = { s == 'valid } 
} 

case class Failure(msg: String) extends InvalidState 

case class WarmingUp extends InvalidState 

// ... 

def isSane(): Boolean = state.sane 

Bien sûr, si ce n'est pas une possibilité pour une raison quelconque, vous pouvez généraliser Daniel's solution peu:

class Matcher[T](o: T) { 
    def matches(pf: PartialFunction[T, Unit]) = pf isDefinedAt o 
} 

object Matcher { 
    implicit def o2matcher[T](o: T): Matcher[T] = new Matcher(o) 
} 

// then 
def isSane = state matches { case Ok(_,'valid) => } 

Answer 3

je ferais quelque chose comme ceci:

abstract class State { 
    def matches(pf: PartialFunction[State, Unit]) = pf isDefinedAt this 
} 

// then 

def isSane = state matches { case Ok(_,'valid) => } 

Parce que matches est défini pour recevoir une fonction partielle, vous pouvez le suivre avec une fonction littérale avec seulement les instructions de cas qui devraient aboutir à true. Vous n'avez rien à renvoyer, car la fonction partielle est définie comme renvoyant Unit. Enfin, la méthode matches utilise la méthode des fonctions partielles isDefinedAt pour vérifier s'il existe une instruction case couvrant elle-même.