Discussion :

[Birdycheat]

Bonjour à tous, ayant commencé Ocaml il y a peu (de manière purement fonctionnelle) il y a des choses que je ne comprends pas, surtout sur la syntaxe, l'indentation propre, la place des parenthèses, des points-virgules simples (j'ai compris l'utilité des ";;" qui servent à finir une instruction). Je suis surtout déconcerté face à un petit code sur le tri fusion, le premier :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
let rec decoupe l = (* fonction qui découpe une liste en deux sous listes en alternant "gauche droite" *)
	match l with
	|x::y::ll -> let (l1,l2) = decoupe ll in
		(x::l1,y::l2)
	|x::ll -> let (l1,l2) = decoupe ll in
		(x::l1,l2)
	|[] -> ([],[]);;
 
(* relations d'ordres pour des scalaires *)
 
let sup x y =
	if x > y = true then true
	else false;;
let inf x y =
	if x < y = true then true
	else false;;
 
(* entrelacement des listes sans généricité *)
 
let rec fusion l1 l2 =
	match (l1,l2) with
	|([],[]) -> []
	|(x::ll1,[]) -> let l = fusion ll1 [] in x::l
	|([],y::ll2) -> let l = fusion [] ll2 in y::l
	|(x::ll1,y::ll2)-> if (x > y) = false
		then let l = fusion ll1 l2 in 
			x::l
		else let l = fusion l1 ll2 in
			y::l;;
 
(* tri fusion sans généricité *)
let rec tri_fusion l =
	match l with
	|[] -> [];
	|x::[] -> l;
	|_ -> 
		begin
			let (l1,l2) = decoupe l in 
			fusion (tri_fusion (l1)) (tri_fusion (l2));
		end;;

qui est totalement opérationnel, tandis que le second qui se veut générique (donc modification de la fusion et du tri fusion) ne fonctionne pas du tout (syntaxe invalide) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
let rec fusion l1 l2 rel = (* rel étant la relation d'ordre utilisée *)
	match (l1,l2) with
	|([],[]) -> []
	|(x::ll1,[]) -> let l = fusion ll1 [] rel in x::l
	|([],y::ll2) -> let l = fusion [] ll2 rel in y::l
	|(x::ll1,y::ll2)-> if (rel x y) = false
		then let l = fusion ll1 l2 rel in 
			x::l
		else let l = fusion l1 ll2 rel in
			y::l;;
let rec tri_fusion l rel = 
	match l with
	|[] -> [];
	|x::[] -> l;
	|_ -> 
		begin
			let (l1,l2) = decoupe l in 
			fusion (tri_fusion (l1) rel) (tri_fusion (l2) rel) rel;
		end;;

En tout cas merci d'avance pour votre aide.
Bonne fin de journée à tous.

[SpiceGuid]

Bonjour,
Et bienvenue sur les forums de developpez.net

C'est du code idiomatique qui fonctionne correctement. Pas d'erreur de typage. Pas d'erreur de syntaxe.

Code OCaml :

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

1
2
# tri_fusion [42;48;56;23;41;71] (>);;
- : int list = [23; 41; 42; 48; 56; 71]

Est-ce que tu utilises une console windows du genre OCamlWin ou OCamlWinPlus ?
Si oui alors opte plutôt pour Crimson Editor(pour windows) ou Geany(pour linux) plus la commande ocamlc.opt.exe -w +A-ez $(FileName).

Sinon est-ce que tu utilises un éditeur ocaml comme Merlin ou utop ?

[Birdycheat]

Bonsoir SpiceGuid, tout d'abord merci de m'avoir répondu aussi vite. C'est vrai que c'est assez spécial de passer de l'impératif à un langage fonctionnel. Pour répondre, j'utilise l'interpréteur interactif

Code :

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

ledit ocaml

sur Linux Mint (avant je compilais à la main sur Powershell Windows mais j'ai vite abandonné et suis passé sur une VM).

[Wx234]

il y a des choses que je ne comprends pas, surtout sur la syntaxe, l'indentation propre, la place des parenthèses, des points-virgules simples (j'ai compris l'utilité des ";;" qui servent à finir une instruction).

Pour la syntaxe suivre des tutoriels te permettra de te familiariser avec, il y a aussi la documentation officielle qui te permettra d'obtenir toutes les informations que tu souhaites à condition de savoir chercher dedans.
L'indentation est principalement une question de gout, il n'y a pas comme en python de "bonne" ou "mauvaise" indentation, mais si tu veux suivre l'usage courant alors lire des codes en OCaml fera largement l'affaire.
Concernant les points-virgules simples, en gros ça exécute ce qui est à gauche mais ignore son résultat puis prends en compte que ce qui est à droite, par exemple 5 + 4; 3 fait 5+4 qui donne 9 puis ignore 9 et donne 3.
Autre exemple si on regarde un bout de ton code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
(* tri fusion sans généricité *)
let rec tri_fusion l =
	match l with
	|[] -> [];
	|x::[] -> l;
	|_ -> 
		begin
			let (l1,l2) = decoupe l in 
			fusion (tri_fusion (l1)) (tri_fusion (l2));
		end;;

Dans "[];" le point virgule est inutile, de même dans "l;" et "fusion (tri_fusion (l1)) (tri_fusion (l2));"
Concernant ton erreur de syntaxe le message exact de ton compilateur sera très utile car il contient beaucoup d'informations, mais déjà je peux dire que dans le deuxième bout de code la fonction "decoupe" n'est pas définie