« Premiers pas en OCaml » : différence entre les versions

Une page de Wikiversité, la communauté pédagogique libre.
Contenu supprimé Contenu ajouté
Watermy (discussion | contributions)
Premier pas 2ème partie
Watermy (discussion | contributions)
Ajout des leçons
Ligne 1 : Ligne 1 :
{{Leçon
| idfaculté = informatique
| département = Programmation informatique
| 1 = {{C|Installation|2| }}
| 2 = {{C|Types|0|?}}
| 3 = {{C|Opérations|0|?}}
| exo1 = {{Exo|QCM|0|?}}
| niveau = 13
}}


Nous allons d'abord nous familiariser avec le langage OCaml.
Nous allons d'abord nous familiariser avec le langage OCaml.
Pour cela lancez l'interpréteur OCaml dans un invite de commande.
Pour cela lancez l'interpréteur OCaml dans un invite de commande.

Version du 29 avril 2011 à 22:14

Premiers pas en OCaml
Chapitres
Chap. 1 :Symbole icône indiquant que la page est une leçon avancée Installation 
Chap. 2 :Symbole icône indiquant que la page est à l'état d'ébauche Types (?)
Chap. 3 :Symbole icône indiquant que la page est à l'état d'ébauche Opérations (?)
Exercices
Exercice : Symbole icône indiquant que la page est à l'état d'ébauche QCM (?)

Présentation [Modifier]

Nous allons découvrir les bases du langage. Les types primitifs et les opérations arithmétiques de bases.

Objectifs [Modifier]

  • Découvrir les types de bases
  • Découvrir les opérations de bases
  • Savoir effectuer les conversions entre types (transtypage)

Niveau et prérequis conseillés [Modifier]

Leçon de niveau 13. Aucun prérequis n'est nécessaire pour cette section.


Référents [Modifier]

Ces personnes sont prêtes à vous aider concernant cette leçon :


Nous allons d'abord nous familiariser avec le langage OCaml. Pour cela lancez l'interpréteur OCaml dans un invite de commande.

 ocaml

Si vous avez bien installé OCaml vous devriez voir le prompt d'OCaml apparaître.

 # |

En OCaml et contrairement à d'autres langage de programmation les expressions finissent par deux points-virgules.

 <expression>;;


Types basiques

OCaml est statiquement typé. Pourtant le type n'est jamais explicitement donné par le développeur. C'est l'une des puissance de OCaml qui utilise l'inférence de type pour déterminer à la compilation le type utilisé. Voyons ce que peut faire OCaml sur quelques exemples.

Les entiers (Integer)

Commencez par taper un entier :

 1;;

La ligne suivante s'affiche.

 - : int = 1


Les réels/flottants (float)

Maintenant un réel (composé d'un point '.')

 1.0;;

ou encore

 1.;;

La ligne suivante s'affiche.

 - : float = 1.

Les caractères (character)

Puis un caractère encadrés par de simples apostrophes (simple quote)

'c';;
 - : char = 'c'

Attention un caractère n'est composé que d'un caractère sous peine d'obtenir une erreur.

'cd';;
 Error: Syntax error

Les seules exceptions sont les caractères spéciaux (commençant par un antislash '\') tel que '\n' (saut de ligne)

'\n';;
 - : char = '\n'

Les chaînes de caractères (string)

Maintenant une chaîne de caractère encadré par des guillemets anglais (double quote)

 "chaine";;
 - : string = "chaine"

Les booléens (boolean)

Et enfin les booléens : deux valeurs possibles, soit vrai (true) soit faux (false)

 true;;
 - : bool = true

ou

 false;;
 - : bool = false

Les opérations simples

sur les entiers

L'inférence de type décharge le développeur de la déclaration des différents types. En contrepartie l'utilisation d'opérateurs spécifiques pour chaque type. Les opérateurs +,-,/,* permettent respectivement d'effectuer les opérations sur l

 1+2;;
 - : int = 3

L'ordre des opérateurs est le même que pour les mathématiques '*' et '/' sont prioritaires sur '+' et '-'.

 1*2-3+4;;
 - : int = 3

Mais il reste possible d'utiliser des parenthèse pour changer les priorités.

 1*2-(3+4);;
 - : int = -5

L'utilisation de la division tronque le résultat.

 5/2;;
 - : int = 2

sur les réels

Les opérateurs pour les réels sont les mêmes que pour les entiers mais suivit d'un point +.,-.*.,/. .

 1.0 +. 2.0
 - : float = 3.

L'addition s'effectue avec l'opérateur '+' pour les entier et '+.' pour les réels. De même '*.' et '/.' sont prioritaires sur '+.' et '-.'.

 1.*.2.-.3.+.4.;;
 - : float = 3.

De même les parenthèse change les priorités.

 1.*.2.-.(3.+.4.);;
 - : float = -5.

Mais cette fois la division donne le résultat exacte

 5./.2.;;
 - : float = 2.5