Discussion :

[Inked31]

Bonjour, j'aimerai savoir si il est possible de créer une fonction prenant n paramètres. Par exemple une fonction prenant une fonction pouvant avoir 1 ou 3 paramètres.

Pour le moment j'ai quelque chose comme ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
let applique = fun f -> fun param ->
 f param;;

Je comprend pourquoi ça ne marche pas et que ça prend uniquement les fonctions ayant 1 paramètre mais je ne sais pas comment faire pour qu'elle puisse appliquer plusieurs paramètres.

Ex:
applique carre 4;;

applique somme 4 5;;

[drunkskater]

Salut,

En Caml, les fonctions sont currifiées (tu peux aussi jeter un coup d'oeil à l'article anglais qui est un peu différent), ce qui fait que les fonctions ne prennent qu'une seule variable.

Mais ça n'empêche pas du tout de travailler avec des fonctions de plusieurs variables ! Pour ça, tu as plusieurs solutions. Par exemple, pour définir f(x, y, z) :

- Soit tu exploites la curryfication, et tu notes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

let f x y z = ...

Auquel cas ce qui va passer c'est que f va être une fonction qui à x associe une nouvelle fonction g (pour laquelle x est fixé) qui à y associe une nouvelle fonction h (x et y fixés) qui à z associe f(x, y, z).
Ca peut paraître compliqué mais en réalité tu n'as pas forcément à réfléchir à tout ça quand tu définis des fonctions, tu peux prendre ça comme une notation. Tu verras qu'on s'y fait très vite et que c'est pratique dans certaines situations

- Soit tu préfères considérer que ta fonction à n variables est une fonction qui à un n-uplet associe une valeur de retour. Auquel cas tu peux tout à fait noter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

let f (x, y, z) = ...

Mais en réalité, ta fonction ne prend qu'un argument (le triplet (x, y, z)). Du coup tu aurais aussi bien pu noter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

let f t = ...

Et ensuite utiliser des fonctions pour extraire l'élément voulu du triplet t. Mais c'est quand même plus simple de attribuer des noms à ces éléments si tu vas t'en servir dans le corps de ta fonction !

- Enfin, tu as une dernière possibilité : Si tu as beaucoup d'arguments et que tu ne veux pas avoir à te rappeler de l'ordre dans lequel tu dois les donner, tu peux utiliser des Label. Et si tu as des arguments qui prennent souvent la même valeur, si bien que tu ne veux pas avoir à la repréciser, tu peux donner des arguments par défaut. Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

let f ?(z = 0.) ~x ~y  = ...

Que tu appellerait comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

f ~x:1. ~y:1.

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

f ~x:1. ~y:1. ~z:1.

A noter que ta fonction ne peux pas comporter que des arguments optionnels, et que du coup du fait de la curryfication tu ne peux pas les donner en derniers (c'est pour ça que j'ai mis le ?(z = 0.) avant ~x et ~y

Voilà, il y a pas mal de doc sur la définition de fonctions un peu partout sur le net, je pense que tu devrais trouver ce dont tu as besoin...

Bonne chance !

[SpiceGuid]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

let apply f x = f x

(n'importe qui peut voir que c'est une êta-expansion de la fonction identité)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
apply (fun x -> x*x) 4;;
apply (+) 4 5;;

Juste pour rire, la même chose sans apply :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
(fun x -> x*x) 4;;
(+) 4 5;;

[SpiceGuid]

Je comprend pourquoi ça ne marche pas et que ça prend uniquement les fonctions ayant 1 paramètre mais je ne sais pas comment faire pour qu'elle puisse appliquer plusieurs paramètres.

'a -> 'b c'est le type de toutes les fonctions, quelque soit le nombre ou le type de "paramètres".

Par exemple int -> float -> bool c'est 'a -> 'b où 'a=int et 'b=float -> bool.

[Cacophrene]

Bonjour,

Transformer f x y en g (x, y) ne me paraît acceptable que lorsque c'est vraiment nécessaire. En effet, un n-uplet n'est pas gratuit, il faut le créer, le filtrer, etc. Bon, ceci dit, beaucoup de fonctions de la bibliothèque standard sont écrites comme ça (toute la série des itérateurs doubles comme map2, par exemple). Une hypothèse (pas vérifiée) : un map2 sans n-uplet serait un petit peu plus efficace qu'un map2 avec n-uplets (mais ce serait plus flagrant avec un map3 ou un map4).

Je pense que la solution est à chercher du côté des applications partielles, comme cela a été expliqué par SpiceGuid. On peut écrire des fonctions spécialisées apply2, apply3, etc. ou simplement utiliser des parenthèses bien placées. On fera attention aux effets de bord, dans ce genre de code.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
let apply f x = f x
let apply2 f x y = apply (f x) y
let apply3 f x y z = apply (f x y) z
let apply4 f x y z t = apply (f x y z) t

Et les types qui vont bien :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
val apply : ('a -> 'b) -> 'a -> 'b
val apply2 : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c
val apply3 : ('a -> 'b -> 'c -> 'd) -> 'a -> 'b -> 'c -> 'd
val apply4 : ('a -> 'b -> 'c -> 'd -> 'e) -> 'a -> 'b -> 'c -> 'd -> 'e

Cordialement,
Cacophrène

[SpiceGuid]

Et les types qui vont bien :

Ajoute une parenthèses à droite :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
('a -> 'b) -> ('a -> 'b)
('a -> 'b -> 'c) -> ('a -> 'b -> 'c)
('a -> 'b -> 'c -> 'd) -> ('a -> 'b -> 'c -> 'd)
('a -> 'b -> 'c -> 'd -> 'e) -> ('a -> 'b -> 'c -> 'd -> 'e)

Et alors tu observes qu'ils sont tous du même type 'a -> 'a

C'est pas qu'ils ne vont pas bien, c'est qu'ils ne font rien.
Pourquoi ?
Je l'ai dit dans mon avant-dernier message :

l'application est une êta-expansion de la fonction identité

[Cacophrene]

Bonsoir,

Et alors tu observes qu'ils sont tous du même type 'a -> 'a

Damien, nous sommes entièrement d'accord sur le fait que la fonction applique du post original ne fait absolument rien. Partant de là, tout le développement apply2, 3 etc. de mon précédent message ne crée que des versions de plus en plus démentes de la fonction identité. Ceci dit, certaines personnes, particulièrement les débutants, ne connaissent pas les êta-expansions et/ou éprouvent des difficultés à les reconnaître, même quand elles sont appliquées à l'identité . Faire comme si de rien n'était est avant tout un prétexte pour leur montrer l'utilisation des n-uplets et des applications partielles. La trivialité du cas importe peu à mon avis, car ils se rendront vite compte de l'inutilité d'une fonction applique de ce genre tout en ayant appris quelque chose de concret dans l'intervalle. Quand ils voudront appliquer une fonction à deux paramètres à un itérateur, ils ne seront pas démunis. C'est comme ça que j'ai appréhendé les choses sur ce fil.

Cordialement,
Cacophrène