4 votes

Créer une fonction qui renvoie le OU logique de plusieurs prédicats booléens

Supposons que mon code contienne un certain nombre de prédicats booléens :

def pred1[A](x: A): Boolean = { ... }
def pred2[A](x: A): Boolean = { ... }
def pred3[A](x: A): Boolean = { ... }

J'aimerais pouvoir créer une fonction qui soit, par exemple, le OU logique de pred1 y pred3 .

Donc, quelque chose comme :

def pred1Or3[A](x: A) = or(pred1, pred2)

Mieux encore, il serait intéressant de pouvoir généraliser afin de fournir ma propre fonction de combinaison. Ainsi, si au lieu de cela, je voulais avoir le ET logique, j'appellerais :

def pred1And3[A](x: A) = combine({_ && _}, pred1, pred2)

Je peux obtenir le même effet de base de cette manière :

def pred1And3[A](x: A) = Seq(pred1, pred2) map { _(x) } reduce { _ && _ }

mais cela semble un peu verbeux et brouille l'intention. Existe-t-il un moyen plus simple de faire cela en Scala ?

4voto

Nate Nystrom Points 465

Voici une solution que j'ai utilisée dans le passé :

implicit def wrapPredicates[A](f: A => Boolean) = new {
  def <|>(g: A => Boolean) = (x: A) => f(x) || g(x)
  def <&>(g: A => Boolean) = (x: A) => f(x) && g(x)
}

A utiliser comme suit :

val pred12or3 = pred1 <|> pred2 <|> pred3

1voto

Rex Kerr Points 94401
def or[A](p: A => Boolean, q: A => Boolean) = (a: A) => p(a) || q(a)
def logic[A](p: A => Boolean, q: A => Boolean)(c: (Boolean, Boolean) => Boolean) = {
  (a: A) => c( p(a) , q(a) )
}

Vous pourriez ajouter un paramètre (a: A) à ces méthodes au lieu de renvoyer une fonction, par exemple :

def or2[A](a: A)(p: A => Boolean, q: A => Boolean) = p(a) || q(a)

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X