Exercice 1 : Opérateurs binaires et couples.
Il est courant de faire des opérations terme-à-termes sur les couples. Par exemple, pour des couples de flottants codant des vecteurs de dimension 2 , l'addition vectorielle correspond à l'addition des termes des deux vecteurs deux-à-deux.
Redonnez le code de la fonction d'addition vectorielle. Quel est son type ?
Plus généralement, écrivez un fonction lift prenant un opérateur binaire, construisant l'opérateur terme-à-terme sur les couples de valeurs. Quel est le type de cette fonction ?
Utilisez lift pour décrire l'addition vectorielle.
Encore plus généralement, il est possible que l'opérateur binaire à appliquer sur les premiers termes n'est pas le même que celui à appliquer sur les deuxièmes termes. Écrivez la fonction lift2 pour cela et donnez son type.
Exercice 2 : Couples et map
Écrivez une fonction map_left prenant un couple $c$ et une fonction $f$, et retournant un couple dont le premier terme est l'image du premier terme de $c$ par $f$ et le deuxième terme est le deuxième terme de $c$. Quel est son type ?
Écrivez map_right, qui agit de même en appliquant la fonction sur le deuxième terme. Donnez son type.
Écrivez map_both, qui prend un couple et une fonction et applique la fonction sur chaque terme du couple. Donnez son type.
Écrivez une fonction merge, prenant un couple, une fonction à deux arguments, et appliquant la fonction aux deux termes du couple dans l'ordre. De nouveau, donnez son type.
Utilisez merge pour écrire une fonction prenant un couple d'entiers et retournant le couple composé de la somme et de la différence des deux entiers.
Exercice 3 : Les options.
le type 'elt option permet de représenter une valeur de type 'elt, ou bien son absence. Pour créer une valeur optionnelle, on utilise les constructeurs Some et None.
let some_int = Some (2 + 2)
let no_int = None
Les options permettent notamment de ne pas avoir besoin de retourner le pointeur nul lorsque typiquement une fonction n'a pas de résultat valide. Pour manipuler les options, nous pouvons utiliser les fonctions de Core.Std.Option, par exemple :
val value : 'elt option -> default:'elt -> 'elt
val is_none : 'elt option -> bool
val is_some : 'elt option -> bool
val map : 'elt option -> f:('elt -> 'im) -> 'im option
À partir du type de ces fonctions, pouvez-vous deviner ce qu'elles font ?
On dispose d'une base de donnée, de type db, contenant des identités de type Identity.t et d'une fonction de requête find_name : name:string -> db ->
Identity.t option. On a par ailleurs :
module Identity : sig
type t
val name : t -> string
val age : t -> int
val country : t -> string option
val phone_number : t -> string
end
Écrivez les fonctions :
val get_age : name:string -> int option
val get_phone_number : name:string -> string option
val get_country_and_phone : name:string -> (string * string) option
Si une identité n'a pas de pays associé, on supposera que le pays est "France".
Écrivez une fonction flatten : 'elt option option -> 'elt
option telle que flatten (Some (Some v)) = Some v.
Écrivez une fonction unsome : 'elt option -> 'elt telle que unsome (Some v) = v.
Exercice 4 : Raisonner avec les types.
En OCaml, il est courant de programmer en se basant uniquement sur les types, sans avoir besoin de réfléchir à la sémantique du programme. On se donne les valeurs suivantes :
val f : a -> b
val g : a -> c
val h : (a -> e) -> d
val i : b -> c -> e
val m : 'any -> 'any t
val n : 'any t -> ('any -> 'res t) -> 'res t
val o : w -> x t
val p : x -> y t
val q : y -> z
Trouvez une valeur de type d en utilisant f,g,h,i.
Écrivez une fonction de type w t -> z t.
