Language caml

    les types  
   type   
   ecriture    
   maximum  
   minimum    
   exemple    
entiers int 1073741823 -1073741824 98
flottants float ?? ?? 9.8
booléens bool ?? ?? 2 < 1 = false
caractères char ?? ?? `5` ou `\``
chaînes de caractères string ?? ?? "Caml Light" ou "Jeudi 08/05"


- : =
- nom indéfini
xxx nom défini
: int/string/char/bool fun



    les opérateurs 
   opérateur   
   ecriture    
   exemple    
   addition 
  +   
  #1+2;; 
- : int = 3
   soustraction 
  -   
  #1-2;; 
- : int = -1
   multiplication 
  *   
  #1*2;; 
- : int = 2
   division 
  /  
  #2/2;; 
- : int = 1
   modulo  
   mod   
   #19 mod 4;;
- : int = 3
   opérateur sur des flottants 
   addition 
  +.   
  #12. +. 7.35;;
- : float = 19.35
   soustraction 
  -.   
  #12. -. 11.99;; 
- : float = 0.01
   multiplication 
  *.   
  #1.2 *. 1.2;; 
- : float = 1.44
   division 
  /.  
  #2. /. 2.1 ;; 
- : float = 2.1875
  puissance
  ** ou **.  
 #10. ** 3.;;
- : float = 1000.0
#10. **. 3.;;
- : float = 1000.0
    les opérateurs 
   opérateur  
   ecriture    
   exemple    
   et  
   & ou &&    
   #true & false;;
- : bool = false
   ou 
   or ou ||    
   #true or false;;
- : bool = true
   inerse 
   not   
   #not false;;
- : bool = true
   inférieur || supérieur 
   < > 
  pour indication true est supérieur  à false 
    les opération sur les chaines de caractère
   opérateur  
   ecriture    
   exemple    
   Concaténer deux chaînes 
    ch1 ^ ch2.   
 #"Caml" ^ "Light";;
- : string = "CamlLight"
  Récupérer le nième caractère d'une chaîne 
  str.[n]    
   #"azertyuiop".[3];;
- : char = `r`
  Obtenir la longueur d'une chaîne de caractères   
   string_length ch    
   #string_length "CamlLight";;
- : int = 9
  trace "[...]"   
   permet de tracer une fonction  
  The function decroissant is now traced.
- : unit = ()





    les conversions 
   type vers type   
   ecriture    
   exemple    
   convertir un string en int  
   string_of_int    
  #string_of_int 25;;
- : string = "25"
   convertir un int en float  
   int_of_float    
  #int_of_float 1.24;;
- : int = 1
   convertir un float en string  
   float_of_string    
 #float_of_string "12";;
- : float = 12.0





    les fonctions 
   description 
   ecriture    
   exemple    
   déclarer une constante 
  #let mafonction   
   #let cste = 12 + 27;;
cste : int = 39
   déclarer une constante pi
  #let pi   
  #let pi = 4. *. (atan 1.);;
pi : float = 3.14159265359
   déclarer une variable
  let mavariable = ref 65;;   
  # let mavariable = ref 65;;
mavariable : int ref = ref 65
   récupérer une variable
 !mavariable;;  
  # !mavariable;;
- : int = 65
   modifier une variable
 #var := 27;;
 #var := 27;;
- : unit = ()
  déclarer une fonction
 let mafonction = function x -> 
ou
let mafonction = fun x ->
ou
let mafonction x =
  let mafonction = function x -> x*x;;
ou
let mafonction = fun x -> 2*x+3;;
ou
let mafonction x = 2*x+3;;
 function
 déclare une fonction à 1 arguement 
  let mafonction = function x -> x*x;; 
 fun
 déclare une fonction à plusieurs arguement succèssifs (on dit qu'elle est curryfiée)
  #let f = fun (Compteur c) -> c + 1;;
f : compteur -> int =
  déclarer une fonction produit qui renvoie une chaine de caractère
 
 #let mafonctionproduit = function (x,y) -> string_of_float(x *. y)  
  utiliser une fonction
 mafonction(parametre1,parametre2);;
 mafonctionproduit(3.,5.);;  





 afficher du texte à l'écran 
print_
afficher  une donnée
 print_int 9;;
print_float 9.;;
print_char `a`;;
print_string "Hello World!";;
print_
afficher  un retour à la ligne
 print_newline();;
  
afficher plusieurs éléments en une ligne
 let affiche_prix prix =
print_string "cet objet coute ";
print_float prix;
print_string " dollards";
print_newline();;
affiche_prix(8.);;
sqrt
calcule la racine carré
  





 les conditions 
   description 
   ecriture    
   exemple    
   vérifie si les deux éléments testés on la même valeur 
   =    
   exemple    
vérifie si les deux éléments testés on une valeur différente 
   <>   
   exemple    
   vérifie si un élément est strictement inférieur à l'autre 
   <   
   exemple    
   vérifie si un élément est inférieur ou égal à l'autre 
   <=    
   exemple    
  vérifie si un élément est strictement supérieur à l'autre 
   >    
   exemple    
   vérifie si un élément est supérieur ou égal à l'autre 
   >=    
   exemple    
  écrire une fonction qui différencie le min 
   
 let min a b =
 if a<=b then a
   else b;;
  écrire plusieurs conditions
 begin et end   
 if condition then begin action1; action2; action3; end;
else begin action4; action5; end;;





 les conditions 
  si sinon
 
 (x) when [test logique] -> [donc] 
| [test logique] -> [instruction]
|_ [test logique] -> [instruction] (tout le reste)
  sinon
 permet de faire un si
 (x) when (x=0) -> 0  
  ::nom
 permet de récuperer le reste et de l'envoyer en recursivité
 x::nom -> x fonction(nom)  
  @
 permet de concaténer deux chaines
 let rec inverse = function
[]->[]
|x::rest -> inverse(rest)@[x];;
 (,)
 La virgule (,) est le délimiteur des produits cartésiens 
 #let a = (1,1.,true,"un",());;
a : int * float * bool * string * unit = 1, 1.0, true, "un", ()
 définition globale
 let < identificateur > = < expression > 
 let s = 1+2+3;; 
s : int = 6
 définition locales
 < definition>in < expression>
| <expression> where <definition>
 let s = 1+2+3;; 
s : int = 6





 l'installation 
Voici comment installer Caml Light sous GNU/Linux. Le plus long est de lire toute cette page. Mais en fait, en résumé, il suffit probablement de taper dans un terminal les commandes:

cd le-repertoire-qui-va-bien
git clone https://github.com/FBoisson/Camllight
cd Camllight/src
make configure
make world
sudo make install


Voici un peu plus de détails. Cette installation est décrite à partir des sources, c'est-à-dire que vous allez télécharger le code de Caml, le compiler pour le transformer en un logiciel exécutable et l'installer ensuite à un endroit où il pourra être utilisé par tous les utilisateurs de votre système. Vous aurez ensuite les sources sous la main et serez en mesure de les consulter si vous voulez regarder comment Caml est écrit. Chercher dans le gestionnaire de paquets logiciels les logiciels suivants et les installer : emacs (l'éditeur de texte) tuareg-mode (un mode emacs pour éditer du Caml) gcc (le compilateur C) make (outil pour lancer la construction d'un projet) git (un outil de contrôle de versions pour gérer les sources d'un logiciel) Lancer un terminal. Se déplacer au besoin dans le répertoire où vous compter installer les sources de Caml avec les commandes cd (change directory) qui permet de changer de répertoire, pwd (print working directory) qui affiche le répertoire courant et ls (list) qui affiche le contenu d'un répertoire. Puis : récupérer les sources de Caml Light avec la commande:
git clone https://github.com/FBoisson/Camllight
un répertoire Camllight doit avoir été créé (ls pour le vérifier). Descendre dans le sous-répertoire src de ce répertoire:
cd Camllight/src
lancer la phase de détection de la configuration:
make configure
Vous verrez que Caml affiche un certain nombre de résultats de tests (qui terminent avec «strerror() found.»). lancer la compilation:
make world
Le processus de compilation affiche un certain nombre de lignes et se termine par: #- : int = 3 #fib : int -> int = #- : int = 10946 #Is that 10946 on the line above? Good. The Caml Light system is up and running. il ne reste plus qu'à installer les programmes exécutables produits dans un répertoire où ils pourront être trouvés par le système. Pour cela, il convient de lancer la commande make install en tant que superutilisateur. Il y a deux méthodes existante. En général seule l'une des deux fonctionne. Celle à utiliser dépend de votre distribution. Si vous connaissez le mot de passe du superutilisateur (root) vous pouvez utiliser la première. Si vous êtes sous Ubuntu, vous utiliserez la seconde : Connectez-vous en tant que superutilisateur en tapant:
su
Le système vous demandera le mot de passe du superutilisateur (root). L'invite de votre terminal devrait ensuite passer de $ à #). Lancez alors:
make install
N'oubliez surtout pas de quitter le mode superutilisateur en tapant:
exit
Lancez la commande:
sudo make install
(le système vous demandera votre mot de passe et il faut que vous ayez le droit de lancer une commande en tant que superutilisateur) Testez que tout va bien : Dans un terminal, tapez
camllight
Vérifiez que vous pouvez calculer: 3+2;; Qui devrait vous répondre: - : int = 5 C'est signe que Caml Light est correctement installé. Quittez avec: quit();; Lancez emacs, créez un nouveau fichier essai.ml, vérifiez qu'emacs est bien passé en mode tuareg. Vérifiez que vous pouvez calculer 3+2;;. Happy coding!