Séance 1
Premiers pas en Oz

L'objectif de cette séance est de se familiariser avec

• l'environnement de développement du système Mozart,
• le langage de programmation Oz.

Préalable

Démarrez l'interface de Mozart. Consultez le lien pour utiliser au mieux les commandes d'édition et de compilation.

Exercices

Voici quelques exercices pour vous familiariser à l'environnement et au langage.

1. Editer et compiler. Tapez le programme suivant.

      {Browse 1}
      {Browse 2}
      {Browse 3}
      {Browse 4}
   

   Ce programme appelle quatre fois la procédure Browse. Cette procédure affiche la valeur qui est donnée en argument.
   • Compilez et exécutez ce programme.
   • Exécutez maintenant ce programme une ligne à la fois. Exécutez les lignes dans l'ordre inverse, sans changer le programme. Exécutez les deux dernières lignes en une fois.

2. Expressions arithmétiques. Nous pouvons utiliser la procédure Browse pour évaluer des expressions arithmétiques. Par exemple:

      {Browse (1+5)*(9-2)}
   

   Calculez
   • 192 - 980
   • 192 - 980 - 191 * 967
   • (192 - 980) * (-2) - 191 * 967

   Attention: l'opérateur de négation se note ``~''.

3. Variables. L'instruction declare permet de créer une variable et de lui assigner une valeur. Comme dans l'exercice précédent, la valeur peut être donnée par une expression. Par exemple:

      declare
      X=(6+5)*(9-7)
   

   On peut alors utiliser l'identificateur de la variable comme synonyme de la valeur. Par exemple:

      {Browse X}
      {Browse X+5}
   

   Réeffectuez les calculs de l'exercice précédent, en utilisant des variables là où vous le jugez utile.

4. Déclarations multiples. Considérez le programme suivant:

      declare
      X=42
      Z=~3
      {Browse X}     % (1)
      {Browse Z}
      
      declare
      Y=X+5
      {Browse Y}     % (2)
      
      declare
      X=1234567890
      {Browse X}     % (3)
   

   Ce qui se trouve après le signe % est ignoré par le compilateur. Il s'agit d'un commentaire.
   • Exécutez le programme paragraphe par paragraphe (c'est-à-dire les cinq première lignes d'abord, puis les trois suivantes, puis les trois dernières). Après cela, le premier X est-il toujours accessible ? A votre avis, sa valeur est-elle toujours en mémoire ? Qu'en est-il de Z ?
   • Réexécutez uniquement la ligne (1). Quel X est affiché ? Où s'est fait le lien entre le X et cette valeur ?
   • Réexécutez la ligne (2). La valeur de Y a-t-elle été affectée par la seconde déclaration de X ? Pourquoi ?

5. Expressions booléennes. Outre les expressions arithmétiques, Oz propose des expressions booléennes. Les deux valeurs possibles de telles expressions sont true et false. Ainsi, la comparaison de deux valeurs entières renvoie un booléen.

      {Browse 3 == 7}     % egaux
      {Browse 3 \= 7}     % differents
      {Browse 3 < 7}      % plus petit
      {Browse 3 =< 7}     % plus petit ou egal
      {Browse 3 > 7}      % plus grand
      {Browse 3 >= 7}     % plus grand ou egal
   

   Faites quelques tests et observez les valeurs booléennes renvoyées.

6. Fonctions et expressions. Nous pouvons aussi utiliser des appels de fonctions dans les expressions arithmétiques et booléennes. Voici un exemple:

      {Browse {Max 3 7}}
      {Browse {Not 3==7}}
   

   La fonction Max prend deux arguments et renvoie le maximum de ceux-ci. La fonction Not prend un argument booléen et renvoie sa négation. Notez que les arguments des fonctions sont aussi des expressions arithmétiques ou booléennes.

   • Utilisez la fonction Max dans une expression qui renvoie le maximum entre trois nombres X, Y et Z. Essayer avec X=7, Y=5, Z=6. Essayer également avec d'autres valeurs.

   • Dans le programme suivant, la sous-expression {SlowAdd 1000 1} est calculée trois fois. La fonction SlowAdd est implémentée pour calculer une somme en au moins une seconde (1000 millisecondes). Transformez l'expression dans l'appel à Browse pour n'appeler SlowAdd qu'une seule fois. Pensez à introduire une variable avec local...in...end.

        declare
        fun {SlowAdd X Y}
           {Delay 1000} X+Y
        end
        {Browse {SlowAdd 1000 1}+{SlowAdd 1000 1}+{SlowAdd 1000 1}}
     

   • Construisez une fonction qui renvoie le signe d'un entier N passé en argument. Les valeurs possibles du signe sont 0, 1 et ~1 suivant que N est nul, positif ou négatif. Testez votre fonction pour différentes valeurs de N.

7. Portée lexicale et environnement. Pour rappel, la portée d'une déclaration est la zone d'un programme où un identificateur est défini et correspond à cette déclaration. L'environnement à un moment donné de l'exécution est l'ensemble des identificateurs définis et leur variable correspondante en mémoire.

   • Dans le programme suivant, quelle est la portée de chacun des identificateurs déclarés ? Ou, de manière duale, à quelle déclaration se rapporte chaque occurrence d'identificateur ?

        local P Q X Y Z in   % (1)
           fun {P X}
              X*Y+Z        % (2)
           end
           fun {Q Y}
              X*Y+Z        % (3)
           end
           X=1
           Y=2
           Z=3
           {Browse {Q {P 4}}}
        end
     

   • En utilisant les informations précédentes, prédisez le résultat de l'exécution du programme. Si cela s'avère nécessaire, exécutez le programme à la main, en notant les instructions effectivement exécutées et leur environnement.

   • Modifiez le code pour que l'identificateur Y à la ligne (2) corresponde à la variable dénotée par X à la ligne (1), et aie donc la valeur 1. Vérifiez que le programme modifié affiche 10.

   • Faites de même pour que l'identificateur Z à la ligne (3) corresponde à la variable dénotée par Y à la ligne (1), et aie donc la valeur 2. Vérifiez que le programme modifié affiche 9.

8. L'abstraction procédurale. Dans cet exercice, vous allez explorer les possibilités des fonctions, afin d'en améliorer votre compréhension. Considérez le programme suivant.

      declare
      X=3
   
      {Browse X+2}     % (1)
      {Browse X*2}     % (2)
   

   • Construisez une fonction Add2 sans argument, à partir de l'expression X+2 à la ligne (1). Ensuite, remplacez l'expression de la ligne (1) par un appel à la fonction Add2.

   • Construisez maintenant une fonction Mul2 à partir de l'expression X*2 de la ligne (2). Cette fonction prendra X en paramètre. Comme dans le point précédent, remplacez l'expression de la ligne (2) par un appel à la fonction Mul2.

   • Décrivez les fonctions Add2 et Mul2. Quels est leur environnement contextuel, c'est-à-dire leurs identificateurs libres et leur valeur ?

   • Déclarez à nouveau l'identificateur X par l'instruction ci-dessous, sans redéfinir les procédures Add2 et Mul2.

        declare
        X=4
     

     Que se passe-t-il si l'on appelle maintenant les fonctions Add2 et Mul2 ?

Exercices supplémentaires

1. Calculez l'expressions suivante en utilisant des variables de manière adéquate (Indication: pensez à 2⁷ = 2*2*2*2*2*2*2).

   2⁷ * 3 + 2⁴² - 2¹⁰⁰ * 5

2. La fonction Sqrt renvoie la racine carrée du nombre réel passé en argument. Utilisez-la pour construire une fonction Distance qui calcule la distance entre deux points d'un plan. Cette fonction prend quatre nombres réels en argument.

      local
         X1=3.   Y1=2.
         X2=2.5  Y2=0.
      in
         {Browse {Distance X1 Y1 X2 Y2}}
      end
   

3. Construisez une fonction Egal qui prend deux arguments et renvoie true s'ils sont égaux, false sinon.

4. Dans cet exercice, nous allons explorer plusieurs façons de définir une fonction qui calcule le maximum entre deux nombres.

   • Ecrivez deux fonctions MonMax1 et MonMax2, qui prennent chacune deux arguments et renvoient le maximum de ceux-ci. MonMax1 ne peut pas utiliser la fonction Max définie par Oz et utilisée dans l'exercice 6 ci-dessus. MonMax2, à l'inverse, doit utiliser la fonction Max.

   • Analysez le comportement des trois morceaux de code suivants. Certains provoquent des erreurs, d'autres pas. Tâchez d'expliquer.

        declare
        X=1 Y=2
        Y={MonMax1 X Y}
        {Browse Y}
     
        declare
        X=2 Y=1
        Y={MonMax1 X Y}
        {Browse Y}
     
        declare
        X=2 Y=1
        {Browse Y=={MonMax1 X Y}}
     

   • Ecrivez une fonction MonMax3, qui prend un seul argument et renvoie le maximum entre cet argument et la variable X.

   • Expliquez le comportement des deux bouts de programme suivants.

        declare
        X=1 Y=2
        {Browse {MonMax3 Y}}
     
        declare
        X=1 Y=2
        {Browse {MonMax3 X}}