From bd33477205396c78128bfda692d29ca1e7241253 Mon Sep 17 00:00:00 2001
From: "joel.vonderwe" <joel.von-der-weid@etu.hesge.ch>
Date: Thu, 20 Feb 2020 14:50:20 +0100
Subject: [PATCH] Added tp4 lambda

---
 base_tp/src/fp/fp.scala         |  2 +-
 base_tp/src/lambda/lambda.scala | 60 +++++++++++++++++++++++++++++++++
 base_tp/test/lambdaTest.scala   | 53 +++++++++++++++++++++++++++++
 3 files changed, 114 insertions(+), 1 deletion(-)
 create mode 100644 base_tp/src/lambda/lambda.scala
 create mode 100644 base_tp/test/lambdaTest.scala

diff --git a/base_tp/src/fp/fp.scala b/base_tp/src/fp/fp.scala
index e726e3d..01bb294 100644
--- a/base_tp/src/fp/fp.scala
+++ b/base_tp/src/fp/fp.scala
@@ -98,7 +98,7 @@ object Serie3 {
   final def even[A]( as: List[A] ): Boolean = {
     as match {
         case Nil => true
-        case _ :: _ :: rest => evenRec(rest)
+        case _ :: _ :: rest => even(rest)
         case _ :: Nil => false
       }
   }
diff --git a/base_tp/src/lambda/lambda.scala b/base_tp/src/lambda/lambda.scala
new file mode 100644
index 0000000..29b38b5
--- /dev/null
+++ b/base_tp/src/lambda/lambda.scala
@@ -0,0 +1,60 @@
+ package ch.hepia.tpscala
+
+/*
+ * Implémenter les fonctions suivantes en suivant les commentaires.
+ */
+
+object Predicates {
+
+  type P[A] = A=>Boolean
+
+  /*
+   * 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) =>
+    !p(a)
+  }
+
+  /*
+   * 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) =>
+    p1(a) && p2(a)
+  }
+
+  /*
+   * 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) =>
+    p1(a) || p2(a)
+  }
+
+  /*
+   * La fonction 'exists' retourne un nouveau prédicat dont le
+   * 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) =>
+    ps match {
+        case p :: Nil => p(a)
+        case p :: _ if p(a) => true
+        case _ :: rest => exists(rest)(a)
+    }
+  }
+
+  /*
+   * La fonction 'forall' retourne un nouveau prédicat dont le
+   * 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) =>
+    ps match {
+        case p :: Nil => p(a)
+        case p :: _ if !p(a) => false
+        case _ :: rest => forall(rest)(a)
+    }
+  }
+}
diff --git a/base_tp/test/lambdaTest.scala b/base_tp/test/lambdaTest.scala
new file mode 100644
index 0000000..eb20686
--- /dev/null
+++ b/base_tp/test/lambdaTest.scala
@@ -0,0 +1,53 @@
+package ch.hepia.tpscala
+
+
+import org.scalatest.funsuite.AnyFunSuite
+
+import Predicates._
+
+class PredicatesSuite4 extends AnyFunSuite {
+
+
+  val big = (_:Int) >= 100
+  val even = (_:Int) % 2 == 0
+
+  val small = not[Int]( big )
+  val bae = and[Int]( big, even )
+  val boe = or[Int]( big, even )
+
+  test("Predicate Evaluation") {
+    assert( big(200) )
+    assert( ! big(19) )
+    assert( even(200) )
+    assert( ! even(201) )
+  }
+
+  test("Predicate negation") {
+    assert( small(19) )
+    assert( !small( 200 ) )
+  }
+
+  test("Predicate AND") {
+    assert( bae( 200 ) )
+    assert( !bae( 201 ) )
+  }
+
+  test("Predicate OR") {
+    assert( boe( 201 ) )
+    assert( !boe( 19 ) )
+  }
+
+  val mul3 = (_:Int ) % 3 == 0
+  val ps = List( big, even, mul3 )
+
+  test("Predicates FORALL") {
+    assert( forall[Int]( ps )( 402 ) )
+    assert( ! forall[Int]( ps )( 200 ) )
+  }
+
+  test("Predicates EXISTS") {
+    assert( exists[Int]( ps )( 18 ) )
+    assert( ! exists[Int]( ps )( 1 ) )
+  }
+
+}
-- 
GitLab