(* Ecrire la fonction rang qui prend en argument un jour de semaine et retourne son rang dans la semaine (lundi est le jour de rang 1 et dimanche est de rang 7 dans la semaine). On remarque que la fonction est partielle et qu’on peut la  compléter en associant l’entier 0 à un jour inconnu.
	rang ′′jeudi′′ => 4
	rang ′′monday′′ => -1 (le -1 a été choisi pour des raisons pratiques à cause des fonctions suivantes
 *)
let rang  = function   | "lundi" -> 1
			| "mardi" -> 2
			| "mercredi" -> 3
			| "jeudi" -> 4
			| "vendredi" -> 5
			| "samedi" -> 6
			| "dimanche" -> 7
			| _ -> -1 ;;

(* Ecrire la fonction inf prenant en arguments 2 jours et retournant true ssi le premier jour précède le deuxième. *)
let inf = fun (x,y) -> rang(x) < rang (y)  ;;

(* Ecrire la fonction jsem qui prend en argument un entier de l’intervalle [1,7] et retourne la chaîne de caractères représentant le jour de la semaine correspondant. Si l’entier est incorrect la fonction retourne la chaîne ′′jour inconnu′′
	jsem 4 => ′′jeudi′′
	jsem 0 => ′′jour inconnu′′
*)
let jsem  = function    | 1 -> "lundi"
			| 2 -> "mardi"
			| 3 -> "mercredi"
			| 4 -> "jeudi"
			| 5 -> "vendredi"
			| 6 -> "samedi"
			| 7 -> "dimanche"
			| _ -> "jour inconnu" ;;

(* On veut écrire plusieurs versions de la fonction csucc qui prend en argument un jour de semaine et retourne son successeur dans la semaine : le successeur de lundi est mardi, celui de dimanche est lundi :
	1ère version en utilisant uniquement le filtrage ;
*)
let csucc  = function   | "lundi" -> "mardi"
			| "mardi" -> "mercredi"
			| "mercredi" -> "jeudi"
			| "jeudi" -> "vendredi"
			| "vendredi" -> "samedi"
			| "samedi" -> "dimanche"
			| "dimanche" -> "lundi"
			| _ -> "successeur inconnu" ;;


(* 2ème version en utilisant les fonctions jsem, et rang et sans filtrage. On donnera une version qui évite de calculer 2 fois la même expression ; *)
let csucc2 = fun x -> if (rang(x) == 7) then jsem(1)  else jsem ((rang x) + 1);;

(*3ème version en utilisant les fonctions jsem, et rang et l’opérateur
   prédéfini mod.
*)
let csucc3 = fun x -> jsem (((rang x) + 1)mod 7);;

(* Ecrire les 3 mêmes versions pour la fonction cpred retournant le jour
précédent. On notera que (-1) mod 7 = -1
*)
let cpred  = function   | "lundi" -> "dimanche"
			| "mardi" -> "lundi"
			| "mercredi" -> "mardi"
			| "jeudi" -> "mercredi"
			| "vendredi" -> "jeudi"
			| "samedi" -> "vendredi"
			| "dimanche" -> "samedi"
			| _ -> "precedent inconnu" ;;

let cpred2 = fun x -> if (rang(x) == 1) then jsem(7)  else jsem ((rang x) - 1);;

let cpred3 = fun x -> jsem (((rang x) - 1)mod 7);;


(* Définir le type date décrit par 3 entiers (numéro du jour dans le mois, numéro du mois,
année)
*)
type date = int * int * int ;;

(* Ecrire la fonction bissextile prenant en argument une année et retournant un booléen indiquant si l’année est bissextile ou non. Une année est bissextile si elle est divisible par 4 et si elle n’est pas divisible par 100 à moins qu’elle soit divisible par 400.
*)
let bissextile = fun (x) -> ( (x mod 4 == 0) && (x mod 100 != 0) )||(x mod 400 == 0 ) ;;

(*Ecrire la fonction nbjour prenant en argument un numéro de mois et une année et retournant le nombre de jour de ce mois dans cette année. Ecrire une version prenant en argument un couple d’entiers et une version prenant en arguments 2 entiers. Remarquez les types de ces 2 fonctions.
*)
let nbjour = function (mois,an) -> match (mois,an) with
				| (1,_) -> 31
				| (2,_) -> if (bissextile (an)) then 29 else 28
				| (3,_) -> 31
				| (4,_) -> 30
				| (5,_) -> 31
				| (6,_) -> 30
				| (7,_) -> 31
				| (8,_) -> 31
				| (9,_) -> 30
				| (10,_) -> 31
				| (11,_) -> 30
				| (12,_) -> 31
				| (_,_) -> -1 ;;

let nbjour2 = fun mois  an -> match (mois,an) with
				| (1,_) -> 31
				| (2,_) -> if (bissextile (an)) then 29 else 28
				| (3,_) -> 31
				| (4,_) -> 30
				| (5,_) -> 31
				| (6,_) -> 30
				| (7,_) -> 31
				| (8,_) -> 31
				| (9,_) -> 30
				| (10,_) -> 31
				| (11,_) -> 30
				| (12,_) -> 31
				| (_,_) -> -1 ;;


(*Ecrire une fonction valide prenant en argument une date et retourne true ssi la date est valide. *)
let valide = fun (jour,mois,an) -> (jour<=nbjour(mois,an)) && (mois <13) && (jour>0) && (mois>0) ;;


(*Ecrire la fonction lendemain prenant en argument une date et retournant celle du lendemain.
Cette fonction ne teste pas si la date entrée en paramètre est valide
*)
let lendemain = fun (jour,mois,an) -> if valide (jour+1,mois,an) then jour+1,mois,an
					else  if valide (1,mois+1,an) then 1,mois+1,an
						else 1,1,an+1  ;;


(*Ecrire la fonction veille prenant en argument une date et retournant celle du la veille.
Cette fonction ne teste pas si la date entrée en paramètre est valide
*)
let veille = fun (jour,mois,an) -> if valide (jour-1,mois,an) then jour-1,mois,an
					else  if valide (nbjour(mois-1,an),mois-1,an) then nbjour(mois-1,an),mois-1,an
						else 31,12,an-1  ;;