Composition de prédicat en Scala

La composition de fonctions est un terme utilisé pour définir un processus de mélange d’une fonction avec d’autres fonctions. Pendant la composition, une fonction contient la référence à une autre fonction.

Le langage Scala a deux manières natives de composer des fonctions :

• (f compose g) (x), ce qui équivaut à f(g(x))
• (f etAlors g) (x), ce qui équivaut à g(f(x))

Cependant, contrairement à la composition de fonctions, la composition de prédicats a ses propres spécificités et règles. Contrairement à la composition de fonctions, où une fonction a une référence à une autre, les prédicats sont indépendants ; de plus, un prédicat a toujours un type de retour booléen. La composition des prédicats suit les lois de l’algèbre booléenne.

Il existe trois prédicats booléens de base, AND, OR et NOT. Les autres prédicats booléens peuvent être une composition de ces trois prédicats de base.

Pour diverses raisons, le langage Scala ne dispose pas d’un moyen natif de composer des prédicats comme il le fait pour les fonctions. Dans cet article, nous présentons un modèle d’encodage pour la composition de prédicats en compensation de la conception du langage. Nous démontrons que notre composition proposée est une algèbre booléenne complète.

Prédicat en Scala

Un prédicat en Scala est une fonction qui prend la forme suivante :

Qui peut être présenté comme :

Ainsi, nous définissons notre trait de prédicat comme :

trait Predicate[T] extends Function[T, Boolean]

En Scala, Function est un alias de type de Function1[-A,+B] qui prend un paramètre de type A et renvoie un type B. Comme nous pouvons le voir, Predicate prend un type T et renvoie toujours un type booléen.

Les trois prédicats de base, AND, OR et NOT, peuvent être définis comme suit :

trait Predicate[T] extends Function[T, Boolean]{
  def or(p2:Predicate[T]) = OrPredicate[T](this, p2)
  def and(p2:Predicate[T]) =  AndPredicate[T](this, p2)
  def unary_! = NotPredicate[T](this)
}
case class OrPredicate[T](p1:Predicate[T], p2:Predicate[T]) extends Predicate[T] {
  def apply(a:T) = p1(a) || p2(a)
}
case class AndPredicate[T](p1:Predicate[T], p2:Predicate[T]) extends Predicate[T] {
  def apply(a:T) = p1(a) && p2(a)
}
case class NotPredicate[T](p:Predicate[T])  extends Predicate[T] {
  def apply(a:T) = !p(a)
}

Comme nous pouvons le voir, le prédicat est une fonction d’ordre supérieur, la fonction peut être composée de ses trois opérations booléennes de base OU, ET et NON (unaire !) pour produire un nouveau prédicat.

Les opérations secondaires, NAND, NOR et XOR peuvent être une composition des trois opérations de base par l’utilisateur final, cependant, elles peuvent également être modélisées comme des opérations primitives comme suit, que nous aimerions inclure dans notre implémentation :

case class NandPredicate[T](p1: Predicate[T], p2: Predicate[T])  {
  def apply(a: T) = !(p1(a) && p2(a))
}
case class NorPredicate[T](p1: Predicate[T], p2: Predicate[T])  {
  def apply(a: T) = !(p1(a) || p2(a))
}
case class XorPredicate[T](p1: Predicate[T], p2: Predicate[T])  {
  def apply(a: T) = (p1(a) || p2(a)) and !(p1(a) && p2(a))
}

De plus, nous définissons les prédicats d’identité pour Or et Et, qui donnent toujours respectivement faux et vrai :

case class TruePredicate[T](r:T) extends Predicate[T] {
   def apply(a: T) = true
}
case class FalsePredicate[T](r:T) extends Predicate[T] {
   def apply(a: T) = false
}

Composition des prédicats

Une fois que les prédicats de base, les prédicats secondaires et les prédicats d’identité sont structurés, nous pouvons définir les classes de types qui nous intéressent. Par exemple, pour le type Int :

implicit class IntEqualTo(x:Int) extends Predicate[Int] {
  def apply(a:Int) = a == x
}
implicit class IntGreaterThan(x:Int) extends Predicate[Int] {
  def apply(a:Int) = a > x
}

La composition de ces prédicats peut produire des prédicats plus compliqués. Par exemple, un prédicat supérieur ou égal à peut être composé comme suit :

IntGreaterThan et IntEqualTo

Les prédicats sont composés en un nouveau prédicat sans être évalués, ce qui rend la composition paresseuse. Cela peut être important dans des scénarios d’élaboration de règles et de prise de décision vastes et complexes.

Intégralité de la composition du prédicat

L’algèbre booléenne, également connue sous le nom d’algèbre binaire, traite des opérations sur des valeurs logiques et incorpore des variables binaires. Un prédicat est une déclaration ou une affirmation mathématique qui contient des variables, donne une valeur booléenne.

Loi de l’algèbre booléenne comprenant les éléments suivants :

Lois monotones

Lois non monotones

Nous démontrons que la composition que nous proposons satisfait à toutes les lois de l’algèbre de Boole. La démonstration et un exemple de mise en œuvre sont disponibles sur :

Composition de prédicat

Conclusion

Dans cet article, nous avons proposé un modèle d’encodage pour la composition de prédicats en Scala, en compensation du manque de support natif dans la conception du langage. Nous avons démontré que le motif proposé satisfait la loi de l’algèbre de Boole. Ce modèle peut être utilisé efficacement dans le développement d’applications à grande échelle impliquant des prédicats complexes, la construction de règles dynamiques et la réalisation d’évaluations paresseuses dans la prise de décision.