====================
Les bases du langage
====================

.. contents::

Commentaires
------------

::

    (* Un commentaire (* Un commentaire imbriqué *) *)
    (*
    Je suis multiligne !
        (* Moi
        aussi *)
    *)

Déclaration de variables
------------------------

La déclaration en OCaml se fait grâce au mot-clé ``let``. ::

    # let x = 5;;
    val x : int = 5
    # let y = 3;;
    val y : int = 3
    # let z = x + y;;
    val z : int = 8

Les déclarations précédentes sont globales. On peut aussi faire des déclarations locales grâce à ``in``. ::

    # let a = 10 and b = 11;;
    val a : int = 10
    val b : int = 11
    # let (a, b) = (3, 4) in a * b;;
    - : int = 12
    # (a, b);;
    - : int * int = (10, 11)

On peut imbriquer les déclarations. ::

    # let c = let (a, b) = (3, 4) in a * b;;
    val c : int = 12

.. warning:: 

    Une déclaration locale ne peut englober une déclaration globale. ::

        # let u = 4 in let v = 2;;
        Characters 22-24:
        let u = 4 in let v = 2;;
                            ^^
        Error: Syntax error


Déclaration de fonctions
------------------------

On utilise le même mot-clé ``let``, avec en plus le mot-clé ``function``. Par exemple la fonction carré : ::

    # let f = function x -> x * x;;
    val f : int -> int = <fun>

On appelle cette fonction comme ceci : ::

    # f 3;;
    - : int = 9

On note qu'il n'y a pas de parenthèses. Les fonctions récursives sont marquées avec le mot-clé ``rec``. ::

    # let rec fac n =
        if n = 0 then 1
        else n * fact (n-1);;
    val fact : int -> int = <fun>
    # fact 3;;
    - : int = 6

Types natifs
------------

En plus des entiers qui ont été utilisés jusqu'ici, il existe de nombreux types natifs en OCaml

+------------+-----------------------------------------------------------------------+
| Type       | Définition                                                            |
+============+=======================================================================+
| ``int``    | Entier relatif de 31 bits (+/- 1 milliard) pour un processeur 32-bits |
+------------+-----------------------------------------------------------------------+
| ``float``  | Nombre à virgule (équivalent de ``double`` en C                       |
+------------+-----------------------------------------------------------------------+
| ``bool``   | Booléen, noté ``true`` ou ``false``                                   |
+------------+-----------------------------------------------------------------------+
| ``char``   | Un charactère à 8 bits                                                |
+------------+-----------------------------------------------------------------------+
| ``string`` | Une chaîne de caractères à 8 bits                                     |
+------------+-----------------------------------------------------------------------+
| ``unit``   | Valeur unique notée ``()``                                            |
+------------+-----------------------------------------------------------------------+

Le typage n'est pas dynamique, on ne peut pas évaluer par exemple ``1 + 0.5``, chaque type possède ses propres opérateurs. Pour le cas précédent, il faut explicitement convertir ``1`` en flottant ou bien arrondir/tronquer ``0.5`` pour en faire un entier.

Opérations sur les entiers et flottants
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

::

    # 1 + 1;;
    - : int = 2
    # 2 * 3;;
    - : int = 6
    # 4 - 5;;
    - : int = -1
    # (/) 10 2;; (* opérateur utilisé comme une fonction *)
    - : int = 5
    # 10 mod 3;; (* reste de la division euclidienne *)
    - : int = 1

Pour les flottants, les opérateurs sont les mêmes préfixé d'un ``.``. ``mod`` devient ``mod_float``. 

::

    # 1.5 +. 1.5;;
    - : float = 3
    # 2.5 *. 3.;; (* 3. est un flottant, 3 est un entier *)
    - : float = 7.5
    # mod_float 7. 3.5;; (* on est obligés d'utiliser mod_float comme ceci *)
    - : float = 0

D'autres trucs sympas : ::

    # max_int;;
    - : int = 4611686018427387903
    # min_int;;
    - : int = -4611686018427387904
    # max_float;;
    - : float = 1.79769313486231571e+308
    # 1 / 0;;
    Exception: Division_by_zero
    # 1. /. 0.;;
    - : float = infinity


Chaînes de caractères
~~~~~~~~~~~~~~~~~~~~~

Les chaines de caractères sont immuables.

::

    # 'a';;
    - : char = 'a'
    # "a";;
    - : string = "a"
    # {|a|} (* Chaine qui permet de ne pas à voir à échapper \ et " *)
    - : string = "a"
    # {|\"]} = "\\\"";;
    - : bool = true
    # {delimiter|the end of this|}quoted string is here|delimiter}
    = "the end of this|}quoted string is here";; (* On peut personnaliser le délimiteur *)
    - : bool = true
    # let a = "Hello" and b = "World" in a ^ " " ^ b;; (* Concaténation *)
    - : string = "Hello World"