Voila ici il y aura une section reserve a ce langage utilise surtout en prepa Mp avec option info
En Travaux
 
Ce logiciel, trés utilisé en prépa MP en cours d'option info, est pratique pour compiler de petits programmes et permet un affiche graphique.
 
 
 
 
 
C'est surtout un langage utiliser pour réaliser des opérations mathématiques. Il est donc normal d'y retrouvé les opérations élémentaires ( +, -, /, * ).
 
Voici un exemple de calcul réalisé dans l'interpréteur de CAML:
 
#123+456;;
-: int = 579
 
A noter que le # n'est pas à écrire, mais qu'il indique que l'on peut saisir du texte.
 
Dans CAML, on peut traiter avec des entiers et des flottants(reels (decimaux)). Dans l'exemple précédent, nous avons utilisé deux entiers, donc nous avons comme réponse int (comme integer).
 
Exemple avec des flottants:
 
#1.23 +. 4.56;;
-: float = 5.79
 
On peut noter que CAML, dans sa syntaxe avec les flottants, oblige l'utilisateur à ajouter un . après l'opération, sous peine d'afficher une erreur.
 
Autre exemple:
 
#5e-3;;
-: float = 0.005
 
 
--------------------------------------------------------------------------------
 
Les différents types de données
En Caml, il y a différents types de valeurs. Les plus utilisés sont les entiers et les flottants. Voici les types de base: int, float, string, bool, char.
 
 
--------------------------------------------------------------------------------
 
Concept de fonction
Les définitions
 
#let nb = 789;;
nb: int = 789
 
On peut maintenant appeler n'importe quand le nombre 789 en utilisant la variable nb:
 
#nb;;
-: int = 789
 
Les définitions locales sont utiles quand nous devons utiliser un calcul uniquement une fois. Exemple de définition locale:
 
#let pi = 3.1415927 in pi *. 10.0 *. 1.0;; (* Pi existe pas dans caml*)
-: float = 314.15927
 
Comme on peut le voir ( le - : ), nous n'avons pas créé de nouvelle définition.
 
Déclarer deux fois une définition sous le même nom écrase la première.
 
Les fonctions
Les fonctions définissent des opérations auxquelles on peut passer des paramètres. Exemple:
 
#let carre_de (x) = x * x;;
carre_de: int -> int = < fun >
 
CAML sait que l'on va renvoyer un entier, parce que l'on a utilisé l'opération * sans mettre un point juste après.
 
On utilise la fonction comme ceci:
 
#carre_de (5);;
carre_de: int = 25
 
A noter que l'on aurait pu se passer de parenthèses:
 
#let carre_de x = x * x;;
carre_de: int -> int = < fun >
#carre_de 5;;
-: int = 25
 
Comme pour les définitions, on peut créer des fonctions locales:
 
#let cube_de x = let carre_de y = y * y in x * carre_de x;;
cube_de: int -> int = < fun >
 
On aurait également pu n'utiliser que des x, chaque fonction étant indépendante:
 
#let cube_de x = let carre_de x = x * x in x * carre_de x;;
cube_de: int -> int = < fun >
 
On peut imbriquer des fonctions locales les une dans les autres indéfiniment.
 
Déclarer deux fois une fonction sous le même nom écrase la première.
 
Les fonctions peuvent posséder n paramètres. Exemple:
 
#let somme a b = a + b;;
somme: int -> int -> int = < fun >
#somme 4 5;;
-: int = 9
 
Il existe également une instruction qui sert à créer des fonctions anonymes: function. Exemple:
 
#let carre_de = function x -> x*x;;
carre_de: int -> int = < fun >
 
Cette fonction est totalement équivalent à la fonction carre_de créée plus haut.
 
Une fonction qui ne possède pas de paramètre (Ex: affiche_bonjour ()) est appelée une procédure.
 
 
--------------------------------------------------------------------------------
 
L'instruction if then else
Cette instruction est utilisée dans tous les langages de programmation évolué, donc c'est normal de la retrouver dans CAML. Voici un exemple:
 
#let calcul a = if a=0 then a
else a*a;;
calcul: int -> int = < fun >
 
Cette fonction va calculé le carré de a si a est différent de 0. D'où la syntaxe:
 
if condition then opérations
else autres_opérations;;
 
La partie l'instruction else est optionnelle, mais si elle existe, son type doit être le même que celui de l'instruction then.
 
A noter également qu'il ne doit pas y avoir de ; la ligne avant l'instruction else.
 
 
--------------------------------------------------------------------------------
 
Les comparateurs
Ces opérateurs sont utilisés surtout avec les instructions de type if. Voici un tableau récapitulatif, valable pour les réels:
 
< : inférieur à  
<= : inférieur ou égale à  
> : supérieur à  
>= : supérieur ou égal à  
= : égal à (renvoie vrai ou faux)  
<> : différent de. On utilise aussi !=  
Pour les flottants, il faut ajouter un . . Exemple:
 
a >. b
 
 
Le séquencement
Il sert à exécuter une suite d'action, les unes après les autres, séparées par des ;. Exemple:
 
#print_string "Bonjour" ; print_string " tout le monde" ;;
Bonjour tout le monde-: unit= ()
 
L'instruction print_string est de type unit, donc renvoi un type unit.
 
Les boucles back
While
Les boucles while sont utilisées pour exécuter une action jusqu'à ce que la condition soit fausse. Voici un exemple de boucle:
 
#let affiche_bonjour n = let nb = ref n in
 while !nb > 0 do
  print_string "Bonjour";
  print_newline ();
  nb := !nb - 1
 done;;
 
Cette fonction aura pour but d'afficher n fois la chaîne de caractères (string) Bonjour. La syntaxe est donc la suivante:
 
while condition do
 instruction 1;
 instruction 2
done;;
 
Il ne doit pas y avoir de ; la ligne avant done. Il est inutile d'utiliser le séquencement de style begin ... end lorsque l'on travaille avec des boucles while.
 
For
Les boucles for sont utilisées pour exécuter une action un certain nombre de fois. Exemple:
 
#let affiche_bonjour n = for i=1 to n do
 print_string "Bonjour";
 print_newline ()
done;;
 
Cette fonction va donc afficher n fois la chaîne de caractères Bonjour. La syntaxe est donc la suivante:
 
for variable locale=indice to paramètre do
 instruction 1;
 instruction 2
done;;
 
Il y a aussi une variante avec downto:
 
for variable locale=indice downto paramètre do
 instruction 1;
 instruction 2
done;;
 
Avec le to, l'indice est incrémenté, avec le downto, il est décrémenté.
 
 
--------------------------------------------------------------------------------
 
Les références back
Dans les exemple que nous avons vus jusqu'ici, nous avons utilisé plusieurs fois l'instruction ref, et son opérateur de déréférencement !. Cette instruction est utilisée pour initialiser une variable à une certaine valeur ( int, float, string, unit . ). Pour rappeler la valeur de cette variable, on utilise donc le !. Exemple:
 
#let var = ref 10;;
var: int ref = ref 10
#!var;;
-: int = 10
 
On utilise également beaucoup l'opérateur d'affectation :=. Exemple:
 
#var := !var - 1;;
-: unit ()
#!var;;
-: int = 9
 
 
--------------------------------------------------------------------------------
 
Les tableaux
Les tableaux (ou vecteurs) sont utilisés pour stocker un nombre n de valeurs de même type (int, float, string, unit). Les tableaux sont de type vect. Voici comment on créé un tableau:
 
#let talbeau = [|1; 2; 3; 4; 5; 6|];;
tableau: int vect = [|1; 2; 3; 4; 5; 6|]
 
Ou bien:
 
#let tableau = make_vect 6 1;;
tableau: int vect = [|1; 1; 1; 1; 1; 1|]
 
Le premier paramètre ( 6 ) défini la taille du tableau, et le second ( 1 ) à quelle valeur il faut l'initialiser. Pour connaittre la taille d'un tableau, on utilise l'instruction vect_length. Exemple:
 
#vect_length tableau;;
-: int = 6
 
Chaque valeur dans le tableau est indexée, et est donc accessible par un simple appel. L'indexation commence à partir de 0, c'est-à-dire que pour appeler la première valeur, il faut appeler la position 0. Exemple:
 
#tableau.(0);;
-: int = 1
 
On peut également changer une valeur dans ce tableau comme ceci:
 
#tableau.(2) <- 10;;
-: unit ()
 
Notre tableau ressemble maintenant à ceci:
 
#tableau;;
-: int vect = [|1; 1; 10; 1; 1; 1|]
 
Un tableau est donc de taille fixe, et indexé par un indice unique qui désigne la position d'une valeur dans ce tableau.
 
 
--------------------------------------------------------------------------------
 
La récursivité back
On fait appelle à la récursivité lorsqu'un problème ne peut être résolu par un humain. Une fonction récursive fait appel à elle-même pour résoudre un calcul. Pour créer une fonction récursive, on utilisé l'instruction let rec.
 
On utilise la fonction définie plusieurs fois, mais avec des valeurs différentes à chaque fois. Exemple de calcul récursif : l'opération factorielle:
 
#let rec factorielle n = if n <= 0 then 1
 else n*factorielle (n-1);;
factorielle: int -> int = < fun >
 
Donc, le calcule de factorielle 4 donnera 24. La fonction s'appellera elle-même jusqu'à ce que n val 0, et n se décrémentera à chaque passage.
 
 
match with
Cette instruction permet de comparer une valeur d'un certain type à une autre valeur de même type. Exemple:
 
#let test_zero n = match n with
 0 -> "Ce nombre est nul"
 | _ -> "Ce nombre est différent de 0";;
 
 
--------------------------------------------------------------------------------
 
Les listes back
 
Fonctions de base
Les listes sont assez proches des tableaux. Mais elles ne sont ni indexées, ni de taille fixe. Elles ne possèdent également que des éléments de même type (int, float, . 'a signifie de tout type). On créé une liste vide comme ceci:
 
#let liste=[];;
liste: 'a list=[]
 
On ajoute un élément à l'aide de l'opérateur :: (opérateur cons):
 
#2::liste;;
-: int list = [2]
 
On peut ajouter plusieurs éléments en même temps:
 
#3::4::5::liste;;
-: int list = [3; 4; 5]
 
Ceci est une liste de type entiers. Comme on peut le constater, le 2 a disparu. On ne peut donc pas ajouter d'éléments à une liste sans en écraser le contenu, sauf en utilisant l'opérateur d'ajout: @:
 
#[10; 11]@liste;;
-: int list = [10; 11; 3; 4; 5]
 
Avec cette opérateur, une liste d'éléments est ajoutée avant la liste ciblée. On peut par contre, créer une liste directement remplie:
 
#let liste_remplie = ["Bonjour" ; " monde !"];;
liste_remplie : string list=["Bonjour"; " monde !"]
 
Ceci est une liste de type chaîne de caractères. Il est à noter que l'on peut imbriquer des listes dans des listes. On peut également faire des opérations dans les listes:
 
#let x=1 in [1 ;2 ;1+x ;2+x];;
-: int list = [1; 2; 2; 3]
 
Pour connaître la taille d'une liste, on utilise l'instruction list_length:
 
#list_length liste;;
-: int = 2
 
14.2. Accession aux éléments d'une liste
On ne peut accéder soit qu'au premier élément d'une liste, soit qu'à la liste privée de son premier élément. On note a le premier élément ( la tête ), et l la suite (la queue). Pour afficher le premier élément d'une liste:
 
#let tete = fun [] -> failwith "Ceci est une liste vide"
 | (a : :l) -> a;;
tete: 'a list -> 'a = < fun >
 
Pour afficher la queue de la liste:
 
#let queue = fun [] -> failwith "Ceci est une liste vide"
 | (a::l) -> l;;
 
 
--------------------------------------------------------------------------------
 
Le graphisme back
 
Cette section va vous montrer comment créer des dessins simples en CAML.
 
Pour pouvoir utiliser les fonctions graphiques, vous devez d'abord initialiser la bibliothèque graphique. Ceci se fait par la commande #open.
 
##open "graphics";;
 
Vous avez maintenant à votre disposition un certain nombre de fonctions vous permettant d'afficher des choses dans une fenêtre de dessin. Pour ouvrir une telle fenêtre, vous devez l'ouvrir:
 
#open_graph "";;
 
Et là, si vous êtes sous FreeBSD, vous devriez avoir un message d'erreur que je ne m'explique pas. Le message doit être le suivant:
 
The global value graphics__open_graph is referenced before being defined.
Please load an implementation of module graphics first.
 
C'est pour cela que la section suivante vous expliquera comment compiler un programme qui utilise les bibliothèques graphiques (pour contourner ce problème).
 
En admettant que cela marche, voici les fonctions utiles pour faire du graphisme:
 
moveto x y : permet de déplacer le marqueur de début de dessin à l'emplacement de coordonnées x et y.  
lineto x y : trace une ligne à partir de l'emplacement du marqueur vers le point de coordonnées x et y.  
set_color couleur : permet de choisir la couleur par défaut ( où couleur est un paramètre comme red, blue, green, yellow, white, black . et peut-être d'autres encore ).  
draw_circle x y rayon : dessine un cercle de centre de coordonnées x et y, et de rayon rayon.  
fill_rect x y taille_x taille_y : créé un rectangle colorié et sa position est définie par x et y qui représenterons son angle en bas à gauche. Taille_x et taille_y sont ses dimensions horizontales et verticales.  
fill_circle x y rayon : dessine un cercle plein de la couleur par défaut de centre de coordonnées x et y et de rayon rayon.  
draw_string "texte" : permet d'afficher un texte en mode graphique.  
Voilà pour les instructions de base.
 
 
--------------------------------------------------------------------------------
 
Index des fonctions les plus utilisées back
 
Affichage à l'écran en mode texte
print_string "texte" : Affiche la chaîne de caractères texte.  
print_int entier : Affiche un entier.  
print_newline () : Passe à la ligne.  
 
Traitement sur les types
float_of_int entier : Transforme un entier en flottant.  
int_of_float flottant : Transforme un flottant en entier.  
sqrt () : Calcul la racine carré du paramètre entre parenthèdes.  
 
Graphismes
moveto x y : Déplace le marqueur à la position x y.  
lineto x y : Trace une ligne de la position du marqueur vers la position x y.  
set_color couleur : Change la couleur par défaut en couleur.  
draw_circle x y rayon : Dessine le contour d'un cercle de centre x et y et de rayon rayon.  
draw_string "texte" : Affiche une chaîne de caractères texte.  
fill_rect x y taille_x taille_y : Dessine un rectangle plein de position x et y et de taille taille_x taille_y.  
fill_circle x y rayon : De même que draw_circle, mais le cercle est plein.  
 
Listes
list_length liste : Donne la taille d'une liste liste.  
 
Tableaux
make_vect x init : Créé un tableau de la taille indiquée par x et initialiser avec la valeur init.  
vect_length tab : Donne la taille d'un tableau tab.  
 
A suivre...
 
Toute aide est la bienvenue
 
Liens:
 
http://caml.inria.fr/download.en.html
pour télécharger le logiciel

reserved

reserved

on se calme
merci

up

personne n'utilise caml ??

c'est pas trop long???

non.

je crois qu'il y a des riches qui en fument mais c'est tout !

Caml pas Camel
 
Fumer tue

nraynaud doit etre le seul 'habitué' a connaitre, mais il est en vacances.
attend octobre et les etudiants en info pour faire un up

je parlais pas des clops

de quoi alors

de chameaux sans doute

 

moi j'aime bien Caml mais bon, en entreprise c'est dur a vendre

murielle, t'es trop belle

stiffler tu donnes mal au coeur

la rime avec caca va tomber

fallait pas manger mes fécès !

Je tiens à dire que le copier/coller de je sais pas quel tutoriel sans même remettre en forme rend le premier post complètement illisible et hautement inintéressant

moi je l'ai trouver bien !

arreter la pourrissionnage quoi

MAIS STFU

une introduction sur la programmation fonctionnelle eût été de bon aloi...

J'ai appris OCaml à paris 6. Ils en font bcp là bas. C'est sympa comme langage et très expressif. Faire un compilo pour un mini-langage est très, très simple.
De plus la récursivité est bien gérée et performante contrairement au C.
 
Sous windows on peut faire générer de l'assembleur au compilo caml. C'est linkable avec du C mais c'est très compliqué, même les types de base sont différents. Le int est sur 31 bits et pas 32 par exemple.

Arf, ça commence bien tiens. Tu parles des boucles while et for avant de parler de la récursivité. C'est une hérésie de faire ça en Caml car cela n'apporte que des mauvaises habitudes dans ce langage ( experience inside ou j'ai commencé la première année à apprendre les boucles pour en deuxième année tout recommencer à zero avec de meilleures bases )
 
Par contre, une fois en école d'inge vous serez chanceux d'avoir encore à faire un peu de Caml. Le langage à l'air de disparaitre completement du cursus superieur.

Si !.
OCaml c'est bien sympa comme langage.  
C'est pas mal enseigné dans les universités, et dans le supérieur aussi.
 
Après en entreprise etc, je sais pas si c'est vraiment utilisé, surement pour la recherche ?

Tous les ML ne sont pas bons mais OCaml (un truc français) est vraiment bien, et performant. Très, très performant. Je n'ai pas voulu y croire jusqu'à avoir une preuve :
http://shootout.alioth.debian.org/ [...] rt=fullcpu
 
Les raisons
- il a été conçu par des dieux de la compil à l'INRIA
- il gère très bien la récursivité
- son garbage collector est un mix de ce qui se fait de mieux

SML + MLton est également relativement violent dans le style

Il y avait déjà un topic unique si je ne m'abuse ?
 
(oui, j'aime bcp ce langage, même si je n'ai pas pratiqué depuis longtemps (et ça s'oublie))

Un de nous deux n'a pas compris le sens du site. Mais je sais pas si c'est toi ou moi    
A moins que ce soit de l'ironie ?  

ouais ok j'avoue je voulais donner une image positive du langage, mais les "flawed benchmark" du site sont quand même équitables. Les langages pourris et lents sont en bas du tableau, ici on a qd même OCaml devant le C, même si les benchs sont justement trop simple. Un prog qui fait un quicksort plus vite que le C ne peut pas être foncièrement mauvais

D = roulzor

 
si le quicksort du C a été fait avec la fonction standart qsort, y'a pas a s'etonner des pietres resultat du C, il fait un appel de fonction par comparaison
 
 

chrisbk : le C++ aussi par défaut (opérateur < ). Bien qu'en C c'est pire parce que l'appel est dynamique
heuresement qu'il y a les types de bases et les méthodes inline en C++.
Mais justement le fait que le qsort du C soit lent c'est un inconvénient réel.
Note : je ne sais pas s'ils ont utilié le qsort, mais je suis d'accord avec toi sur ce point

 
nan, enfin a moitié, paske deja pour des int/float ca va retomber sur le < habituel, sans appel de fonction, et pour le reste tu as toutes les chances de pouvoir beneficier de l'inlining
 

 
merci tu veux te joindre a moi dans ma Grande Croisade contre le C ?

j'ai écrit en fraçais pourtant ??
Non pas de croisade contre le C. Le C ça roxxor ça race, c'est juste un peu root comme langage
comment ça je suis hypocrite  

désolé j'ai ete trop prompt
 
Le C ca craint du cul  
 

Le meilleur langage, on ne le saura jamais...

Un 2ème chrisbk