Programmation Fonctionnelle, TD3

Htmligure
Version & licenses
Creative Commons License

Programmation Fonctionnelle, TD3 : Types paramétrés II

Guyslain Naves

Exercice 1 : Fonctions.

Le type des fonctions est un type paramétré, avec deux paramètres :

  1. type ('dom,'im) funct = 'dom -> 'im
  1. Par rapport à 'dom, à quelle catégorie de types paramétrés appartient le type des fonctions ? Par exemple, à quelle catégorie appartient 'dom -> int ?
  2. Et par rapport à 'im, par exemple int -> 'dom ?
  3. Donnez le code des fonctions map et comap. À quoi correspondent map et comap pour les fonctions ?

Exercice 2 : Promesses.

Lwt est une librairie permettant de gérer des calculs concurrents. Voici un extrait de l'API :

  1. (** The type of promises, that will eventually contain
  2. a result of type ['result]. *)
  3. type 'result t

  5. val return : 'value -> 'value t

  7. val bind : 'value t -> ('value -> 'result t) -> 'result t

  9. (** infix for [bind] *)
  10. val (>>=) : 'value t -> ('value -> 'result t) -> 'result t


  13. val map : ('value -> 'result) -> 'value t -> 'result t

  15. (** infix for [map] *)
  16. val (>|=) : 'value t -> ('value -> 'result) -> 'result t

  18. (** [async f] starts a thread without waiting for the result. *)
  19. val async : (unit -> 'any t) -> unit
  1. À quelle catégorie de type paramétrés appartient Lwt.t ? Pourquoi ?

  2. On se donne :

    1. type event
    2. val mouse_event : unit -> event Lwt.t
    3. val get_position : event -> int * int

    Écrivez une promesse ayant pour résultat la position de la souris au prochain événement.

  3. Écrivez une promesse qui à chaque événement souris, affiche en sortie standard la position de la souris, indéfiniment.

Exercice 3 : Comparateurs.

Voici l'interface d'un petit module tout simple qui rend de grands services.

  1. type 'elt comparison = 'elt -> 'elt -> int

  3. val int : int comparison
  4. val float : float comparison
  5. val bool : bool comparison
  6. val string : string comparison

  8. val pair : 'fst comparison * 'snd comparison -> ('fst * 'snd) comparison
  9. val list : 'elt comparison -> 'elt list comparison

  11. val comap : ('elt -> 'im) -> 'im comparison -> 'elt comparison

  13. val inverse : 'elt comparison -> 'elt comparison

  15. val min_by : 'elt comparison -> 'elt -> 'elt -> 'elt
  16. val max_by : 'elt comparison -> 'elt -> 'elt -> 'elt

  18. (** [cmp1 <|> cmp2] compares using [cmp1], or when [cmp1] gives
  19. equality, using [cmp2] *)
  20. val (<|>) : 'elt comparison -> 'elt comparison -> 'elt comparison
  1. À quelle catégorie appartient le type 'elt comparison ?
  2. Écrivez des fonctions de comparaisons pour :
    • les paires int * bool,
    • les listes de listes d'entiers (int list) list
    • les paires (float list * int)

  3. Soit le module suivant :

    1. module Person : sig
    2. type t
    3. val get_name : t -> string
    4. val age : t -> int
    5. val id : t -> int
    6. end

    Donnez une fonction pour comparer deux personnes selon leur nom, et en cas d'égalité selon leur âge.

  4. Programmez les fonctions inverse et comap.

Exercice 4 : synchronisation.

La librairie standard contient des modules pour manipuler des threads, mais plus bas-niveau que Lwt. Le module Event permet d'établir des communications synchronisées entre threads.

  1. (* from Thread *)
  2. type t

  4. (* creating a thread, a thread computes an application *)
  5. val create : ('arg -> 'res) -> 'arg -> t

  7. (* Waiting for a thread to terminate *)
  8. val join : t -> unit

  10. (* [delay sec] pauses the current thread for [sec] seconds. *)
  11. val delay : float -> unit
  1. (* from Event *)
  2. type 'value channel (* Channel transmitting values of type ['value] *)
  3. type 'value event (* Event with information of type ['value] *)

  5. val new_channel : unit -> 'value channel

  7. (* blocking. Synchronises over an event with another thread. *)
  8. val sync : 'value event -> 'value

  10. val send : 'value channel -> 'value -> unit event
  11. val receive : 'value channel -> 'value event

  13. val wrap : 'v event -> ('v -> 't) -> 't event
  1. Écrire un programme créant deux threads. Le premier envoie au second les entiers de 10 à 1 , à une seconde d'intervalle. Le deuxième les affiche. Le programme termine quand les deux threads terminent.
  2. À quelles catégories appartiennent les types channel et event ?
  3. Quel autre nom pourrait-on donner à wrap ?