> [english summary at the end of this mail]

> 1. J'aimerai savoir si :
>
> 	let b = true
> 	let f = if b then f1 else f2
>
>    est compilé en f1, c'est-à-dire si la branche d'un "if" est
>    directement sélectionnée lorsque le booléen est "true" ou "false"
>    (sans l'évaluer, bien sûr ; simplement directement égal à "true" ou
>    "false" au moment de la compilation)

Non, il n'y a pas de propagation des constantes dans le compilateur
Objective Caml. Cependant, b n'est teste qu'une seule fois, et non pas
a chaque appel de f, qui se branche directement sur le code de f1
(voir question suivante).

>    La raison de ma question est que cela permettrait d'avoir des options
>    de compilation directement en Caml sans perdre d'efficacité.

C'est possible, a condition de bien sortir les tests des
fonctions. P.ex. ne pas ecrire

        let f x           if debug then ...;
          ...

(test a chaque appel de f), mais plutot

        let f           if debug then fun x -> ...; ...
                   else fun x -> ...

> 2. de la même manière, est-ce que
>
> 	let f = fun x -> e
> 	let f1 = f
> 	
>    est compilé en remplaçant tout appel à f1 par un appel à f ?

Oui. En fait, les identificateurs f et f1 ont la meme valeur
fonctionnelle, qui est une fermeture du code de fun x -> e.

>    Ma question est, là encore, de savoir si on ne perd pas
>    d'efficacité en renommant des fonctions.

Il n'y a pas de surcout a l'appel de fonction.

- Xavier Leroy

> =english====================================================================>
> 1. I would like to know if
>
> 	let b = true
> 	let f = if b then f1 else f2
>
> is compiled as f1, that is if the branch of an "if" expression is
> directly selected when the boolean expression is "true" or "false"
> (without performing any computation on it, of course; just directly
> equal to the constructor "true" or "false").

No, there's no constant folding in the compiler. However, b will be
tested only once, not at each call to f, so that's still fairly efficient.

> 2. the same way, is
>
> 	let f = fun x -> e
> 	let f1 = f
>
> compiled by replacing any call to f1 by a call to f ?

No, f and f1 have the same functional value: a closure of the code for
fun x -> e.

> The question is still to known if we don't loose efficiency by
> renaming functions.

We don't.