content: -- TP Type Algébrique et Monade
  
  -- Exercice 1
  -- Faire une aborescence de fichiers et retourner le path d'un fichier
  {-# OPTIONS_GHC -Wno-overlapping-patterns #-}
  import Data.ByteString (findIndex)
  type Nom = String
  type Date = Integer
  type Perm = String
  data Element donnees = 
      Fichier Nom donnees Perm Date |
      Repertoire Nom [Element donnees] Perm Date
  
  findF :: Nom -> Element a -> [Nom]
  findF nom (Fichier n _ _ _) = if nom == n then [n] else []
  findF nom (Repertoire n l _ _) = if nom == n then [n] else concatMap (findF nom) l
  
  -- Exercice 3
  data Constante = Vrai | Faux | Indéfini deriving (Show)
  
  incomp :: Constante -> Constante -> Constante
  incomp Faux _ = Vrai
  incomp _ Faux = Vrai
  incomp _ _ = Indéfini
  incomp Vrai Vrai = Faux
  
  non :: Constante -> Constante
  non Vrai = Faux
  non Faux = Vrai
  non Indéfini = Indéfini
  
  et :: Constante -> Constante -> Constante
  et Vrai Vrai = Vrai
  et Faux _ = Faux
  et _ Faux = Faux
  et _ _ = Indéfini
  
  ou :: Constante -> Constante -> Constante
  ou Vrai _ = Vrai
  ou _ Vrai = Vrai
  ou Faux Faux = Faux
  ou _ _ = Indéfini
  
  -- Exercice 4
  -- Définir un type d'arbre binaire
  
  data Arbre a b = F (Feuille a) | N (Noeud a b)
  type Feuille a = a
  type Noeud a b = ((Arbre a b), (Arbre a b))
  
  -- Version du prof
  data Tree a b = Leaf a | Node b (Tree a b) (Tree a b)
  
  eval :: Tree t ((t,t)->t) -> t
  eval (Leaf x) = x
  eval (Node f n1 n2) = f (eval n1, eval n2)
  
  -- Exercice 6
  -- Définir une fonction qui renvoie l'index d'un élément dans une liste ou nothing si cet élément ne fait pas partie de la liste
  find :: Eq a => [a] -> a -> Maybe Int
  find ls x = findIndex ls x 0
      where
          findIndex [] _ _ = Nothing
          findIndex (y:ys) x i = if x == y then Just i else findIndex ys x (i+1)
  
  -- Exercice 8
  function :: Eq a => [a] -> [b] -> a -> Maybe b
  function [] _ _ = Nothing
  function _ [] _ = Nothing
  function (x:xs) (y:ys) a = if x == a then Just y else function xs ys a
  
  -- Les monades 
  -- Pas à maitriser