From mboxrd@z Thu Jan 1 00:00:00 1970 Received: (from majordomo@localhost) by pauillac.inria.fr (8.7.6/8.7.3) id AAA19602; Thu, 13 Dec 2001 00:03:17 +0100 (MET) X-Authentication-Warning: pauillac.inria.fr: majordomo set sender to owner-caml-list@pauillac.inria.fr using -f 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 AAA19434 for ; Thu, 13 Dec 2001 00:03:16 +0100 (MET) Received: from mail.libertysurf.net (mail.libertysurf.net [213.36.80.91]) by nez-perce.inria.fr (8.11.1/8.11.1) with ESMTP id fBCN3Fb05117 for ; Thu, 13 Dec 2001 00:03:15 +0100 (MET) Received: from Utilisateur (195.242.76.7) by mail.libertysurf.net (5.1.053) id 3C112A76000FF767; Thu, 13 Dec 2001 00:03:15 +0100 Message-ID: <00a201c18360$f8135480$074cf2c3@Utilisateur> From: "Diego Olivier Fernandez Pons" To: Cc: "Caml" References: <15382.13531.184819.989958@helios.info-ua><4.3.2.7.2.20011211145019.028d8e50@arda.pair.com> <15383.12155.733583.353752@helios.info-ua> Subject: Re: [Caml-list] Function call with a list of parameters Date: Wed, 12 Dec 2001 23:31:53 +0100 MIME-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: 8bit X-Priority: 3 X-MSMail-Priority: Normal X-Mailer: Microsoft Outlook Express 5.50.4133.2400 X-MimeOLE: Produced By Microsoft MimeOLE V5.50.4133.2400 Sender: owner-caml-list@pauillac.inria.fr Precedence: bulk Vincent Barichard a écrit let fourAdd x y z w = x + y + z + w;; myFunctionCall fourAdd [1 ; 2 ; 3 ; 4];; # - : int = 10 On a effectivement un problème de typage de la fonction donnée en argument (puisque le type "fonction" sans précision d'arité n'existe pas en Caml). Si le code suivant marche, on est immédiatement en difficultés quand on veut changer le nombre d'arguments (même dans un cas fini). let applique f = function | [x; y; z; t] -> f x y z t | _ -> failwith "type error" ;; applique addfour [1; 2; 3; 4];; # - : int = 10 let applique f = function | [x; y; z] -> f x y z | [x; y; z; t] -> f x y z t | _ -> failwith "type error" ;; # This expression has type 'a but is here used with type 'b -> 'a Une première idée serait de passer par un type somme type fonction = | Unaire of (int -> int) | Binaire of (int -> int -> int) | Ternaire of (int -> int -> int -> int) ;; puis faire un filtrage dans lors le l'application let appliquer f liste = match f with | Unaire g -> let [x] = liste in g x | Binaire g -> let [x; y] = liste in g x y ;; Outre les avertissements que génère le code et la complication que requiert le passage au type somme proposé, ce code a le grand désavantage d'imposer que l'arité de f soit bornée. Peut on contourner la difficulté ? On remarquera que l'on peut écrire différemment le cas particulier que vous avez proposé : let add x total = x + total;; let addFour x y z t = add x (add y (add z (add t 0))); Et appliquer la fonction add sur une liste de longueur quelconque est tout à fait possible. Peut-on éviter d'appliquer à chaque étape la même fonction ? oui ! let add2 x total = total + x + 2;; let add3 x total = total + x + 3;; let add5 x total = total + x + 5;; let add7 x total = total + x + 7;; let add17 x y z t = add2 x (add3 y (add5 z (add7 t 0)));; Si l'on dispose d'une liste de fonctions, on peut sans difficulté l'appliquer au moyen de : let rec applique_fonctions argument = function | [] -> argument | (tete :: queue) -> applique_fonctions (tete argument) queue ;; # val applique_fonctions : 'a -> ('a -> 'a) list -> 'a = Autrement dit, si vous arrivez à transformer votre fonction à n arguments en composée de n fonctions d'arité fixe, vous pourrez alors les appliquer à une liste de n paramètres indépendamment de n. Cela dit, ce dernier problème n'est ni plus aisé, ni toujours soluble. Diego Olivier ------------------- Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/ To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr