Discussion :

[prgasp77]

Bonjour à tous,
quelque part dans mon code on peut lire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

let [v_x;v_y;v_z] = List.map( ( ** ) v) [e_x;e_y;e_z]

Ceci est une méthode très esthétique (je trouve) pour déclarer trois variables, résultats d'un changement de base. Ma fonction (**) v ne peut lever d'exception, et le résultat est donc garanti.

Néanmoins, ocamlc me sort un warning P (this patter-matching is not exhaustive ...). Sela me semble compréhensif, mais existe-t-il un moyen de lui dire "t'inquiète, je m'en occupe" sans toucher à cette belle ligne ?

Merci.

[LLB]

Tu peux ajouter l'option "-w p" lors de la compilation. Les warnings P (partial match) sont alors désactivés. Il faut faire attention car cet avertissement est parfois utile ; ne viens pas te plaindre après ! En particulier, lorsque tu modifies ta liste et ajoutes un élément à droite, si tu oublies d'ajouter un identifiant à gauche, tu auras une exception.

À ma connaissance, il n'est pas possible de désactiver localement un warning en Caml. Dommage !

[SpiceGuid]

Le warning me paraît tout à fait justifié, il n'y a aucune raison d'utiliser un foncteur de type liste si en fait tu veux un foncteur de type triplet.

Code Caml :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
let map3 f (x,y,z) = (f x,f y,f z)
 
let (v_x,v_y,v_z) = map3 ( ( ** ) v) (e_x,e_y,e_z) in ...

Dans certains langages le foncteur (la fonction map) est défini automatiquement sur tous les types de données, et pas seulement sur le type liste.

[Cacophrene]

Bonjour !

Attention quand même avec les n-uplets et l'ordre d'évaluation en OCaml. Voir par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
# let map3 f (x, y, z) = (f x, f y, f z);;
val map3 : ('a -> 'b) -> 'a * 'a * 'a -> 'b * 'b * 'b = <fun>
# let f x = print_int x; x + 1;;
val f : int -> int = <fun>
# map3 f (1, 2, 3);;
321- : int * int * int = (2, 3, 4)

C'est assez pénible et on doit se forcer à écrire une version verbeuse :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
let map3 f (x, y, z) =
  let x' = f x in
  let y' = f y in
  let z' = f z in (x', y', z')

Évidemment s'il n'y a pas d'effets de bord c'est autre chose... mais si par la suite le code évolue et que f contient des effets de bord, c'est la prise de tête assurée.

Cordialement,
Cacophrène

[gasche]

pour précisément le problème de prgasp77, j'ai écrit l'extension camlp4 refutable.

On code comme cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

let refutable [v_x;v_y;v_z] = List.map( ( ** ) v) [e_x;e_y;e_z]

Et camlp4 produit la sortie suivante, qu'il envoie au compilateur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
let (v_z, v_y, v_x) =
  match List.map (( ** ) v) [ e_x; e_y; e_z ] with
  | [ v_x; v_y; v_z ] when true -> (v_z, v_y, v_x)
  | _ ->
      failwith
        "Refutable matching failed (File \"test.ml", line 1, characters 15-26)"

[InOCamlWeTrust]

Je ne vois pas en quoi c'est élégant, ni pratique.

Si j'ai trois variables, je devrai écrire explicitement deux listes à trois éléments.
Si j'ai quatre variables, je devrai écrire explicitement deux listes à quatre éléments.
Si j'ai cinq variables, je devrai écrire explicitement deux listes à cinq éléments.
Si j'ai six variables, je devrai écrire explicitement deux listes à six éléments.
Si j'ai sept variables, je devrai écrire explicitement deux listes à sept éléments.
[...]
Je vous laisse écrire la suite.

Ce n'est ni pratique, ni facile d'usage, ni lisible (en tous cas, pas plus que l'écrire explicitement) et ça na compile même pas proprement !

[LLB]

Je ne vois pas en quoi c'est élégant, ni pratique.

Pour l'élégance, c'est subjectif.
Pour le côté pratique, il a donné un exemple. SpiceGuid a proposé une alternative, mais elle est plus longue et plus trompeuse (ordre des effets de bord). Que proposes-tu ?

Ça ne t'arrive jamais de manipuler une liste dont tu connais à l'avance le nombre d'éléments ?

Exemple que j'ai eu ce matin : j'ai une adresse IP sous forme de string. J'appelle une fonction qui découpe par rapport aux points, elle me renvoie une liste de 4 éléments. Je préfèrerais écrire le code suivant :

let refutable [a;b;c;d] = List.map int_of_float (String.split "." ip)

[Cacophrene]

Bonjour !

La solution à base de camlp4 proposée par bluestorm vient à point nommé et, pour le coup, je la trouve réellement élégante car elle a le mérite d'insister sur le caractère réfutable du motif par un mot-clef ad hoc.

Évidemment, on peut crier à la fainéantise, faire le filtrage soi-même n'est pas très contraignant, et tout et tout. Mais quand même c'est sympa.

Cordialement,
Cacophrène

[InOCamlWeTrust]

Pour l'élégance, c'est subjectif.
Pour le côté pratique, il a donné un exemple. SpiceGuid a proposé une alternative, mais elle est plus longue et plus trompeuse (ordre des effets de bord). Que proposes-tu ?

Un truc tout con...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
let e_x = x ** v
and e_y = y ** v
and e_z = z ** v in
...

... c'est très simple également à écrire.

Ça ne t'arrive jamais de manipuler une liste dont tu connais à l'avance le nombre d'éléments ?

Honnêtement, non, sauf dans des cas particuliers et rares où il faut initialiser des données. Mais dans ce cas, nul besoin de nomer chaque élément.

Exemple que j'ai eu ce matin : j'ai une adresse IP sous forme de string. J'appelle une fonction qui découpe par rapport aux points, elle me renvoie une liste de 4 éléments.

Et pourquoi ne pas les mettre dans un vecteur v à quatre éléments ? En termes d'accès, c'est pareil, et il te suffit de nommer le vecteur, et non ses éléments. Dans ce cas présent, je pense qu'une liste n'est pas adaptée. Les listes sont à accès séquentiel, et ne conviennent donc pas pour accéder directement aux éléments.

[SpiceGuid]

+1
Il y a une syntaxe simple pour faire des trucs simples, utilisez-la au lieu de nous demander des astuces pour couper les cheveux en 4.

[gasche]

Le problème c'est que cette proposition donne lieu à une duplication de l'information ((**) v). List.map permet justement de factoriser cette transformation, de façon générique par rapport à la taille de la liste (parce que la fonction map3 spécialisée aux tuples c'est une solution qui conviendrait, mais si tu choisis de passer en 4D, pouf), et c'est, je pense, ce qui fait l'élégance de cette solution aux yeux de ceux qui l'apprécient.

Pour éviter les répétitions, il faut factoriser ce traitement, ce qui est faisable aussi dans le cadre de la solution de InOCamlWeTrust avec une définition auxiliaire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
let e_x, e_y, e_z =
  let (!) e_n = v ** e_n in
  !e_x, !e_y, !e_z

Le choix de (!) est purement esthétique et vous pouvez prendre ce que vous voulez. Ça reste plus lourd syntaxiquement que le List.map. Un avantage par rapport au List.map c'est qu'on n'est pas obligé d'avoir tous les éléments de même type : parfois on fait un traitement générique polymorphe sur des éléments de types différents.

Le plus simple serait sans doute d'avoir accès à une famille de fonctions map_tup1, map_tup2, ..., map_tupn (avec par exemple 1 <= n < 42), comme en Haskell, ou dans un système plus puissant une fonction générique au type dépendant.

[prgasp77]

Bonjour à tous, et avant tout merci de votre implication.
Je tiens à rappeler que ma question était de savoir s'il était possible de renseigner au compilateur qu'il était inutile de lever tel warning sur telle expression, mon bout de code ne servant qu'à illustrer mon problème.

Mais vos réactions sur ma petite ligne sont très intéressantes, tous vos messages pratiquement m'on apprit quelque chose.

Ceci dit, pourquoi n'est-il pas possible à votre avis de définir un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Nupplet.map : ('a -> 'b) -> int -> 'a nupplet -> 'b nupplet

dans un genre ressemblant à Printf.printf ?

Merci.

[Cacophrene]

Salut !

Parce qu'un n-uplet n'est pas de la forme 'a * 'a * 'a * ... * 'a répété n fois mais bien 'a * 'b * 'c * 'd * 'e * ... * 'n. En d'autres termes ses éléments n'ont pas tous le même type (hétérogénéité), au contraire des listes par exemple. Donc :

• Soit tu définis des n-uplets homogènes.
• Soit tu utilises des listes avec l'avertissement précédent.
• Soit tu utilises les solution qu'on t'a données.

Cordialement,
Cacophrène

[prgasp77]

Oui, je voulais dire avec des n-upplet homogènes, est-ce possible ?
Et oui j'ai pris en compte les conseils que vous m'avez donné (message #9 de InOCamlWeTrust), bien que toutes vos propositions étaient intéressantes.

Mais pourquoi ais-je l'impression que tu es irrité ?

[InOCamlWeTrust]

Tout simplement parce que, en OCaml, il n'est pas possible de faire ce que tu veux. On ne peut, à partir du système de types, ni créer des n-uplets génériques ni garantir le fait que deux listes auront la même longueur.

C'est un principe de base du typage à la Hindley-Milner, que l'on oublie peut-être trop souvent de mentionner dans les cours de OCaml. Il faut l'intégrer pour comprendre les limites du système de types, car celui-ci ne peut pas tout résoudre !

[Cacophrene]

Bonjour !

Oui, je voulais dire avec des n-upplet homogènes, est-ce possible ?

En redéfinissant le type des n-uplets, oui. Mais ça devient une liste, au final...

Mais pourquoi ais-je l'impression que tu es irrité ?

Désolé si mon message a pu te donner cette impression, ce n'était pas du tout le cas.

Cordialement,
Cacophrène

[SpiceGuid]

Ceci dit, pourquoi n'est-il pas possible à votre avis de définir un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Nupplet.map : ('a -> 'b) -> int -> 'a nupplet -> 'b nupplet

dans un genre ressemblant à Printf.printf ?

avec des n-upplet homogènes, est-ce possible ?

Ton type est incorrect parce que l'arité de nupplet n'est pas int mais une valeur de type int.
En ocaml non seulement tu ne peux pas écrire la fonction map sur n'importe quel tuple homogène mais en fait tu ne peux même pas écrire son type, parce que l'arité est une valeur et tu ne peux pas mettre une valeur dans un type.


Si tu veux vraiment te prendre la tête le système de modules est plus expressif que le typage à la Hindley-Milner. Dans une certaine mesure il te permet de simuler certains types dépendants.

Code ocaml :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
module type Tuple
  =
  sig
    type 'a t
    val map : ('a -> 'b) -> 'a t -> 'b t 
  end 

module One 
  : Tuple with type 'a t = 'a 
  =
  struct
    type 'a t = 'a
    let map f = f 
  end

module Succ(N : Tuple)
  : Tuple with type 'a t = 'a * 'a N.t
  =
  struct
    type 'a t = 'a * 'a N.t
    let map f (h,t) = (f h),N.map f t 
  end

En redéfinissant le type des n-uplets, oui. Mais ça devient une liste, au final...

Presque, il y a toute de même une différence, par exemple ma fonction map n'est pas récursive ou du moins pas avec le même type.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
module Pair = Succ(One)  
module Triple = Succ(Pair)
module Quadruple = Succ(Triple)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
# Pair.map;;
- : ('a -> 'b) -> 'a Pair.t -> 'b Pair.t = <fun>
# Triple.map;;
- : ('a -> 'b) -> 'a Triple.t -> 'b Triple.t = <fun>
# Quadruple.map;;
- : ('a -> 'b) -> 'a Quadruple.t -> 'b Quadruple.t = <fun>

[prgasp77]

C'est pas mal déjà
Dernière question, le module Printf est-il compatible avec ce typage signé Hindley-Milner ?

[LLB]

Oui, c'est compatible grâce à une bidouille dans le compilateur. Le printf fourni fonctionne parce qu'il est reconnu et analysé par le compilateur. Tu ne peux donc pas définir ton propre printf (à moins d'utiliser un préprocesseur). Cela se fait aussi au prix de quelques subtilités dans le langage :

Cette expression est autorisée : Printf.printf "hello"
alors que celle-là est refusée : let s = "hello" in Printf.printf s
(il faudrait une annotation de type)

Tu peux jouer avec printf dans le mode interactif et afficher les types. Tu verras que c'est un poil compliqué (types format, format6, etc.), mais c'est pour que tout marche bien au niveau du système de typage.

[gasche]

Tout simplement parce que, en OCaml, il n'est pas possible de faire ce que tu veux. On ne peut, à partir du système de types, ni créer des n-uplets génériques ni garantir le fait que deux listes auront la même longueur.

C'est pas pour chipoter, mais même sans typage d'ordre supérieur on sait utiliser des "listes à longueur fixée" du pauvre. Ce sont des méthodes bien connues (exemple chez Oleg)

Un petit exemple en OCaml :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
type o
type 'a s
 
include
  (struct
     type ('a, 'n) nlist = 'a list
     let nil = []
     let cons hd tl = hd :: tl
     let to_list x = x
 
     let map = List.map
 
     type 'a witness = int
     let o = 0
     let s = succ
     let of_list n x =
       assert (List.length x = n); x
   end : sig
     type ('a, 'n) nlist = private ('a list)
     val nil : ('a, o) nlist
     val cons : 'a -> ('a, 'n) nlist -> ('a, 'n s) nlist
     val to_list : ('a, _) nlist -> 'a list
 
     val map : ('a -> 'b) -> ('a, 'n) nlist -> ('b, 'n) nlist
 
     type 'a witness
     val o : o witness
     val s : 'n witness -> 'n s witness
     val of_list : 'n witness -> 'a list -> ('a, 'n) nlist
   end)

(J'utilise des modules pour les types abstraits, mais pas de foncteurs ou d'ordre supérieur)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
# let test = cons 2 (cons 3 nil);;
val test : (int, o s s) nlist = [2; 3]

Évidemment, sans calcul au niveau des types, on serait bien embêté si on voulait un "filter" sans test dynamique par exemple. Même "concat" ne me semble pas évident à formuler correctement.