https://lea-linux.org/docs/api.php?action=feedcontributions&feedformat=atom&user=BasilesLea Linux - Contributions [fr]2026-04-04T11:40:50ZContributionsMediaWiki 1.40.1https://lea-linux.org/docs/index.php?title=OCaml&diff=11886OCaml2006-02-19T20:07:34Z<p>Basiles : </p>
<hr />
<div>{{ En Construction }}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
<code>(* hello world en Ocaml *)<br />
print_string "hello world\n";;</code><br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<code>% <i>ocaml</i><br />
Objective Caml version 3.09.1<br />
<br />
# 2 + 3;;<br />
- : int = 5</code><br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5''). L'inférence de types prend tout son intérêt sur des programmes non triviaux (plus d'une centaine de lignes) dont elle permet la concision (en évitant la plupart des déclarations de type, comme on le fait en C, C++, Java...).<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
<code># #use "hello.ml";;<br />
hello world<br />
- : unit = ()<br />
</code><br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur (la seule du type unit) est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
<code># print_string;;<br />
- : string -> unit = < fun ></code><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
On peut définir des valeurs par le mot-clé '''let'''. Par exemple<br />
<code># let dix = 5*2;;<br />
val dix : int = 10</code><br />
définit une valeur nommée dix de type int valant 10<br />
<br />
On peut définir des valeurs fonctionnelles (c'est à dire des fonctions) par exemple<br />
<code># let double x = 2*x;;<br />
val double : int -> int = &lt;fun&gt; </code><br />
Le compilateur a inféré le type de la fonction double: son argument x est nécessairement entier, car il est multiplié par 2 et que la multiplication est une opération sur les entiers; son résultat est entier, car c'est le résultat produit par la multiplication. Une fois compilé par ocamlopt, la fonction ci-dessus est aussi efficace que celle écrite en C!<br />
<br />
On peut définir des fonctions récursives par la construction '''let rec''' - voici l'inévitable factorielle et le calcul de 10!<br />
<br />
<code># <i>let rec fact n = if n < 1 then 1 else n * fact (n-1);;</i><br />
val fact : int -> int = < fun ><br />
# ''fact 10;;''<br />
- : int = 3628800</code><br />
<br />
Voici l'une des plus simples des recursivités croisées (le mot-clé and lie plusieurs définitions) - les fonctions paire et impaire<br />
<code># <i>let rec paire n = if n = 0 then true else impaire (n-1) <br />
and impaire n = if n = 0 then false else paire (n-1) ;;</i><br />
val paire : int -> bool = &lt;fun&gt;<br />
val impaire : int -> bool = &lt;fun&gt; </code><br />
le compilateur tient compte du fait que ces recursions sont terminales; l'appel recursif à impaire dans la définition de pair (et réciproquement) est la dernière application de fonction, et il est interprété itérativement (sans grossir la pile des appels). On peut donc calculer <br />
<code># <i>paire 123456789;;</i><br />
- : bool = false</code><br />
le résultat est calculé en quelques secondes, la machine a bouclé plus d'un milliard de fois. Les compilateurs classiques (par exemple C, C++, Java) aurait fait exploser la pile d'appel.<br />
<br />
En fait on peut réécrire la factorielle de manière récursive terminale en définissant une fonction interne à 2 arguments: le résultat partiel (produit précédemment calculé p) et l'argument n<br />
<br />
<code>#'<i>let fact n =<br />
let rec interne_fact p n = if n < 1 then p else interne_fact (p*n) (n-1)<br />
in interne_fact 1 n;;</i><br />
val fact : int -> int = &lt;fun&gt;</code><br />
<br />
On peut dans une expression définir des noms '''internes''' par la construction let .''..définitions internes...'' in ''....corps.....'' (ou let rec ... in .... pour une recursion).<br />
<br />
la factorielle ainsi redefinie est compilée en du code identique à la fonction C<br />
''int factc(int n) { int p=1; while(n>1) p=p*(n--);return p; }''<br />
<br />
La plupart des boucles s'écrivent en fait par une telle récursion terminale interne. Il faut noter que les variables dans tous les exemples ci-dessus sont des paramètres qui ne changent pas: on a rarement besoin d'affectation en Ocaml.<br />
<br />
En fait on peut aussi coder de manière '''impérative''', avec des variables qui varient (comme en C ou Java), qu'on appelle référence:<br />
<code># <i>let fact n = let p = ref 1 and c = ref 1 in<br />
'' while !c <= n do p := !p * !c ; incr c done; !p;; </i></code><br />
l'affectation à une référence se note := et la déréference est explicitée par un point d'exclamation. La fonction incr incrémente une réference vers un entier<br />
<br />
(((à suivre)))<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11885OCaml2006-02-19T20:04:19Z<p>Basiles : </p>
<hr />
<div>{{ En Construction }}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
<code><i>(* hello world en Ocaml *)</i><br />
print_string "hello world\n";;</code><br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<code>% <i>ocaml</i><br />
Objective Caml version 3.09.1<br />
<br />
# 2 + 3;;<br />
- : int = 5</code><br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5''). L'inférence de types prend tout son intérêt sur des programmes non triviaux (plus d'une centaine de lignes) dont elle permet la concision (en évitant la plupart des déclarations de type, comme on le fait en C, C++, Java...).<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
<code># #use "hello.ml";;<br />
hello world<br />
- : unit = ()<br />
</code><br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur (la seule du type unit) est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
<code># print_string;;<br />
- : string -> unit = < fun ></code><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
On peut définir des valeurs par le mot-clé '''let'''. Par exemple<br />
<code># let dix = 5*2;;<br />
val dix : int = 10</code><br />
définit une valeur nommée dix de type int valant 10<br />
<br />
On peut définir des valeurs fonctionnelles (c'est à dire des fonctions) par exemple<br />
<code># let double x = 2*x;;<br />
val double : int -> int = &lt;fun&gt; </code><br />
Le compilateur a inféré le type de la fonction double: son argument x est nécessairement entier, car il est multiplié par 2 et que la multiplication est une opération sur les entiers; son résultat est entier, car c'est le résultat produit par la multiplication. Une fois compilé par ocamlopt, la fonction ci-dessus est aussi efficace que celle écrite en C!<br />
<br />
On peut définir des fonctions récursives par la construction '''let rec''' - voici l'inévitable factorielle et le calcul de 10!<br />
<br />
<code># <i>let rec fact n = if n < 1 then 1 else n * fact (n-1);;</i><br />
val fact : int -> int = < fun ><br />
# ''fact 10;;''<br />
- : int = 3628800</code><br />
<br />
Voici l'une des plus simples des recursivités croisées (le mot-clé and lie plusieurs définitions) - les fonctions paire et impaire<br />
<code># <i>let rec paire n = if n = 0 then true else impaire (n-1) <br />
and impaire n = if n = 0 then false else paire (n-1) ;;</i><br />
val paire : int -> bool = &lt;fun&gt;<br />
val impaire : int -> bool = &lt;fun&gt; </code><br />
le compilateur tient compte du fait que ces recursions sont terminales; l'appel recursif à impaire dans la définition de pair (et réciproquement) est la dernière application de fonction, et il est interprété itérativement (sans grossir la pile des appels). On peut donc calculer <br />
<code># <i>paire 123456789;;</i><br />
- : bool = false</code><br />
le résultat est calculé en quelques secondes, la machine a bouclé plus d'un milliard de fois. Les compilateurs classiques (par exemple C, C++, Java) aurait fait exploser la pile d'appel.<br />
<br />
En fait on peut réécrire la factorielle de manière récursive terminale en définissant une fonction interne à 2 arguments: le résultat partiel (produit précédemment calculé p) et l'argument n<br />
<br />
<code>#'<i>let fact n =<br />
let rec interne_fact p n = if n < 1 then p else interne_fact (p*n) (n-1)<br />
in interne_fact 1 n;;</i><br />
val fact : int -> int = &lt;fun&gt;</code><br />
<br />
On peut dans une expression définir des noms '''internes''' par la construction let .''..définitions internes...'' in ''....corps.....'' (ou let rec ... in .... pour une recursion).<br />
<br />
la factorielle ainsi redefinie est compilée en du code identique à la fonction C<br />
''int factc(int n) { int p=1; while(n>1) p=p*(n--);return p; }''<br />
<br />
La plupart des boucles s'écrivent en fait par une telle récursion terminale interne. Il faut noter que les variables dans tous les exemples ci-dessus sont des paramètres qui ne changent pas: on a rarement besoin d'affectation en Ocaml.<br />
<br />
En fait on peut aussi coder de manière '''impérative''', avec des variables qui varient (comme en C ou Java), qu'on appelle référence:<br />
<code># <i>let fact n = let p = ref 1 and c = ref 1 in<br />
'' while !c <= n do p := !p * !c ; incr c done; !p;; </i></code><br />
l'affectation à une référence se note := et la déréference est explicitée par un point d'exclamation. La fonction incr incrémente une réference vers un entier<br />
<br />
(((à suivre)))<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11884OCaml2006-02-19T19:59:40Z<p>Basiles : /* quelques exemples de code Ocaml */</p>
<hr />
<div>{{ En Construction }}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
<code>'(* hello world en Ocaml *)'<br />
print_string "hello world\n";;</code><br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<code>% <i>ocaml</i><br />
Objective Caml version 3.09.1<br />
<br />
# 2 + 3;;<br />
- : int = 5</code><br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5''). L'inférence de types prend tout son intérêt sur des programmes non triviaux (plus d'une centaine de lignes) dont elle permet la concision (en évitant la plupart des déclarations de type, comme on le fait en C, C++, Java...).<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
<code># #use "hello.ml";;<br />
hello world<br />
- : unit = ()<br />
</code><br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur (la seule du type unit) est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
<code># print_string;;<br />
- : string -> unit = < fun ></code><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
On peut définir des valeurs par le mot-clé '''let'''. Par exemple<br />
<code># let dix = 5*2;;<br />
val dix : int = 10</code><br />
définit une valeur nommée dix de type int valant 10<br />
<br />
On peut définir des valeurs fonctionnelles (c'est à dire des fonctions) par exemple<br />
<code># let double x = 2*x;;<br />
val double : int -> int = < fun ></code><br />
Le compilateur a inféré le type de la fonction double: son argument x est nécessairement entier, car il est multiplié par 2 et que la multiplication est une opération sur les entiers; son résultat est entier, car c'est le résultat produit par la multiplication. Une fois compilé par ocamlopt, la fonction ci-dessus est aussi efficace que celle écrite en C!<br />
<br />
On peut définir des fonctions récursives par la construction '''let rec''' - voici l'inévitable factorielle et le calcul de 10!<br />
<br />
<code># ''let rec fact n = if n < 1 then 1 else n * fact (n-1);;''<br />
val fact : int -> int = < fun ><br />
# ''fact 10;;''<br />
- : int = 3628800</code><br />
<br />
Voici l'une des plus simples des recursivités croisées (le mot-clé and lie plusieurs définitions) - les fonctions paire et impaire<br />
<code># ''let rec paire n = if n = 0 then true else impaire (n-1) '' <br />
''and impaire n = if n = 0 then false else paire (n-1) ;;''<br />
val paire : int -> bool = < fun ><br />
val impaire : int -> bool = < fun ></code><br />
le compilateur tient compte du fait que ces recursions sont terminales; l'appel recursif à impaire dans la définition de pair (et réciproquement) est la dernière application de fonction, et il est interprété itérativement (sans grossir la pile des appels). On peut donc calculer <br />
<code># ''paire 123456789;;''<br />
- : bool = false</code><br />
le résultat est calculé en quelques secondes, la machine a bouclé plus d'un milliard de fois. Les compilateurs classiques (par exemple C, C++, Java) aurait fait exploser la pile d'appel.<br />
<br />
En fait on peut réécrire la factorielle de manière récursive terminale en définissant une fonction interne à 2 arguments: le résultat partiel (produit précédemment calculé p) et l'argument n<br />
<br />
<code>#'' let fact n = ''<br />
''let rec interne_fact p n = if n < 1 then p else interne_fact (p*n) (n-1)''<br />
''in interne_fact 1 n;;''<br />
val fact : int -> int = < fun ></code><br />
<br />
On peut dans une expression définir des noms '''internes''' par la construction let .''..définitions internes...'' in ''....corps.....'' (ou let rec ... in .... pour une recursion).<br />
<br />
la factorielle ainsi redefinie est compilée en du code identique à la fonction C<br />
''int factc(int n) { int p=1; while(n>1) p=p*(n--);return p; }''<br />
<br />
La plupart des boucles s'écrivent en fait par une telle récursion terminale interne. Il faut noter que les variables dans tous les exemples ci-dessus sont des paramètres qui ne changent pas: on a rarement besoin d'affectation en Ocaml.<br />
<br />
En fait on peut aussi coder de manière '''impérative''', avec des variables qui varient (comme en C ou Java), qu'on appelle référence:<br />
<code># ''let fact n = let p = ref 1 and c = ref 1 in''<br />
'' while !c <= n do p := !p * !c ; incr c done; !p;; ''</code><br />
l'affectation à une référence se note := et la déréference est explicitée par un point d'exclamation. La fonction incr incrémente une réference vers un entier<br />
<br />
(((à suivre)))<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11870OCaml2006-02-19T08:56:54Z<p>Basiles : ajout d'exemples (incomplet)</p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<br />
% ''ocaml''<br />
Objective Caml version 3.09.1<br />
<br />
# ''2 + 3;;''<br />
- : int = 5<br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5''). L'inférence de types prend tout son intérêt sur des programmes non triviaux (plus d'une centaine de lignes) dont elle permet la concision (en évitant la plupart des déclarations de type, comme on le fait en C, C++, Java...).<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
# ''#use "hello.ml";;''<br />
hello world<br />
- : unit = ()<br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur (la seule du type unit) est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
# ''print_string;;''<br />
- : string -> unit = < fun ><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
On peut définir des valeurs par le mot-clé '''let'''. Par exemple<br />
# ''let dix = 5*2;;''<br />
val dix : int = 10<br />
définit une valeur nommée dix de type int valant 10<br />
<br />
On peut définir des valeurs fonctionnelles (c'est à dire des fonctions) par exemple<br />
# ''let double x = 2*x;;''<br />
val double : int -> int = < fun ><br />
Le compilateur a inféré le type de la fonction double: son argument x est nécessairement entier, car il est multiplié par 2 et que la multiplication est une opération sur les entiers; son résultat est entier, car c'est le résultat produit par la multiplication. Une fois compilé par ocamlopt, la fonction ci-dessus est aussi efficace que celle écrite en C!<br />
<br />
On peut définir des fonctions récursives par la construction '''let rec''' - voici l'inévitable factorielle et le calcul de 10!<br />
<br />
# ''let rec fact n = if n < 1 then 1 else n * fact (n-1);;''<br />
val fact : int -> int = < fun ><br />
# ''fact 10;;''<br />
- : int = 3628800<br />
<br />
Voici l'une des plus simples des recursivités croisées (le mot-clé and lie plusieurs définitions) - les fonctions paire et impaire<br />
<br />
# ''let rec paire n = if n = 0 then true else impaire (n-1) '' <br />
''and impaire n = if n = 0 then false else paire (n-1) ;;''<br />
val paire : int -> bool = < fun ><br />
val impaire : int -> bool = < fun ><br />
<br />
le compilateur tient compte du fait que ces recursions sont terminales; l'appel recursif à impaire dans la définition de pair (et réciproquement) est la dernière application de fonction, et il est interprété itérativement (sans grossir la pile des appels). On peut donc calculer <br />
# ''paire 123456789;;''<br />
- : bool = false<br />
le résultat est calculé en quelques secondes, la machine a bouclé plus d'un milliard de fois. Les compilateurs classiques (par exemple C, C++, Java) aurait fait exploser la pile d'appel.<br />
<br />
En fait on peut réécrire la factorielle de manière récursive terminale en définissant une fonction interne à 2 arguments: le résultat partiel (produit précédemment calculé p) et l'argument n<br />
<br />
#'' let fact n = ''<br />
''let rec interne_fact p n = if n < 1 then p else interne_fact (p*n) (n-1)''<br />
''in interne_fact 1 n;;''<br />
val fact : int -> int = < fun ><br />
<br />
On peut dans une expression définir des noms '''internes''' par la construction let .''..définitions internes...'' in ''....corps.....'' (ou let rec ... in .... pour une recursion).<br />
<br />
la factorielle ainsi redefinie est compilée en du code identique à la fonction C<br />
''int factc(int n) { int p=1; while(n>1) p=p*(n--);return p; }''<br />
<br />
La plupart des boucles s'écrivent en fait par une telle récursion terminale interne. Il faut noter que les variables dans tous les exemples ci-dessus sont des paramètres qui ne changent pas: on a rarement besoin d'affectation en Ocaml.<br />
<br />
En fait on peut aussi coder de manière '''impérative''', avec des variables qui varient (comme en C ou Java), qu'on appelle référence:<br />
# ''let fact n = let p = ref 1 and c = ref 1 in''<br />
'' while !c <= n do p := !p * !c ; incr c done; !p;; ''<br />
l'affectation à une référence se note := et la déréference est explicitée par un point d'exclamation. La fonction incr incrémente une réference vers un entier<br />
<br />
<br />
(((à suivre)))<br />
<br />
<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11867OCaml2006-02-18T21:59:10Z<p>Basiles : </p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<br />
% ''ocaml''<br />
Objective Caml version 3.09.1<br />
<br />
# ''2 + 3;;''<br />
- : int = 5<br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5''). L'inférence de types prend tout son intérêt sur des programmes non triviaux (plus d'une centaine de lignes) dont elle permet la concision (en évitant la plupart des déclarations de type, comme on le fait en C, C++, Java...).<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
# ''#use "hello.ml";;''<br />
hello world<br />
- : unit = ()<br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur (la seule du type unit) est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
# ''print_string;;''<br />
- : string -> unit = < fun ><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
On peut définir des valeurs par le mot-clé '''let'''. Par exemple<br />
# ''let dix = 5*2;;''<br />
val dix : int = 10<br />
définit une valeur nommée dix de type int valant 10<br />
<br />
On peut définir des valeurs fonctionnelles (c'est à dire des fonctions) par exemple<br />
# ''let double x = 2*x;;''<br />
val double : int -> int = < fun ><br />
Le compilateur a inféré le type de la fonction double: son argument x est nécessairement entier, car il est multiplié par 2 et que la multiplication est une opération sur les entiers; son résultat est entier, car c'est le résultat produit par la multiplication. Une fois compilé par ocamlopt, la fonction ci-dessus est aussi efficace que celle écrite en C!<br />
<br />
On peut définir des fonctions récursives par la construction '''let rec''' - voici l'inévitable factorielle et le calcul de 10!<br />
<br />
# ''let rec fact n = if n < 1 then 1 else n * fact (n-1);;''<br />
val fact : int -> int = < fun ><br />
# ''fact 10;;''<br />
- : int = 3628800<br />
<br />
Voici l'une des plus simples des recursivités croisées (le mot-clé and lie plusieurs définitions) - les fonctions paire et impaire<br />
<br />
# ''let rec paire n = if n = 0 then true else impaire (n-1) '' <br />
''and impaire n = if n = 0 then false else paire (n-1) ;;''<br />
val paire : int -> bool = < fun ><br />
val impaire : int -> bool = < fun ><br />
<br />
le compilateur tient compte du fait que ces recursions sont terminales; l'appel recursif à impaire dans la définition de pair (et réciproquement) est la dernière application de fonction, et il est interprété itérativement (sans grossir la pile des appels). On peut donc calculer <br />
# ''paire 123456789;;''<br />
- : bool = false<br />
le résultat est calculé en quelques secondes, la machine a bouclé plus d'un milliard de fois. Les compilateurs classiques (par exemple C, C++, Java) aurait fait exploser la pile d'appel.<br />
<br />
En fait on peut réécrire la factorielle de manière récursive terminale en définissant une fonction interne à 2 arguments: le résultat partiel (produit précédemment calculé p) et l'argument n<br />
<br />
#'' let fact n = ''<br />
''let rec interne_fact p n = if n < 1 then p else interne_fact (p*n) (n-1)''<br />
''in interne_fact 1 n;;''<br />
val fact : int -> int = < fun ><br />
<br />
On peut dans une expression définir des noms '''internes''' par la construction let .''..définitions internes...'' in ''....corps.....'' (ou let rec ... in .... pour une recursion).<br />
<br />
la factorielle ainsi redefinie est compilée en du code identique à la fonction C<br />
''int factc(int n) { int p=1; while(n>1) p=p*(n--);return p; }''<br />
<br />
La plupart des boucles s'écrivent en fait par une telle récursion terminale interne. Il faut noter que les variables dans tous les exemples ci-dessus sont des paramètres qui ne changent pas: on a rarement besoin d'affectation en Ocaml.<br />
<br />
<br />
(((à suivre)))<br />
<br />
<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11866OCaml2006-02-18T21:53:53Z<p>Basiles : </p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<br />
% ''ocaml''<br />
Objective Caml version 3.09.1<br />
<br />
# ''2 + 3;;''<br />
- : int = 5<br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5'').<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
# ''#use "hello.ml";;''<br />
hello world<br />
- : unit = ()<br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur (la seule du type unit) est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
# ''print_string;;''<br />
- : string -> unit = < fun ><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
On peut définir des valeurs par le mot-clé '''let'''. Par exemple<br />
# ''let dix = 5*2;;''<br />
val dix : int = 10<br />
définit une valeur nommée dix de type int valant 10<br />
<br />
On peut définir des valeurs fonctionnelles (c'est à dire des fonctions) par exemple<br />
# ''let double x = 2*x;;''<br />
val double : int -> int = < fun ><br />
Le compilateur a inféré le type de la fonction double: son argument x est nécessairement entier, car il est multiplié par 2 et que la multiplication est une opération sur les entiers; son résultat est entier, car c'est le résultat produit par la multiplication. Une fois compilé par ocamlopt, la fonction ci-dessus est aussi efficace que celle écrite en C!<br />
<br />
On peut définir des fonctions récursives par la construction '''let rec''' - voici l'inévitable factorielle et le calcul de 10!<br />
<br />
# ''let rec fact n = if n < 1 then 1 else n * fact (n-1);;''<br />
val fact : int -> int = < fun ><br />
# ''fact 10;;''<br />
- : int = 3628800<br />
<br />
Voici l'une des plus simples des recursivités croisées (le mot-clé and lie plusieurs définitions) - les fonctions paire et impaire<br />
<br />
# ''let rec paire n = if n = 0 then true else impaire (n-1) '' <br />
''and impaire n = if n = 0 then false else paire (n-1) ;;''<br />
val paire : int -> bool = < fun ><br />
val impaire : int -> bool = < fun ><br />
<br />
le compilateur tient compte du fait que ces recursions sont terminales; l'appel recursif à impaire dans la définition de pair (et réciproquement) est la dernière application de fonction, et il est interprété itérativement (sans grossir la pile des appels). On peut donc calculer <br />
# ''paire 123456789;;''<br />
- : bool = false<br />
le résultat est calculé en quelques secondes, la machine a bouclé plus d'un milliard de fois. Les compilateurs classiques (par exemple C, C++, Java) aurait fait exploser la pile d'appel.<br />
<br />
En fait on peut réécrire la factorielle de manière récursive terminale en définissant une fonction interne à 2 arguments: le résultat partiel (produit précédemment calculé p) et l'argument n<br />
<br />
#'' let fact n = ''<br />
''let rec interne_fact p n = if n < 1 then p else interne_fact (p*n) (n-1)''<br />
''in interne_fact 1 n;;''<br />
val fact : int -> int = < fun ><br />
<br />
On peut dans une expression définir des noms '''internes''' par la construction let .''..définitions internes...'' in ''....corps.....'' (ou let rec ... in .... pour une recursion).<br />
<br />
la factorielle ainsi redefinie est compilée en du code identique à la fonction C<br />
''int factc(int n) { int p=1; while(n>1) p=p*(n--);return p; }''<br />
<br />
La plupart des boucles s'écrivent en fait par une telle récursion terminale interne. Il faut noter que les variables dans tous les exemples ci-dessus sont des paramètres qui ne changent pas: on a rarement besoin d'affectation en Ocaml.<br />
<br />
<br />
(((à suivre)))<br />
<br />
<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11865OCaml2006-02-18T21:49:38Z<p>Basiles : </p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<br />
% ''ocaml''<br />
Objective Caml version 3.09.1<br />
<br />
# ''2 + 3;;''<br />
- : int = 5<br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5'').<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
# ''#use "hello.ml";;''<br />
hello world<br />
- : unit = ()<br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur (la seule du type unit) est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
# ''print_string;;''<br />
- : string -> unit = < fun ><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
On peut définir des valeurs par le mot-clé '''let'''. Par exemple<br />
# ''let dix = 5*2;;''<br />
val dix : int = 10<br />
définit une valeur nommée dix de type int valant 10<br />
<br />
On peut définir des valeurs fonctionnelles (c'est à dire des fonctions) par exemple<br />
# ''let double x = 2*x;;''<br />
val double : int -> int = < fun ><br />
Le compilateur a inféré le type de la fonction double: son argument x est nécessairement entier, car il est multiplié par 2 et que la multiplication est une opération sur les entiers; son résultat est entier, car c'est le résultat produit par la multiplication. Une fois compilé par ocamlopt, la fonction ci-dessus est aussi efficace que celle écrite en C!<br />
<br />
On peut définir des fonctions récursives par la construction '''let rec''' - voici l'inévitable factorielle et le calcul de 10!<br />
<br />
# let rec fact n = if n < 1 then 1 else n * fact (n-1);;<br />
val fact : int -> int = < fun ><br />
# ''fact 10;;''<br />
- : int = 3628800<br />
<br />
Voici l'une des plus simples des recursivités croisées (le mot-clé and lie plusieurs définitions) - les fonctions paire et impaire<br />
<br />
# ''let rec paire n = if n = 0 then true else impaire (n-1) <br />
and impaire n = if n = 0 then false else paire (n-1) ;;''<br />
val paire : int -> bool = < fun ><br />
val impaire : int -> bool = < fun ><br />
<br />
le compilateur tient compte du fait que ces recursions sont terminales; l'appel recursif à impaire dans la définition de pair (et réciproquement) est la dernière application de fonction, et il est interprété itérativement (sans grossir la pile des appels). On peut donc calculer <br />
# ''paire 123456789;;''<br />
- : bool = false<br />
le résultat est calculé en quelques secondes, la machine a bouclé plus d'un milliard de fois. Les compilateurs classiques (par exemple C, C++, Java) aurait fait exploser la pile d'appel.<br />
<br />
En fait on peut réécrire la factorielle de manière récursive terminale en définissant une fonction interne à 2 arguments: le résultat partiel (produit précédemment calculé p) et l'argument n<br />
<br />
#'' let fact n = <br />
let rec interne_fact p n = if n < 1 then p else interne_fact (p*n) (n-1)<br />
in interne_fact 1 n;;''<br />
val fact : int -> int = < fun ><br />
<br />
On peut dans une expression définir des noms '''internes''' par la construction let .''..définitions internes...'' in ''....corps.....'' (ou let rec ... in .... pour une recursion).<br />
<br />
la factorielle ainsi redefinie est compilée en du code identique à la fonction C<br />
int factc(int n) { int p=1; while(n>1) p=p*(n--);return p; }<br />
<br />
La plupart des boucles s'écrivent en fait par une telle recursion terminale interne.<br />
<br />
<br />
(((à suivre)))<br />
<br />
<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11864OCaml2006-02-18T21:32:48Z<p>Basiles : </p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<br />
% ''ocaml''<br />
Objective Caml version 3.09.1<br />
<br />
# ''2 + 3;;''<br />
- : int = 5<br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5'').<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
# ''#use "hello.ml";;''<br />
hello world<br />
- : unit = ()<br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur (la seule du type unit) est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
# ''print_string;;''<br />
- : string -> unit = < fun ><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
On peut définir des valeurs par le mot-clé '''let'''. Par exemple<br />
# ''let dix = 5*2;;''<br />
val dix : int = 10<br />
définit une valeur nommée dix de type int valant 10<br />
<br />
On peut définir des valeurs fonctionnelles (c'est à dire des fonctions) par exemple<br />
# ''let double x = 2*x;;''<br />
val double : int -> int = < fun ><br />
Le compilateur a inféré le type de la fonction double: son argument x est nécessairement entier, car il est multiplié par 2 et que la multiplication est une opération sur les entiers; son résultat est entier, car c'est le résultat produit par la multiplication. Une fois compilé par ocamlopt, la fonction ci-dessus est aussi efficace que celle écrite en C!<br />
<br />
On peut définir des fonctions récursives par la construction '''let rec''' - voici l'inévitable factorielle et le calcul de 10!<br />
<br />
# let rec fact n = if n < 1 then 1 else n * fact (n-1);;<br />
val fact : int -> int = < fun ><br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11863OCaml2006-02-18T21:25:56Z<p>Basiles : </p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<br />
% ''ocaml''<br />
Objective Caml version 3.09.1<br />
<br />
# ''2 + 3;;''<br />
- : int = 5<br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5'').<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
# ''#use "hello.ml";;''<br />
hello world<br />
- : unit = ()<br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur (la seule du type unit) est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
# ''print_string;;''<br />
- : string -> unit = < fun ><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
On peut définir des valeurs par le mot-clé '''let'''. Par exemple<br />
# ''let dix = 5*2;;''<br />
val dix : int = 10<br />
définit une valeur nommée dix de type int valant 10<br />
<br />
On peut définir des valeurs fonctionnelles (c'est à dire des fonctions) par exemple<br />
# ''let double x = 2*x;;''<br />
val double : int -> int = < fun ><br />
Le compilateur a inféré le type de la fonction double: son argument x est nécessairement entier, car il est multiplié par 2 et que la multiplication est une opération sur les entiers; son résultat est entier, car c'est le résultat produit par la multiplication. Une fois compilé par ocamlopt, la fonction ci-dessus est aussi efficace que celle écrite en C!<br />
<br />
On peut définir des fonctions récursives par la construction '''let rec'''<br />
<br />
# let rec fact n = if n < 1 then 1 else n * fact (n-1);;<br />
val fact : int -> int = < fun ><br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11862OCaml2006-02-18T21:24:53Z<p>Basiles : </p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<br />
% ''ocaml''<br />
Objective Caml version 3.09.1<br />
<br />
# ''2 + 3;;''<br />
- : int = 5<br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5'').<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
# ''#use "hello.ml";;''<br />
hello world<br />
- : unit = ()<br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur (la seule du type unit) est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
# ''print_string;;''<br />
- : string -> unit = < fun ><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
On peut définir des valeurs par le mot-clé '''let'''. Par exemple<br />
# ''let dix = 5*2;;''<br />
val dix : int = 10<br />
définit une valeur nommée dix de type int valant 10<br />
<br />
On peut définir des valeurs fonctionnelles (c'est à dire des fonctions) par exemple<br />
# ''let double x = 2*x;;''<br />
val double : int -> int = < fun ><br />
Le compilateur a inféré le type de la fonction double: son argument x est nécessairement entier, car il est multiplié par 2 et que la multiplication est une opération sur les entiers; son résultat est entier, car c'est le résultat produit par la multiplication. Une fois compilé par ocamlopt, la fonction ci-dessus est aussi efficace que celle écrite en C!<br />
<br />
On peut définir des fonctions récursives par la construction '''let rec'''<br />
<br />
# let rec fact n = if n < 1 then 1 else n * fact (n-1);;<br />
val fact : int -> int = < fun ><br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11861OCaml2006-02-18T21:19:30Z<p>Basiles : </p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<br />
% ''ocaml''<br />
Objective Caml version 3.09.1<br />
<br />
# ''2 + 3;;''<br />
- : int = 5<br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5'').<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
# ''#use "hello.ml";;''<br />
hello world<br />
- : unit = ()<br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur (la seule du type unit) est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
# ''print_string;;''<br />
- : string -> unit = < fun ><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
On peut définir des valeurs par le mot-clé let. Par exemple<br />
# ''let dix = 5*2;;''<br />
val dix : int = 10<br />
définit une valeur nommée dix de type int valant 10<br />
<br />
On peut définir des valeurs fonctionnelles (c'est à dire des fonctions) par exemple<br />
# ''let double x = 2*x;;''<br />
val double : int -> int = < fun ><br />
Le compilateur a inféré le type de la fonction double: son argument x est nécessairement entier, car il est multiplié par 2 et que la multiplication est une opération sur les entiers; sont résultat est entier, car c'est le resultat produit par la multiplication. Une fois compilé par ocamlopt, la fonction ci-dessus est aussi efficace que celle écrite en C!<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11860OCaml2006-02-18T21:18:25Z<p>Basiles : </p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<br />
% ''ocaml''<br />
Objective Caml version 3.09.1<br />
<br />
# ''2 + 3;;''<br />
- : int = 5<br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5'').<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
# ''#use "hello.ml";;''<br />
hello world<br />
- : unit = ()<br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur (la seule du type unit) est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
# ''print_string;;''<br />
- : string -> unit = <fun><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
On peut définir des valeurs par le mot-clé let. Par exemple<br />
# ''let dix = 5*2;;''<br />
val dix : int = 10<br />
définit une valeur nommée dix de type int valant 10<br />
<br />
On peut définir des valeurs fonctionnelles (c'est à dire des fonctions) par exemple<br />
# ''let double x = 2*x;;''<br />
val double : int -> int = <fun><br />
Le compilateur a inféré le type de la fonction double: son argument x est nécessairement entier, car il est multiplié par 2 et que la multiplication est une opération sur les entiers; sont résultat est entier, car c'est le resultat produit par la multiplication. Une fois compilé par ocamlopt, la fonction ci-dessus est aussi efficace que celle écrite en C!<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11859OCaml2006-02-18T21:13:15Z<p>Basiles : </p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<br />
% ''ocaml''<br />
Objective Caml version 3.09.1<br />
<br />
# ''2 + 3;;''<br />
- : int = 5<br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5'').<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
# ''#use "hello.ml";;''<br />
hello world<br />
- : unit = ()<br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur (la seule du type unit) est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
# ''print_string;;''<br />
- : string -> unit = <fun><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
On peut définir des valeurs par le mot-clé let. Par exemple<br />
# ''let dix = 5*2;;''<br />
val dix : int = 10<br />
définit une valeur nommée dix de type int valant 10<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11858OCaml2006-02-18T21:08:24Z<p>Basiles : </p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant); l'interprète interactif compile chaque phrase tapée en du code octet, puis l'execute. Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués. Ce fichier peut-être édité (par exemple avec Emacs ou Xemacs en mode tuareg) puis sauvegardé dans hello.ml<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir explicitement l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase. Les entrées de l'utilisateur sont ici en italiques; tout le reste (y compris le % et le #) sont sortis par la machine.<br />
<br />
% ''ocaml''<br />
Objective Caml version 3.09.1<br />
<br />
# ''2 + 3;;''<br />
- : int = 5<br />
<br />
Ici apparait un trait essentiel du langage Ocaml: l''''inférence de types''' (ou synthèse de type). Chaque expression entrée (ou compilée) est analysée par le compilateur qui devine (infère) son type. Le compilateur donne le type inféré (ici le type entier ''int'' sur 31 bits -un bit de moins que la taille du mot machine), calcule la valeur de l'expression, puis l'imprime (ici ''5'').<br />
<br />
Sous le toplevel, on peut demander la compilation (interactive) d'un fichier, par la directive #use:<br />
# ''#use "hello.ml";;''<br />
hello world<br />
- : unit = ()<br />
<br />
le fichier hello.ml a été compilé puis exécuté, donc le message hello word est imprimé. Toutes les expressions Ocaml ont une valeur (à l'inverse de C ou Pascal, où procedures et fonctions sont différentes), et les fonctions qui n'ont qu'un effet de bord (par exemple une impression) renvoie une valeur de type ''unit'' - cette valeur est notée ()<br />
<br />
les fonctions sont des valeurs comme les autres: Ocaml est un langage fonctionnel, et des fonctions peuvent prendre comme arguments ou renvoyer comme résultat d'autres fonctions. Pour interroger le type d'une valeur, il suffit de la taper; voici comment demander la fonction print_string:<br />
# ''print_string;;''<br />
- : string -> unit = <fun><br />
<br />
La valeur d'une fonction n'est pas affichée (c'est techniquement une fermeture, c'est à dire la juxtaposition de code executable et des valeurs qu'il utilise); Ocaml affiche donc le type string -> unit de la fonction print_string: c'est une fonction qui prend un argument chaine et renvoie unit.<br />
<br />
<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11857OCaml2006-02-18T20:47:22Z<p>Basiles : </p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant). Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
=== quelques exemples de code Ocaml ===<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *) et peuvent être imbriqués.<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
on peut aussi utiliser l'interprète interactif (toplevel); on peu taper les phrases sur plusieurs lignes, mais le double point-virgule est indispensable pour terminer la phrase.<br />
<br />
% ''ocaml''<br />
Objective Caml version 3.09.1<br />
<br />
# ''2 + 3;;''<br />
- : int = 5<br />
<br />
<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11856OCaml2006-02-18T20:41:39Z<p>Basiles : n</p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant). Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
== quelques exemples de code Ocaml ==<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *)<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction, sans parenthèses. Un certain nombre de fonctions (en fait de valeurs fonctionnelles) sont prédéfinies, de sorte qu'on n'a pas besoin (au contraire de C) de requérir l'accès à la bibliothèque standard d'Ocaml.<br />
<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=OCaml&diff=11855OCaml2006-02-18T20:35:11Z<p>Basiles : /* L'implémentation d'Ocaml */</p>
<hr />
<div>{{En construction}}<br />
= Le language Ocaml =<br />
<br />
== Introduction ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant). Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
== quelques exemples de code Ocaml ==<br />
<br />
Bien sûr, le hello world:<br />
<br />
''(* hello world en Ocaml *)''<br />
print_string "hello world\n";;<br />
<br />
Les commentaires sont à la Pascal entre (* et *)<br />
<br />
Les arguments d'une fonction (ici print_string) suivent le nom de la fonction<br />
<br />
On peut sauvegarder ce fichier de 2 lignes dans hello.ml puis le compiler par <br />
ocamlc hello.ml -o hello qui produit un binaire de code octet (portable tel quel sur beaucoup d'architectures). On aurait pu le compiler avec le compilateur natif: ocamlopt hello.ml -o hello<br />
<br />
<br />
{{Copy|9/11/2005|[[Utilisateur:Basiles|Basiles]]|CC-BY-SA}}</div>Basileshttps://lea-linux.org/docs/index.php?title=Proposition_d%27article&diff=10557Proposition d'article2005-11-09T20:54:46Z<p>Basiles : /* Le language Ocaml */</p>
<hr />
<div>= Proposition d'article =<br />
Indiquer ici les articles qui manquent et que vous même désirez créer, puis créez les ! Si vous avez besoin de mettre des images dans votre article, n'hésitez pas à demander à Léa les [[Lea_Linux:Groupe_Editeur|droit d'éditeurs]]. '''Ne mettez pas''' des articles que vous désireriez voir écrits par quelqu'un d'autre que vous ! <br />
<br />
'''Note :''' pour proposer un nouveau truc ou une nouvelle astuce, utiliser [[Trucs:Proposition_d'un_truc|cette page]].<br />
<br />
* exemple : <nowiki>[[Nom de l'article]]</nowiki><br />
== Rubrique : Installation ==<br />
<br />
== Rubrique : X Window ==<br />
<br />
== Rubrique : Matériel ==<br />
* [[Utilisation des jukebox creative sous linux]] [[Utilisateur:Bimon]] 30 octobre 2005<br />
<br />
== Rubrique : Logiciels ==<br />
<br />
== Rubrique : Le réseau ==<br />
[[Debian GNU/Linux et IPv6]]. [[Utilisateur: Thomas Carlu|Thomas Carlu]] 25 oct 2005 à 1:15 (CEST)<br />
<br />
== Rubrique : Administrer ==<br />
* [[Gestion des ACL]] (ou [[ACL]] pour le titre). [[Utilisateur:Vincent Ramos|Vincent Ramos]] 24 oct 2005 à 23:00 (CEST)<br />
:Fait. Bien qu'améliorable, l'article me semble complet. [[Utilisateur:Vincent Ramos|Vincent Ramos]] 26 oct 2005 à 00:22 (CEST) ;<br />
* [[Attributs étendus]] (''chattr'' sur ext2 et ext3, outils efs2progs) [[Utilisateur:Vincent Ramos|Vincent Ramos]] 26 oct 2005 à 17:40 (CEST)<br />
<br />
== Rubrique : Noyau et modules ==<br />
<br />
== Rubrique : Développer ==<br />
<br />
<br />
== Le language Ocaml ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
<br />
== L'implémentation d'Ocaml ==<br />
<br />
Le language Ocaml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant). Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot).<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
Il existe une communauté grandissante de développeurs Ocaml. Le '''Ocaml Hump''' [http://caml.inria.fr/cgi-bin/hump.fr.cgi ici] contient une collection croissante de logiciels et bibliothèques libres codé(e)s en Ocaml; on peut développer des applications Web (avec Wdialog par exemple), interfacer des SGBDs, invoquer des appels systèmes etc... Ocaml est très puissant (et originellement développé) pour le traitement symbolique de l'information: compilateurs, démonstrateurs de théorèmes, etc..<br />
<br />
J'aurais d'autres choses à dire sur Ocaml. N'hesitez pas à m'y inciter. <br />
--[[Utilisateur:Basiles|Basiles]] 9 nov 2005 à 21:45 (CET)<br />
<br />
== Rubrique : Léavancé ==</div>Basileshttps://lea-linux.org/docs/index.php?title=Proposition_d%27article&diff=10556Proposition d'article2005-11-09T20:48:11Z<p>Basiles : /* Le language Ocaml */</p>
<hr />
<div>= Proposition d'article =<br />
Indiquer ici les articles qui manquent et que vous même désirez créer, puis créez les ! Si vous avez besoin de mettre des images dans votre article, n'hésitez pas à demander à Léa les [[Lea_Linux:Groupe_Editeur|droit d'éditeurs]]. '''Ne mettez pas''' des articles que vous désireriez voir écrits par quelqu'un d'autre que vous ! <br />
<br />
'''Note :''' pour proposer un nouveau truc ou une nouvelle astuce, utiliser [[Trucs:Proposition_d'un_truc|cette page]].<br />
<br />
* exemple : <nowiki>[[Nom de l'article]]</nowiki><br />
== Rubrique : Installation ==<br />
<br />
== Rubrique : X Window ==<br />
<br />
== Rubrique : Matériel ==<br />
* [[Utilisation des jukebox creative sous linux]] [[Utilisateur:Bimon]] 30 octobre 2005<br />
<br />
== Rubrique : Logiciels ==<br />
<br />
== Rubrique : Le réseau ==<br />
[[Debian GNU/Linux et IPv6]]. [[Utilisateur: Thomas Carlu|Thomas Carlu]] 25 oct 2005 à 1:15 (CEST)<br />
<br />
== Rubrique : Administrer ==<br />
* [[Gestion des ACL]] (ou [[ACL]] pour le titre). [[Utilisateur:Vincent Ramos|Vincent Ramos]] 24 oct 2005 à 23:00 (CEST)<br />
:Fait. Bien qu'améliorable, l'article me semble complet. [[Utilisateur:Vincent Ramos|Vincent Ramos]] 26 oct 2005 à 00:22 (CEST) ;<br />
* [[Attributs étendus]] (''chattr'' sur ext2 et ext3, outils efs2progs) [[Utilisateur:Vincent Ramos|Vincent Ramos]] 26 oct 2005 à 17:40 (CEST)<br />
<br />
== Rubrique : Noyau et modules ==<br />
<br />
== Rubrique : Développer ==<br />
<br />
<br />
== Le language Ocaml ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
Le language caml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant). Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler'', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot.<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
J'aurais d'autres choses à dire sur Ocaml. N'hesitez pas à m'y inciter. <br />
--[[Utilisateur:Basiles|Basiles]] 9 nov 2005 à 21:45 (CET)<br />
<br />
== Rubrique : Léavancé ==</div>Basileshttps://lea-linux.org/docs/index.php?title=Proposition_d%27article&diff=10555Proposition d'article2005-11-09T20:45:41Z<p>Basiles : /* Le language Ocaml */</p>
<hr />
<div>= Proposition d'article =<br />
Indiquer ici les articles qui manquent et que vous même désirez créer, puis créez les ! Si vous avez besoin de mettre des images dans votre article, n'hésitez pas à demander à Léa les [[Lea_Linux:Groupe_Editeur|droit d'éditeurs]]. '''Ne mettez pas''' des articles que vous désireriez voir écrits par quelqu'un d'autre que vous ! <br />
<br />
'''Note :''' pour proposer un nouveau truc ou une nouvelle astuce, utiliser [[Trucs:Proposition_d'un_truc|cette page]].<br />
<br />
* exemple : <nowiki>[[Nom de l'article]]</nowiki><br />
== Rubrique : Installation ==<br />
<br />
== Rubrique : X Window ==<br />
<br />
== Rubrique : Matériel ==<br />
* [[Utilisation des jukebox creative sous linux]] [[Utilisateur:Bimon]] 30 octobre 2005<br />
<br />
== Rubrique : Logiciels ==<br />
<br />
== Rubrique : Le réseau ==<br />
[[Debian GNU/Linux et IPv6]]. [[Utilisateur: Thomas Carlu|Thomas Carlu]] 25 oct 2005 à 1:15 (CEST)<br />
<br />
== Rubrique : Administrer ==<br />
* [[Gestion des ACL]] (ou [[ACL]] pour le titre). [[Utilisateur:Vincent Ramos|Vincent Ramos]] 24 oct 2005 à 23:00 (CEST)<br />
:Fait. Bien qu'améliorable, l'article me semble complet. [[Utilisateur:Vincent Ramos|Vincent Ramos]] 26 oct 2005 à 00:22 (CEST) ;<br />
* [[Attributs étendus]] (''chattr'' sur ext2 et ext3, outils efs2progs) [[Utilisateur:Vincent Ramos|Vincent Ramos]] 26 oct 2005 à 17:40 (CEST)<br />
<br />
== Rubrique : Noyau et modules ==<br />
<br />
== Rubrique : Développer ==<br />
<br />
<br />
== Le language Ocaml ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application libre potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes, disponible [http://www.cis.upenn.edu/~bcpierce/unison/ ici]. Il y aussi '''Advi''' (visualiseur pour fichiers dvi produits par LaTeX) qui permet notamment de faire de beaux transparents (y compris avec des formules de mathématiques, de l'animation, des fenêtres de démo de logiciels) disponible [http://pauillac.inria.fr/advi/ ici] et le paquet Whizzytex (utilisant advi) pour visualiser immédiatement en temps quasi réel un document LaTeX pendant son édition.<br />
<br />
Le language caml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation (partageant du code en commun):<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant). Il y a aussi un débogueur '''ocamldebug''' <br />
<br />
le compilateur vers du code-octet ''bytecode compiler', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot.<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''. Les programmes compilés avec ocamlopt s'exécutent à peu près aussi rapidement que leur équivalent C ou C++.<br />
<br />
J'aurais d'autres choses à dire sur Ocaml. N'hesitez pas à m'y inciter. <br />
--[[Utilisateur:Basiles|Basiles]] 9 nov 2005 à 21:45 (CET)<br />
<br />
== Rubrique : Léavancé ==</div>Basileshttps://lea-linux.org/docs/index.php?title=Proposition_d%27article&diff=10554Proposition d'article2005-11-09T20:38:29Z<p>Basiles : /* Le language Ocaml */</p>
<hr />
<div>= Proposition d'article =<br />
Indiquer ici les articles qui manquent et que vous même désirez créer, puis créez les ! Si vous avez besoin de mettre des images dans votre article, n'hésitez pas à demander à Léa les [[Lea_Linux:Groupe_Editeur|droit d'éditeurs]]. '''Ne mettez pas''' des articles que vous désireriez voir écrits par quelqu'un d'autre que vous ! <br />
<br />
'''Note :''' pour proposer un nouveau truc ou une nouvelle astuce, utiliser [[Trucs:Proposition_d'un_truc|cette page]].<br />
<br />
* exemple : <nowiki>[[Nom de l'article]]</nowiki><br />
== Rubrique : Installation ==<br />
<br />
== Rubrique : X Window ==<br />
<br />
== Rubrique : Matériel ==<br />
* [[Utilisation des jukebox creative sous linux]] [[Utilisateur:Bimon]] 30 octobre 2005<br />
<br />
== Rubrique : Logiciels ==<br />
<br />
== Rubrique : Le réseau ==<br />
[[Debian GNU/Linux et IPv6]]. [[Utilisateur: Thomas Carlu|Thomas Carlu]] 25 oct 2005 à 1:15 (CEST)<br />
<br />
== Rubrique : Administrer ==<br />
* [[Gestion des ACL]] (ou [[ACL]] pour le titre). [[Utilisateur:Vincent Ramos|Vincent Ramos]] 24 oct 2005 à 23:00 (CEST)<br />
:Fait. Bien qu'améliorable, l'article me semble complet. [[Utilisateur:Vincent Ramos|Vincent Ramos]] 26 oct 2005 à 00:22 (CEST) ;<br />
* [[Attributs étendus]] (''chattr'' sur ext2 et ext3, outils efs2progs) [[Utilisateur:Vincent Ramos|Vincent Ramos]] 26 oct 2005 à 17:40 (CEST)<br />
<br />
== Rubrique : Noyau et modules ==<br />
<br />
== Rubrique : Développer ==<br />
<br />
<br />
== Le language Ocaml ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python). Il existe plusieurs grosses applications développées en Ocaml -aussi bien libres que propriétaires-. Une application potentiellement utile à beaucoup est '''Unison''' pour synchroniser (càd copier) des fichiers entres machines différentes. <br />
<br />
Le language caml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation:<br />
<br />
l'interprète interactif dit ''toplevel'', par la commande '''ocaml'''; le principal intérêt d' '''ocaml''' est de tester '''interactivement''' une (ou quelques) nouvelles fonctions (éventuellement rajoutées à un gros programme existant).<br />
<br />
le compilateur vers du code-octet ''bytecode compiler', par la commande '''ocamlc''' (le code-octet produit a sa machine virtuelle propre '''ocamlrun'''; ce code octet est différent de ceux de Java, Lua ou Parrot.<br />
<br />
le compilateur natif (sur AMD64, x86, PowerPC, Sparc etc...) ''native compiler'', par la commande '''ocamlopt'''<br />
<br />
== Rubrique : Léavancé ==</div>Basileshttps://lea-linux.org/docs/index.php?title=Proposition_d%27article&diff=10553Proposition d'article2005-11-09T20:32:17Z<p>Basiles : Développer en Ocaml</p>
<hr />
<div>= Proposition d'article =<br />
Indiquer ici les articles qui manquent et que vous même désirez créer, puis créez les ! Si vous avez besoin de mettre des images dans votre article, n'hésitez pas à demander à Léa les [[Lea_Linux:Groupe_Editeur|droit d'éditeurs]]. '''Ne mettez pas''' des articles que vous désireriez voir écrits par quelqu'un d'autre que vous ! <br />
<br />
'''Note :''' pour proposer un nouveau truc ou une nouvelle astuce, utiliser [[Trucs:Proposition_d'un_truc|cette page]].<br />
<br />
* exemple : <nowiki>[[Nom de l'article]]</nowiki><br />
== Rubrique : Installation ==<br />
<br />
== Rubrique : X Window ==<br />
<br />
== Rubrique : Matériel ==<br />
* [[Utilisation des jukebox creative sous linux]] [[Utilisateur:Bimon]] 30 octobre 2005<br />
<br />
== Rubrique : Logiciels ==<br />
<br />
== Rubrique : Le réseau ==<br />
[[Debian GNU/Linux et IPv6]]. [[Utilisateur: Thomas Carlu|Thomas Carlu]] 25 oct 2005 à 1:15 (CEST)<br />
<br />
== Rubrique : Administrer ==<br />
* [[Gestion des ACL]] (ou [[ACL]] pour le titre). [[Utilisateur:Vincent Ramos|Vincent Ramos]] 24 oct 2005 à 23:00 (CEST)<br />
:Fait. Bien qu'améliorable, l'article me semble complet. [[Utilisateur:Vincent Ramos|Vincent Ramos]] 26 oct 2005 à 00:22 (CEST) ;<br />
* [[Attributs étendus]] (''chattr'' sur ext2 et ext3, outils efs2progs) [[Utilisateur:Vincent Ramos|Vincent Ramos]] 26 oct 2005 à 17:40 (CEST)<br />
<br />
== Rubrique : Noyau et modules ==<br />
<br />
== Rubrique : Développer ==<br />
<br />
<br />
== Le language Ocaml ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux et au logiciel libre. Il est utilisé par une communauté croissante, aussi bien dans le monde académique (de nombreux chercheurs prototypent leurs idées en Ocaml) ou universitaire (son prédécesseur Caml est enseigné en classe prépa, premier cycle) que dans le monde industriel (dans des petites startup comme dans des grosses multinationales). Ocaml est language fonctionnel et à objets, avec un typage statique (et inférence de types). À cet égard il est assez différent des languages habituels sous Linux (comme C, C++, Perl, Python).<br />
<br />
Le language caml a sa page [http://caml.inria.fr ici]. Son implémentation est libre. Il y a en réalité plusieurs variantes d'implementation:<br />
<br />
l'interprète interactif dit ''toplevel''<br />
<br />
== Rubrique : Léavancé ==</div>Basileshttps://lea-linux.org/docs/index.php?title=Proposition_d%27article&diff=10552Proposition d'article2005-11-09T20:25:02Z<p>Basiles : Développer en Ocaml</p>
<hr />
<div>= Proposition d'article =<br />
Indiquer ici les articles qui manquent et que vous même désirez créer, puis créez les ! Si vous avez besoin de mettre des images dans votre article, n'hésitez pas à demander à Léa les [[Lea_Linux:Groupe_Editeur|droit d'éditeurs]]. '''Ne mettez pas''' des articles que vous désireriez voir écrits par quelqu'un d'autre que vous ! <br />
<br />
'''Note :''' pour proposer un nouveau truc ou une nouvelle astuce, utiliser [[Trucs:Proposition_d'un_truc|cette page]].<br />
<br />
* exemple : <nowiki>[[Nom de l'article]]</nowiki><br />
== Rubrique : Installation ==<br />
<br />
== Rubrique : X Window ==<br />
<br />
== Rubrique : Matériel ==<br />
* [[Utilisation des jukebox creative sous linux]] [[Utilisateur:Bimon]] 30 octobre 2005<br />
<br />
== Rubrique : Logiciels ==<br />
<br />
== Rubrique : Le réseau ==<br />
[[Debian GNU/Linux et IPv6]]. [[Utilisateur: Thomas Carlu|Thomas Carlu]] 25 oct 2005 à 1:15 (CEST)<br />
<br />
== Rubrique : Administrer ==<br />
* [[Gestion des ACL]] (ou [[ACL]] pour le titre). [[Utilisateur:Vincent Ramos|Vincent Ramos]] 24 oct 2005 à 23:00 (CEST)<br />
:Fait. Bien qu'améliorable, l'article me semble complet. [[Utilisateur:Vincent Ramos|Vincent Ramos]] 26 oct 2005 à 00:22 (CEST) ;<br />
* [[Attributs étendus]] (''chattr'' sur ext2 et ext3, outils efs2progs) [[Utilisateur:Vincent Ramos|Vincent Ramos]] 26 oct 2005 à 17:40 (CEST)<br />
<br />
== Rubrique : Noyau et modules ==<br />
<br />
== Rubrique : Développer ==<br />
<br />
<br />
== Le language Ocaml ==<br />
<br />
Le language Ocaml est développé en France par une équipe de chercheurs de l'[http://www.inria.fr INRIA], dont la plupart utilisent (et contribuent activement) à Linux.<br />
<br />
== Rubrique : Léavancé ==</div>Basileshttps://lea-linux.org/docs/index.php?title=Utilisateur:Basiles&diff=10551Utilisateur:Basiles2005-11-09T20:16:06Z<p>Basiles : mini-page de Basile Starynkevitch</p>
<hr />
<div>Basile STARYNKEVITCH (Bourg La Reine - France) - voir sa page [http://starynkevitch.net/Basile ici]</div>Basiles