right hand side of let rec

right hand side of let rec

[Laurent Chéno]

Sorry : poor-english version at the end.

Je ne comprends pas ce qui se passe avec le programme suivant :

(*****)
let ignore _ = () ;;

type 'a cycle = {	mutable val : 'a ;
					mutable pred : 'a cycle ;
					mutable succ : 'a cycle } ;;

let ajoute_au_cycle c x 	let p = c.pred
	and s = c.succ
	in
	let r =	{ val = x ; pred = p ; succ = c }
	in
	p.succ <- r ;
	c.pred <- r ;
	r ;;

let cycle_of_list l 	let rec r = { val = hd l ; succ = r ; pred = r }
	in
	do_list (function x -> ignore (ajoute_au_cycle r x)) (tl l) ;
	r ;;
(*****)

Caml me renvoie un message d'erreur :

#Entrée interactive:
>	let rec r = { val = hd l ; succ = r ; pred = r }
>	                    ^^^^
Ce genre d'expressions n'est pas autorisé comme membre droit d'un "let rec".


Bien sûr, j'ai contourné la difficulté en écrivant

let cycle_of_list l      let hd_l = hd l
     in
     let rec r = { val = hd_l ; succ = r ; pred = r }
     in
     do_list (function x -> ignore (ajoute_au_cycle r x)) (tl l) ;
     r ;;

Mais pourquoi Caml est-il si malheureux ?

Cordialement, Laurent Chéno

------- poor english

the later program causes an error : unauthorised expression in rhs of "let rec"
why ?

Re: right hand side of let rec

[Pierre Weis]

> let cycle_of_list l =
> 	let rec r = { val = hd l ; succ = r ; pred = r }
> 	in
> 	do_list (function x -> ignore (ajoute_au_cycle r x)) (tl l) ;
> 	r ;;
> #Entrée interactive:
> >	let rec r = { val = hd l ; succ = r ; pred = r }
> >	                    ^^^^
> Ce genre d'expressions n'est pas autorisé comme membre droit d'un "let rec".
> 
> 
> Bien sûr, j'ai contourné la difficulté en écrivant
> 
> let cycle_of_list l =
>      let hd_l = hd l
>      in
>      let rec r = { val = hd_l ; succ = r ; pred = r }
>      in
>      do_list (function x -> ignore (ajoute_au_cycle r x)) (tl l) ;
>      r ;;
> 
> Mais pourquoi Caml est-il si malheureux ?

Parceque Caml ne veut pas faire bus error! On n'a pas le droit aux appels
de fonctions dans les membres droits de let rec de valeurs parceque
ces appels de fonction pourraient produire de telles erreurs en
accèdant à des morceaux non encore contruits des valeurs définies
récursivement. Un petit exemple expliquera le problème. Quelle est la
valeur de y dans

let rec x = 1 :: y
and y = tl x;;

ou même celle de x définit pas
let rec x = 1 :: tl x;;

Dans les deux cas cette indétermination de la valeur définie se
traduirait par une erreur à l'exécution (en modifiant peut-être un peu
l'exemple dans certaines implémentations).

C'est pourquoi on n'a le droit dans les définitions récursives qu'à
des constructions de valeurs (appels à des constructeurs, construction
de couples, d'enregistrements, références à des valeurs déjà construites
ou définies récursivement), à l'exclusion d'appels de fonctions. Cela
garantit la construction correcte des valeurs récursivement
définies. Caml est heureux de vous fournir cette garantie, et il est
d'ailleurs très heureux d'être le seul système ML (non paresseux) à
vous fournir des définitions récursives de valeurs...

> ------- poor english
> 
> the later program causes an error : unauthorised expression in rhs of "let rec"
> why ?

Because no function calls are authorised in right hand sides of let
rec. This is simply because this constraint ensures that recursively
defined values can be properly built with no bus error
problem. Consider for instance:

let rec x = 1 :: tl y
and y = tl x;;

or

let rec x = 1 :: tl (tl x);;

That's why Caml is proud to (statically) prevent this situation, and
offer you the recursive definition of non functional values (which is generally
forbidden by ML compilers).

Pierre Weis

INRIA, Projet Cristal, Pierre.Weis@inria.fr, http://cristal.inria.fr/~weis/