Types et polymorphisme (let et fun) [Résolu]

[n0-sheep]

Bonjour à tous,
Je m'attaque à la compréhension de la gestion des types en Caml et voici quelque chose que je ne m'explique pas, peut-être pourrez-vous m'aider à comprendre :

[EDIT]
J'essaie d'obtenir une fonction du type

Code :

1
2
f : ('a -> 'b) -> 'a1 -> 'a2 -> 'b1 * 'b2 = <fun>

[/EDIT]

A priori, je pensais qu'il fallait utiliser un let :

Ici ca marche, j'utilise un let, id a été déclarée au préalable :

Code :

1
2
3
#let fonc' = fun x -> (id x) in fun x y -> (fonc' x, fonc' y);;
- : 'a -> 'b -> 'a * 'b = <fun>

Ici, ca ne marche pas, pourtant j'utilise la même structure au sein de la fonction....

Code :

1
2
3
#let f id = let fonc' = fun x -> (id x) in fun x y -> (fonc' x, fonc' y);;
f : ('a -> 'b) -> 'a -> 'a -> 'b * 'b = <fun>

Merci d'avance

[SpiceGuid]

Et pourquoi pas :

Code Caml :

1
2
# fun x y -> x,y;;
- : 'a -> 'b -> 'a * 'b = <fun>

[n0-sheep]

Bonjour,
Merci pour votre réponse.

J'ai du mal m'exprimer, il faut dire que le concept n'est pas encore très clair pour moi.
Je voudrais faire ça :

Code :

(f id)(2, 2.);;

avec ce type :

Code :

1
2
3
f : ('a -> 'b) -> 'a -> 'c -> 'b * 'd = <fun>
ou :
f : ('a -> 'b) -> 'a1 -> 'a2 -> 'b1 * 'b2 = <fun>

(J'ai édité mon premier message pour mieux le préciser)

[Ptival]

Code :

f : ('a -> 'b) -> 'a -> 'c -> 'b * 'd

Tu ne peux pas retourner un élément de type 'd si tu ne reçois pas un argument de type 'd ou une fonction qui retourne entre autres un 'd.

Il n'y a donc pas de bonne réponse à ta question : soit tu nous expliques comment tu souhaites utiliser ta fonction ou son but, et on peut te guider, ou bien tu veux vraiment créer une fonction de ce type, et personne ne peut t'aider dans cette quête.

En particulier, ton appel :

Code :

(f id)(2, 2.)

semble assez suspicieux. Que doit-il retourner ? Que fait-il d'id en particulier ?

[prgasp77]

Tout à fait, il te faut un moyen de retourner un 'd à partir de 'a et de 'b.

Envoyé par Ptival

En particulier, ton appel :

Code :

(f id)(2, 2.)

semble assez suspicieux. Que doit-il retourner ? Que fait-il d'id en particulier ?

Les parenthèses en moins − f id (2, 2.) − c'est tout de suite plus clair. En OCaml (et en général avec les langages construits sur le modèle de lambda-calcul), il n'y a pas de distinction entre une fonction qui prend deux arguments a et b d'une part, et une fonction qui prend un argument a et retourne une fonction qui prend un argument b d'autre part.

Cdlt,

[n0-sheep]

Bonjour à tous,
Merci beaucoup pour vos réponses. Voici quelques précisions sur ce que je cherche :

J'ai cette fonction :

Code :

1
2
3
#let func = fun a -> (true, a);;
func : 'a -> bool * 'a = <fun>

J'ai cette autre fonction :

Code :

1
2
3
#let applicator func = fun x y -> (func x, func y);;
applicator : ('a -> 'b) -> 'a -> 'a -> 'b * 'b = <fun>

Donc ceci marche :

Code :

1
2
3
#applicator func 2 3;;
- : (bool * int) * (bool * int) = (true, 2), (true, 3)

Néanmois, la fonction func peut s'appliquer aux int mais aussi au float :

Code :

1
2
3
4
5
#func 1.0;;
- : bool * float = true, 1.0
#func 2;;
- : bool * int = true, 2

Donc je voudrais pouvoir faire ceci sans erreurs :

Code :

1
2
3
4
5
>applicator func 2 1.0;;
>                  ^^
This expression has type float,
but is used with type int.

Pour ça, je remarque que si l'on passe par une forme let, ça fonctionne :

Code :

1
2
3
#let func' = fun x -> (true,x) in fun x y  -> (func' x, func' y);;
- : 'a -> 'b -> (bool * 'a) * (bool * 'b) = <fun>

Ce que je cherche, c'est un moyen de mélanger les deux, un peu a cette manière :

Code :

1
2
3
#let applicator' = let func' = fun x -> (true,x) in fun x y  -> (func' x, func' y);;
applicator' : 'a -> 'b -> (bool * 'a) * (bool * 'b) = <fun>

Par exemple, quelque chose équivalent à ceci :

Code :

1
2
3
#let applicator' func = let func' = fun x -> func x in fun x y  -> (func' x, func' y);;
applicator' : ('a -> 'b) -> 'a -> 'a -> 'b * 'b = <fun>

J'ai alors essayé ceci sans succès :

Code :

1
2
3
let applicator' func = let func1 = fun x -> func x in let func2 = fun y -> func y in fun x y  -> (func1 x, func2 y);;
applicator' : ('a -> 'b) -> 'a -> 'a -> 'b * 'b = <fun>

Mais cette tentative échoue.

voilà donc ce que j'essaie de faire...


Merci à vous

[prgasp77]

Je comprends. Ton problème (et sa solution) est décrit ici : Higher-Rank Polymorphism in OCaml [legiasoft.com].

[n0-sheep]

Bonjour,
Merci beaucoup pour la piste de recherche, je vais regarder de ce coté.

[SpiceGuid]

Code OCaml :

1
2
3
4
5
# let func a = true,a
  and applicator f g x y = f x, g y;;

# applicator func func 2 1.0;;

Ou bien te compliquer la vie avec du Higher-Rank Polymorphism