Discussion :

[asefthukom]

Bonjour,

je n'arrive pas à comprendre comment marche cette structure ni comment accéder à ses différents champs.
Si quelqu'un pouvait m'expliquer, je lui en serai gré.

Un exemple de code est le suivant :

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
 
type t = int list ;;
- : type t = int list
 
(* en particulier je ne comprends pas cette ligne *)
let ast = ref ( [] : t ) ;;
- : val ast : t ref = {contents = []}
 
!ast ;;
- : t = []
 
1 :: !ast ;;
- : int list = [1]
 
!ast ;;
- : t = []

Voilà si quelqu'un avait un peu de temps pour me détailler ça.

Cordialement

[TropMDR]

[CODE]
(* en particulier je ne comprends pas cette ligne *)
let ast = ref ( [] : t ) ;;
- : val ast : t ref = {contents = []}

La seule subtilité ici est la suivante : [] est la liste vide, et donc est de type blah list quelque soit blah. Donc si tu ne précises rien, tu obtiens ça :

Code :

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

1
2
# let r = ref [];;
val r : '_a list ref = {contents = []}

(note pas super importante pour maintenant : le '_a à la place d'un 'a signifie "cette référence n'est pas vraiment polymorphe, c'est juste que je ne sais pas encore bien ce que c'est, mais dès que tu feras un truc avec, je résoudrai le problème." Par exemple :

Code :

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

1
2
3
4
# r := 1 :: !r;;
- : unit = ()
# r;;
- : int list ref = {contents = [1]}

fin de la note)

Donc pour éviter ce problème, la personne qui a écris ce code précise le type de [] avec la notation ([] : t) qui dit "[] est de type t". Or t est défini égal à int list. Donc ça colle !

Donc puisque ([] : t) est une int list, ref ([] : t) est une référence sur une int list.

C'est plus clair ? Ou le problème est aussi avec ce que sont les références ?

[Cacophrene]

Bonsoir,

Pour compléter la réponse de TropMDR à propos des références : les références sont, dans caml, traitées historiquement avec une syntaxe propre (c'est-à-dire let foo = ref bar pour créer une nouvelle référence, foo := bar pour changer la valeur et !foo pour obtenir la valeur). Mais tu peux voir que l'interpréteur écrit aussi :

Code :

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

val ast : t ref = {contents = []}

En fait, les références peuvent aussi êtres vues comme un simple type record :

Code :

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

1
2
type 'a ref = {mutable contents : 'a}

C'est d'ailleurs comme cela que le type ref est défini dans le module Pervasives. Tu peux donc utiliser let foo = {contents = bar}, foo.contents <- bar et foo.contents et te passer ainsi du sucre syntaxique associé (mais en pratique, je pense que personne ne le fait).

Cordialement,
Cacophrène

[asefthukom]

Bonsoir,

Merci pour ces explications qui ont éclairés quelques points.
En effet je pensais que :

Code :

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

1
2
3
 
let ast = ref ( [] : t ) ;;
- : val ast : t ref = {contents = []}

était plutôt vu comme une int list list, ce que je ne comprenais pas du fait que quand je faisais

Code :

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

1
2
3
 
# let r = ref [];;
val r : '_a list ref = {contents = []}

je n'avais qu'une '_a list ref

Envoyé par TropMDR
Donc puisque ([] : t) est une int list, ref ([] : t) est une référence sur une int list.

Pouvez vous aussi me dire justement pourquoi c'est pas vu comme une référence [] list de type t (ie une ref int list list) ?

NB: Pour la note de TropMDR, j'avais en effet essayé de passé par une liste dont le type n'est pour le moment pas précisé ( '_a ) pour essayer de comprendre mais ça n'avait pas suffit.

Pour le deuxième point,

Code :

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

1
2
 
val ast : t ref = {contents = []}

Envoyé par Cacophrene
Tu peux donc utiliser let foo = {contents = bar}, foo.contents <- bar et foo.contents et te passer ainsi du sucre syntaxique associé (mais en pratique, je pense que personne ne le fait).

J'ai justement besoin de pratiquer ce genre de chose je crois, j'ai beaucoup de fonctions comme

Code :

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

1
2
3
4
 
let foo {contents = cont} =
  foo_2 cont
;;

Est-ce que cela veut bien dire "comme je n'ai pas de nom à mon ``champs mutable``, je le nomme cont" et après je pourrais l'appliquer à quelque chose ?

Merci pour le temps et les explications.

Cordialement

[Cacophrene]

Bonjour,

J'ai justement besoin de pratiquer ce genre de chose je crois

Comme je te l'ai dit dans mon précédent message : en pratique, personne ne le fait. Il y a de multiples raisons derrière. D'abord, dans les cours, on sépare souvent l'enseignement des références de celui du type record. Ensuite, le sucre syntaxique accentue l'idée selon laquelle il s'agit de deux notions bien distinctes. Bref, c'est bien de le savoir, mais l'utiliser... pense au principe de moindre surprise pour les gens qui, éventuellement, reliront et assureront la maintenance de ton code. Bref, c'est mieux avec la notation habituelle :

Code :

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

let foo bar = foo_2 !bar

Est-ce que cela veut bien dire "comme je n'ai pas de nom à mon ``champs mutable``, je le nomme cont" et après je pourrais l'appliquer à quelque chose ?

Je dirais : soit cont la valeur du champ contents de la référence reçue en entrée.

Cordialement,
Cacophrène

[asefthukom]

Bonjour,

Après avoir pas mal manipulé ces constructions, et grâce à vos explications, j'ai bien compris comment ça marche.

Merci !