Changed Predicate type

base_tp/src/lambda/lambda.scala

@@ -12,7 +12,7 @@ object Predicates {
    * La méthode 'not' retourne un nouveau prédicat dont le résultat
    * est toujours la négation du résultat de l'argument.
    */
-  def not[A]( p: (A)=>Boolean ): (A)=>Boolean = { (a:A) =>
+  def not[A]( p: P[A] ): P[A] = { (a:A) =>
     !p(a)
   }
 
@@ -20,7 +20,7 @@ object Predicates {
    * La méthode 'and' retourne un nouveau prédicat dont le résultat
    * est toujours la conjonction des résultats des deux arguments.
    */
-  def and[A]( p1: (A)=>Boolean, p2: (A)=>Boolean ): (A)=>Boolean = { (a:A) =>
+  def and[A]( p1: P[A], p2: P[A] ): P[A] = { (a:A) =>
     p1(a) && p2(a)
   }
 
@@ -28,7 +28,7 @@ object Predicates {
    * La fonction 'or' retourne un nouveau prédicat dont le résultat
    * est toujours la disjonction des résultats des deux arguments.
    */
-  def or[A]( p1: (A)=>Boolean, p2: (A)=>Boolean ): (A)=>Boolean = { (a:A) =>
+  def or[A]( p1: P[A], p2: P[A] ): P[A] = { (a:A) =>
     p1(a) || p2(a)
   }
 
@@ -37,7 +37,7 @@ object Predicates {
    * résultat est vrai si au moins un des prédicat de l'argument est
    * vrai.
    */
-  def exists[A]( ps: List[(A)=>Boolean] ): (A)=>Boolean = { (a:A) =>
+  def exists[A]( ps: List[P[A]] ): P[A] = { (a:A) =>
     ps match {
         case p :: Nil => p(a)
         case p :: _ if p(a) => true
@@ -50,7 +50,7 @@ object Predicates {
    * résultat est vrai si et seulement si tous les prédicats de
    * l'argument sont vrais.
    */
-  def forall[A]( ps: List[(A)=>Boolean] ): (A)=>Boolean = { (a:A) =>
+  def forall[A]( ps: List[P[A]] ): P[A] = { (a:A) =>
     ps match {
         case p :: Nil => p(a)
         case p :: _ if !p(a) => false