TP4

(* Exercice 2.1 *)
type valeur_logique = Vrai | Faux | Indefini ;;

type 'a formule_avec_var = Valeur of valeur_logique
               | Variable of 'a
               | Et of 'a formule_avec_var * 'a formule_avec_var
               | Non of 'a formule_avec_var ;;


let f = Et( Variable "x", Et(Variable "y", Valeur Vrai) ) ;;

(* Exercice 2.2 *)
let rec est_close = fun f ->
  match f with
  | Valeur -> true
  | (* ? *)
;;

est_close f;;

est_close (Et( Valeur Faux, Et(Valeur Faux, Valeur Vrai) )) ;;

(* Exercice 2.3 *)
(* Remplace toutes les occurences de x par g dans f *)
let rec substitution = fun f -> fun x ->
                               fun g ->
                               match f with
                               | Variable y -> if x=y then g else f
                               | (* ? *)
;;

(* Exercice 2.4 *)
(* conv permet de spécifier le convertisseur à utiliser
   en fonction du type de la variable *)
let to_string = fun f -> fun conv ->
                         let rec aux = fun f ->
                           match f with
                           | Variable x -> conv x
                           | Valeur Vrai -> "vrai"
                           | (* ? *)
;;

to_string (Et( Variable "x", Et(Variable "y", Valeur Vrai) )) (fun s -> s) ;;

to_string (Et( Variable 1, Et(Variable 2, Valeur Vrai) )) string_of_int ;;

let g = Et( Variable 1 , Et(Variable 2, Valeur Vrai) );;

to_string g string_of_int ;;

(* Exercice 3 *)
type listIS = Vide | I of int * listIS | S of string * listIS ;;

let l = I(5, I(3, S("3", I(0, S("", Vide))))) ;;

(* Exercice 3.1 *)
let afficheIS = function l ->
  let rec aux = fun l res ->
    match l with
      | Vide -> res
      | (* ? *)
  in print_string (aux l ""); print_newline() ;;

afficheIS l ;;

(* Exercice 3.2 *)
(* f et g sont les fonctions de conversion des éléments de la listeIS *)
let mapIS_liste = fun f -> fun g -> fun l ->
  let rec aux = fun l res ->
    match l with
      | Vide -> res
      | (* ? *)
  in aux l [];;

mapIS_liste (string_of_int) (fun s -> s) l ;;

mapIS_liste (fun x -> x=0) (fun x -> x="") l;;

(* Exercice 3.3 *)
(* l est une liste de chaînes de caractères *)
let rec liste_to_IS l =
  match l with
  | [] -> Vide
  | h::t -> try (* ? *)
            with
              _ ->  (* ? *);;


liste_to_IS ["3"; "4"; "toto"];;

liste_to_IS ["3"; "4" ];;

(* Exercice 3.4 *)
(* ? *)

(* Exercice 4 *)
(* à créer sous forme de module ! *)
type ('a, 'b) dictionnaire =
   Vide | Element of 'a * 'b * ('a, 'b) dictionnaire ;;


(* val creer : unit -> ('a, 'b) dictionnaire = <fun> *)

let creer() = Vide;;

exception Deja_present;;
(* val ajouter : 'a -> 'b -> ('a, 'b) dictionnaire -> ('a, 'b) dictionnaire = <fun> *)
let rec ajouter = fun c -> fun v ->
                           fun dico ->
                           match dico with
                           | Vide -> Element(c,v,dico)
                           | (* ? *)
;;

(* val acceder : 'a -> ('a, 'b) dictionnaire -> 'b = <fun> *)
exception Pas_presente ;;
let rec acceder = fun c -> fun dico ->
                           match dico with
                           | Vide -> raise Pas_presente
                           | (* ? *)

(* val appartient : 'a -> ('a, 'b) dictionnaire -> bool = <fun> *)
let rec appartient = fun v ->
  fun dico ->
  match dico with
  | Vide -> false
  | (* ? *)
;;

(* val supprimer : 'a -> ('a, 'b) dictionnaire -> ('a, 'b) dictionnaire = <fun> *)
(* ? *)
let supprimer = fun c dico ->
  (* ? *)