Discussion :

[sioul]

Je viens de commencer la programmation en Caml au lycée, et j'ai donc décider d'installer le logiciel chez moi. Le probleme est qu'au lycée les pc tournent sous linux, avec Camlight et emacs mode tuareg tandis que je suis sous windows. j'ai donc télécharger Ocaml et emacs mode tuareg à cette adresse.

Cependant je rencontre des problemes : par exemple pour une fonction récursive qui me permettrais de concaténer deux listes et qui me semble t il fonctionnait très bien au lycée

Code :

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

1
2
3
let rec concat = fun
 | [] l   -> l
 | h::q l -> h::(concat (q l));;

j'obtient ceci

Code :

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

1
2
3
4
5
6
7
# let rec concat = fun
 | [] l   -> l
 | h::q l -> h::(concat (q l));;
    Characters 22-23:
   | [] l   -> l
   ^
Syntax error

D'une manière plus générale je n'arrive pas a me servir de "fun".

Cela est il dut a une différence entre ocaml et camlight ?
Et comment faire pour résoudre ce problème ? ( je veux dire par la que dois je faire pour que la version Caml de mon pc accepte les codes qui le sont par les ordis du lycée )

Merci d'avace a la personne qui me répondras, et je m'excuse pour ma "noobitude"

[gorgonite]

perso, je te conseille d'utiliser la notation match ... with

Code :

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

1
2
3
let rec concat l1 l = match (l1, l) with
   ([],l)   -> l
 | (h::q,l) -> h::(concat (q l));;

[sioul]

merci beaucoup pour l'astuce
(par contre il faut écrire concat q l et non concat (q l) sinon caml fait une crise au sujet du fonction qui ne peux pas etre applied )

Sinon sais tu a quoi est du le pobleme de syntaxe avec fun ?
Parce que j'ai essayé de trouver sur internet des exemples de fonctions du meme types que celles utilisées par mon prof (du type let rec fonction = fun ) et je n'ai rien trouvé.
En effet ,meme si match with fonctionne, je préfèrerais écrire le meme type de programmes que mon prof

[gorgonite]

le match with est plus performant que le fun ->


le problème vient du fait qu'il faut un seul argument après fun...


ps: dans quel lycée es-tu ? avec quel prof ?
c'est un vrai prof d'info, ou un prof de maths qui accepte de faire des tp de caml ?

[sioul]

j'ai répondu au ps par mp

le problème vient du fait qu'il faut un seul argument après fun...

oulala.
mais alors ca va poser un probleme ca.
parceque mon prof m'a donné (sur papier il est vrai, je ne sais plus si je les ai testées sur Caml) une bonne demi douzaine de fonctions commençant par

Code :

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

1
2
3
 
let rec fonction = fun
 | a b -> ...

Et si fun n'adet qu'une seule variable ... alrs toutes ces fonctions seraient fausses ?

Parceque ce qu'il nous a dit en cour, c'est qu'on utilise
let rec f = function quand on aune seule variable et
let rec f = fun quand on en a plusieurs

Ou alors cela dépendrait des versiond de Caml utiliséees ? (oCaml vs light )

[Strab]

Ton professeur a raison, fun accepte plusieurs arguments.

L'erreur est que fun ne sert pas à reconnaitre un motif, mais seulement a préciser les paramètres de la fonction. Tu ne peux donc pas avoir plusieurs cas comme avec match.

Ceci est possible :

Code :

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

let f = fun a b c -> a + b + c;;

Mais pas ça :

Code :

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

let f = fun 0 -> 1 | 1 -> 2 | x -> 0;;

[gorgonite]

Mais pas ça :

Code :

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

let f = fun 0 -> 1 | 1 -> 2 | x -> 0;;

pour un argument, ça passe normalement...

[sioul]

finalement, est il possible d'écrire une fonction du type

Code :

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

1
2
3
let rec concat = fun
 | [] l   -> l
 | h::q l -> h::(concat (q l));;

?
parceque vu les explications de Strab je pencherai pour un non (a moin que j'ai mal compris ), mais ces ligne de codes sont tirées directement de mon cours .... d'ou ma perplexité

[Steki-kun]

A mon sens, ton problème c'est juste que tu écris fun à la place de function !

fun permet de créer des lambda abstractions, c'est à dire de définir des valeurs de fonctions, sans nécessairement leur donner de nom. Sa syntaxe c'est bien

Code :

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

1
2
 
fun arg1 ... argn -> expression

la syntaxe

Code :

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

1
2
 
let [rec] nom_fonction [arg1 .. argn] = function cas1 -> ..  | ... etc

c'est du sucre syntaxique pour écrire:

Code :

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

1
2
 
let [rec] nom_fonction [arg1 .. argn] arg_en_plus = match arg_en_plus with cas1 -> ..  | ... etc

évidemment dans le cas où y'a un seul cas de matching, la syntaxe peut se confondre avec celle du fun, mais ca n'est pas du tout la même chose. Fun permet de définir des fonctions, function est juste un raccourci syntaxique pour faire une fonction qui débute par un match with. Dans ton cas, c'est donc function que tu veux utiliser, puisque fun ne permet pas de faire du matching directement.

[InOCamlWeTrust]

Le mot-clef fun n'est PAS du sucre syntaxique : il existe une vraie différence en termes de code engendré entre cette construction et le filtrage de n-uplets.

Plus généralement, fun accepte un ou plusieurs arguments, permet de filtrer les éléments, mais uniquement dans le cas de motifs irréfutables.

On peut écrire ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
[nestes @ apasinel] 16:08 % ocaml
        Objective Caml version 3.06
 
# type colour = Colour of int;;
type colour = Colour of int
# let f = fun (Colour c) -> c;;
val f : colour -> int = <fun>
# #quit;;
[nestes @ apasinel] 16:09 %

Et donc, comme on ne peut mettre que des motifs irréfutables, la barre '|' n'a aucun sens.

[LLB]

Le mot-clef fun n'est PAS du sucre syntaxique : il existe une vraie différence en termes de code engendré entre cette construction et le filtrage de n-uplets.

Au niveau du sucre syntaxique, c'est en effet : (version sucrée à gauche)

Code :

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

1
2
let f x y = ...   <=> let f = fun x y -> ...
function          <=> fun x -> match x

Et donc, comme on ne peut mettre que des motifs irréfutables, la barre '|' n'a aucun sens.

Presque. Il y a quelques cas où on peut la mettre :

Code :

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

1
2
type test = Foo of int | Bar of int * int
let f = fun (Foo x | Bar (x, _)) -> x

Il suffit d'arriver à gérer tous les cas en un seul motif.

[Steki-kun]

Le mot-clef fun n'est PAS du sucre syntaxique : il existe une vraie différence en termes de code engendré entre cette construction et le filtrage de n-uplets.

Oui, ai-je prétendu le contraire ? J'ai parlé de [b]function[\b], pas de [b]fun[\b]. Peut être tu ne répondais pas à moi, mais ça en avait l'air alors je tiens à préciser...

[InOCamlWeTrust]

Désolé, j'ai lu trop vite.

Toutes mes excuses.

Très bien vu aussi le coup du "Or" pattern... c'est une chose, effectivement, à laquelle on ne pense pas souvent : personnellement, je programme beaucoup en Objective Caml, et je ne me souviens jamais qu'on peut l'utiliser.

[LLB]

Très bien vu aussi le coup du "Or" pattern... c'est une chose, effectivement, à laquelle on ne pense pas souvent : personnellement, je programme beaucoup en Objective Caml, et je ne me souviens jamais qu'on peut l'utiliser.

C'est vrai que ça s'utilise peu souvent dans un let ou un fun :

Code :

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

1
2
3
4
# let 0, x | x, _ = 1, 2;;
val x : int = 1
# let 0, x | x, _ = 0, 2;;
val x : int = 2

Mais cette même construction se rencontre régulièrement pour regrouper plusieurs cas d'un pattern matching (je vous laisse deviner ce que fait la fonction ) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
let simplify =
  let op_to_fct = function
    | Plus -> (+) | Minus -> (-) | Times -> ( * ) | Div -> (/) | Custom a -> a
  in map (function
    | BinOp (op, Val a, Val b) -> Val ((op_to_fct op) a b)
    | UnOp (UMinus, Val a) -> Val (-a)
    | BinOp (Times, Val 0, _) | BinOp (Times, _, Val 0) -> Val 0
    | BinOp (Times, Val 1, a) | BinOp (Times, a, Val 1)
    | BinOp (Minus, a, Val 0) | BinOp (Div, a, Val 1)
    | UnOp (UPlus, a)         | UnOp (_, UnOp (_, a))
    | a -> a)

Ou encore (ici, on pourrait tout mettre dans le let, mais on perd en lisibilité) :

Code :

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

1
2
3
4
5
6
let pos_of_exp = function
 | Int (pos, _)
 | Float (pos,_)
 | String (pos,_)
 | FunCall (pos,_,_)
 | If (pos,_,_,_) -> pos

[Patriarch24]

Les fonctions s'introduisent normalement par le mot-clé function. Chaque paramètre de la fonction est introduit par une nouvelle construction function. Par exemple :

function x -> function y -> ...

définit une fonction à deux paramètres x et y. Les fonctions qui procèdent par filtrage s'introduisent également par le mot-clé function.
Le mot-clé fun introduit des fonctions curryfiées (à plusieurs arguments successifs). Par exemple :

fun x y -> ...

introduit une fonction à deux arguments x et y comme la précédente.


(extrait de la faq Ocaml sur caml.inria.fr)