Re: Question point fixe

Re: Question point fixe

[Damien Doligez]

>From: Vincent Poirriez
>
>Why is it impossible to write:
>
>let rec monf = build monf;;

Because the compiler does not want to know anything about "build"
(except its type) when it compiles "monf".  Thus it doesn't know
whether "build" will use its argument or not.  If "build" does use its
argument, there is no way to make this work.  This is the same as
writing:

let rec x = succ x;;

Re: Question point fixe

[Xavier Leroy]

> > Why is it impossible to write:
> > let rec monf = build monf;;
>
> Because the compiler does not want to know anything about "build"
> (except its type) when it compiles "monf".  Thus it doesn't know
> whether "build" will use its argument or not.  If "build" does use its
> argument, there is no way to make this work.  This is the same as
> writing:
> let rec x = succ x;;

Not quite, because "monf" is a function while "x" above is an integer.

For a function, the compiler could initialize "monf" with
(fun _ -> raise Bottom), then evaluate "build monf" (raising "Bottom"
if "build" applies "monf"), then update the initial value as usual.

I'm not saying the compiler should do that: it's painful to implement
and it breaks a nice property of the current compilation for "let
rec", which is that if a "let rec" definition is accepted, then it
always succeeds at run-time in finding the fixpoint.

I would suggest that Vincent Poirriez either tolerates the efficiency
loss implied by "let rec monf x = build monf x", or uses a reference
to compute the fixpoint himself.

- Xavier Leroy

Question point fixe

[Pierre Weis]

From: Vincent Poirriez
Date: Tue, 18 Oct 94 09:43:00 +0100
To: caml-list@pauillac.inria.fr
Subject: Question point fixe


Ci-dessous une question dont j'ai oublie' la reponse:

Pourquoi n'a t'on pas le droit d'e'crire:

let build f =
 let g x = expr       (* ou` l'on fait appel a` f *)
  in
  function y -> expr' (* ou` l'on fait appel a` g *)
;;
let rec monf = build monf;;

L'intere^t de cette e'criture serait d'effectuer les 
calculs possibles par l'application partielle alors que
l'ecriture autorise'e:
 let rec monf x = build monf x;;
ne les effectue pas

Vincent
(Vincent.Poirriez@inria.fr)

(*I Hope my english isn't too bad*)   
Here after, a question that I don't remember the answer:

Why is it impossible to write:
let build f =
 let g x = expr       (* where f is called *)
  in
  function y -> expr' (* where g is called *)
;;
let rec monf = build monf;;

The interest of such a definition is to perform some
calculus in the partial application. These calculus
are not performed in the following allowed definition:
 let rec monf x = build monf x;;

Vincent
(Vincent.Poirriez@inria.fr)