From mboxrd@z Thu Jan 1 00:00:00 1970 Received: (from weis@localhost) by pauillac.inria.fr (8.7.6/8.7.3) id RAA02460 for caml-redistribution; Tue, 3 Jun 1997 17:16:51 +0200 (MET DST) Received: from nez-perce.inria.fr (nez-perce.inria.fr [192.93.2.78]) by pauillac.inria.fr (8.7.6/8.7.3) with ESMTP id PAA01717 for ; Tue, 3 Jun 1997 15:51:00 +0200 (MET DST) Received: from pulsar.univ-valenciennes.fr (pulsar.univ-valenciennes.fr [193.50.192.1]) by nez-perce.inria.fr (8.8.5/8.7.3) with ESMTP id PAA23279 for ; Tue, 3 Jun 1997 15:50:58 +0200 (MET DST) Received: from titan.univ-valenciennes.fr (titan.univ-valenciennes.fr [193.50.192.38]) by pulsar.univ-valenciennes.fr (8.7.3/jtpda-5.1) with SMTP id PAA00139 ; Tue, 3 Jun 1997 15:58:34 +0200 (MET DST) Received: from titan (localhost) by titan.univ-valenciennes.fr (5.x/SMI-SVR4) id AA11302; Tue, 3 Jun 1997 15:47:23 +0100 Message-Id: <33942E7A.7C54@univ-valenciennes.fr> Date: Tue, 03 Jun 1997 15:47:22 +0100 From: Vincent Poirriez Organization: limav X-Mailer: Mozilla 3.01Gold (X11; I; SunOS 5.4 sun4m) Mime-Version: 1.0 To: Jean.Luc.Paillet@lim.univ-mrs.fr Cc: caml-list@inria.fr Subject: Re: sequencing References: <9706030959.AA15419@gyptis.univ-mrs.fr> Content-Type: text/plain; charset=iso-8859-1 Content-Transfer-Encoding: 8bit Sender: weis Jean.Luc.Paillet@lim.univ-mrs.fr wrote: > > Quelqu'un pourrait-il m'expliquer pourquoi le sequencement d'une fonction > a` effet de bord, telle que "print_string" par exemple, semble inverse' il n'est pas inversé puisqu'il n'est pas spécifié!!! Le sens naturel, pour nous autres, est l'évaluation de gauche à droite, ce n'est pas le même dans d'autres cultures et certaines raisons (efficacité de compilation par exmple) font que certains compilateurs évaluent de droite à gauche, c'est le cas pour ocaml. Si vous voulez controler l'ordre d'exécution utilisez l'opérateur de séquencement ";" ou, ce qui est équivalent pour votre exemple, les itérateurs "impératifs" Ce qui donne Objective Caml version 1.05 # List.iter;; - : ('a -> 'b) -> 'a list -> unit = # List.iter print_string ["a" ; "b"];; ab- : unit = () # let rec iter f = function [] -> () | h::t -> f h; iter f t;; val iter : ('a -> 'b) -> 'a list -> unit = # iter print_string ["a" ; "b"];; ab- : unit = () # au lieu de votre code > quand elle est appliquée sur une liste au moyen d'un iterateur. > > Par exemple > map print_string ["a" ; "b"] ;; produit > > ba- : unit list = [(); ()] > ce qui implique un parcours de la liste de droite a gauche . > Plus curieux, avec une definition recursive "personnelle" de l'iterateur, > telle que > > let rec monmap f liste = > match liste with [] -> [] | > head :: tail -> (f head) :: monmap f (tail) ;; > > On pourrait s'attendre ici a ce que "(f head)" soit evalue avant > l'appel recursif. He bien non, > on obtient encore > > monmap print_string ["a" ; "b"] ;; > ba- : unit list = [(); ()] > > Quelle est mon erreur d'interpretation ? > Doit-on penser que (f head) est empile jusqu'a ce que la fonction termine ? > > ????? > ********************************************** > ££ English version ££ > > I don't understand why the sequencing of side effects seems to be inverted, It is not inverted is it is not specified!!! The natural way, "for us" is to evaluate from left to right but it is not the same in other cultures and for some deep reasons (efficiency for example) some compilers evaluate from right to left, it is the case for ocaml. If you need to control the order of evaluation you have to use the operator ";" or, which is simpler for your example, the predifined "imperatif" iterator: This leads to Objective Caml version 1.05 # List.iter;; - : ('a -> 'b) -> 'a list -> unit = # List.iter print_string ["a" ; "b"];; ab- : unit = () # let rec iter f = function [] -> () | h::t -> f h; iter f t;; val iter : ('a -> 'b) -> 'a list -> unit = # iter print_string ["a" ; "b"];; ab- : unit = () # instead of your code > > when using "map" , like for example in the following: > > map print_string ["a" ; "b"] ;; gives > ba- : unit list = [(); ()] > > it means that the list is scanned from the right to the left > > More surprising, with a recursive hand made definition of "map", such as > > let rec monmap f liste = > match liste with [] -> [] | > head :: tail -> (f head) :: monmap f (tail) ;; > > We also obtain > > monmap print_string ["a" ; "b"] ;; > ba- : unit list = [(); ()] > > We could thing that "(f head)" is evaluated before the recursive call . > > What is my mistake ? > Does the term "(f head)" pushed on the recursion stack until terminating > the recursive calls, before being evaluated ? > > Thanks for an explanation > > Kind regards > > Jean-Luc Paillet > Vincent Poirriez -- Tel: (33) {0}3 27 14 13 33 Fax: (33) {0}3 27 14 12 94 mailto:Vincent.Poirriez@univ-valenciennes.fr http://www.univ-valenciennes.fr/limav/poirriez ISTV Université de Valenciennes Le Mont Houy BP 311 F59304 Valenciennes CEDEX