ENIB S4-PRG-Rust 01_Types - Types et valeurs

{} Installation et prise en main

La première chose à faire consiste à prendre le temps de s'assurer du fait que tout l'outillage est installé et configuré dans votre environnement de travail.

Il faut nécessairement configurer votre environnement de travail sur les postes de travail de l'ENIB qui sont équipés du système d'exploitation Linux.
Pour cela, la simple saisie de la commande enib_rust_setup dans un terminal est suffisante.

Bien entendu, au moment de poursuivre en dehors des séances planifiées, il faudra également installer et configurer votre poste de travail personnel.
Pour cela, il faut se référer à ce chapitre.

Après s'être assuré des bonnes installation et configuration des outils, il convient également de se remémorer les démarches décrites dans ce chapitre.

Le point de départ pour toutes les expérimentations à venir sera le projet s4prg qui contient notamment :

Cargo.toml : la configuration qui décrit quelques propriétés du projet,
src/lib.rs : la bibliothèque constituée de toutes les expérimentations que nous nous apprêtons à mener,
src/chapter_?.rs : des modules de cette bibliothèque contenant les fonctions (encore vides) qui serviront à expérimenter,
src/main.rs : le programme principal permettant de choisir les chapitres et les fonctions à propos desquels nous voulons exécuter des expérimentations,
src/s4.rs et src/roadmap.rs : deux modules de fonctionnalités utiles pour quelques expérimentations,
tests/integration_?.rs : les tests d'intégration, encore vides, qui devront être réalisés pour certaines étapes,
count_big.txt✍
Ce fichier a été téléchargé depuis https://norvig.com/ngrams/.
: une liste d'occurrences pour 29136 mots en langue Anglaise qui servira de jeu de données pour quelques expérimentations.
map_16.csv et map_96.csv✍
Le fichier map_96.csv a été généré à partir de données publiées sur https://github.com/ThomasLENNE/terminale-nsi-cours/ dans __Projets__/9.Folium.
Il s'agit de la liste des préfectures françaises, ainsi que la liste des départements limitrophes de chaque département.
Les longueurs des routes reliant les préfectures ont été obtenues par des requêtes sur l'API en ligne https://project-osrm.org/.
Le fichier map_16.csv en est un sous-ensemble très partiel.
: deux représentations très simplifiées du réseau routier français qui serviront de jeu de données pour quelques expérimentations.

Le code source de ce projet sera étendu au fil de l'avancée dans le travail.

Faites fonctionner le programme principal tout en lisant brièvement son code source✍ afin d'en comprendre l'organisation.

Que se passe-t-il lorsque nous exécutons ce programme sans argument sur la ligne de commande ?
Et si nous ajoutons un numéro de chapitre sur la ligne de commande ?
Et si nous ajoutons un numéro de section après le numéro de chapitre ?
Et si nous utilisons une notation telle que 1,3-5 ?

{} Types numériques élémentaires

Dans la documentation

rustup doc --std

, recherchez ce qui concerne les types comme i8, i16, i32, i64, i128 ainsi que les types comme u8, u16, u32, u64, u128.

De quoi s'agit-il globalement ?
Que signifient les chiffres constituant ces noms de types ?
Que signifie la distinction entre les préfixes i et u ?
Comment connaître la plage de valeurs que chacun de ces types peut décrire ?

Complétez la fonction chapter_1::section_2() en utilisant quelques-uns de ces types pour effectuer quelques calculs et afficher les résultats.

Provoquez volontairement un passage au delà des limites de la plage de valeurs d'une variable ; que se passe-t-il ?

Consultez la documentation des fonctions saturating_???() et wrapping_???() de cette variable et essayez-les pour en observer le comportement.

Étudiez

rustup doc --std 'as'

et convertissez des données d'un type vers un autre ; que se passe-t-il lorsque les limites ne sont pas respectées ?

Étudiez

rustup doc --std 'f32'

rustup doc --std 'f64'

De quoi s'agit-il globalement ?
Qu'est-ce qui distingue ces deux types ?

Effectuez quelques calculs ainsi que des conversions avec les types précédents.

Déduire de tout cela les règles de prudence à adopter lors du choix des types numériques dans un traitement.

Activité complémentaire :

Essayez les fonctions overflowing_???() des premiers types étudiés et exploitez le booléen pour afficher explicitement le franchissement des limites.
Étudiez
```
rustup doc --std 'std::convert::TryFrom'
```
comme autre moyen d'effectuer des conversions entre ces types et montrez la différence avec as.
Ce chapitre explique les limitations des valeurs réelles✍
Les explications sont données en langage C, mais les propriétés mises en évidence sont liées aux principes mis en œuvre dans le matériel et non au langage de programmation.
.

{} Copie, clonage et déplacement

Dans les expérimentations précédentes, les valeurs numériques pouvaient être librement recopiées d'une variable à une autre.
Cela permet d'exprimer très naturellement des calculs, en réutilisant des valeurs déjà calculées, en les modifiants... comme dans la plupart des langages de programmation.

Introduisez maintenant, dans la fonction chapter_1::section_3(), une variable v1 qui soit un vector contenant quelques valeurs numériques et affichez-en le contenu.
Affectez v1 à une seconde variable v2 dont vous afficherez également le contenu afin de vérifier qu'il est bien identique à celui de v1.
Utilisez ensuite v1 (pour un nouvel affichage par exemple) ; que se passe-t-il ?

Il est probable que le compilateur suggère d'utiliser v1.clone() pour initialiser v2 ; suivez cette recommandation pour en constater l'effet.

Réalisez maintenant une fonction use_vector() attendant comme paramètre un tel vector et qui se contente d'en afficher le contenu.
Appelez cette fonction en lui transmettant v1 comme paramètre et tentez à nouveau d'utiliser v1 après cet appel ; que se passe-t-il ?
Intervenez alors comme précédemment, en utilisant l'opération .clone().

Reprenez une démarche similaire avec une fonction use_int() attendant comme paramètre un entier.
L'usage de .clone() lors de la transmission du paramètre est-il nécessaire ?
Constatez alors la similarité entre l'affectation à une variable et le passage d'un paramètre lors de l'appel d'une fonction.

Modifiez maintenant la fonction use_vector() pour qu'elle change le contenu du vector passé en paramètre (en ajoutant une valeur par exemple) avant de l'afficher.
Que constate-t-on sur v1 qui est affiché au retour de la fonction ?

En l'état actuel de nos connaissances, comment pourrions-nous récupérer la valeur modifiée à la sortie de la fonction ?
(Nous envisagerons une bien meilleure solution ultérieurement)

Assurez-vous d'avoir bien compris ce qui a été observé :

les types élémentaires (numériques notamment) autorisent la copie implicite des valeurs,
les types élaborés (Vec ou String par exemple) autorisent
- le déplacement implicite des valeurs,
- et éventuellement le clonage explicite des valeurs✍
  Le concepteur d'un tel type élaboré peut choisir d'autoriser ou non une telle opération de clonage explicite.
  Plus rarement, lorsqu'un type élaboré n'est composé que de données implicitement copiables, le concepteur peut décider de rendre aussi ce nouveau type implicitement copiable.
  .

Activité complémentaire :

Reprenez une démarche similaire avec une donnée de type String (chaîne de caractères).
Ce chapitre reprend une démarche similaire à celle-ci.

{} Allocation des données

La macro show_mem!() fournie par le module s4 sert à décrire le placement en mémoire d'une donnée.

Dans la fonction chapter_1::section_4(), créez une variable u représentant un entier de 32 bits et utilisez la fonction précédente de cette façon :

s4::show_mem!("u", u);

.
Faites de même avec une variable f représentant un réel de 64 bits.
Faites de même avec une variable t représentant un tableau contenant trois entiers de 16 bits.
Faites encore de même avec une variable v représentant un vector contenant trois entiers de 16 bits.
Observez attentivement les résultats :

Les tailles en octets affichées sont-elles toutes les quatre en accord avec ce que l'intuition suppose ?
Les adresses affichées sont-elles proches ou éloignées ?
Réalisez un dessin représentant ces quatre variables par de petites boîtes illustrant leurs tailles et dispositions respectives.

Affichez le placement en mémoire des entiers mémorisés par t grâce à trois invocations de la forme

s4::show_mem!("t[0]", t[0]);

.
Faites de même avec les entiers mémorisés par v.
Observez attentivement les résultats :

Les tailles en octets affichées sont-elles maintenant en accord avec ce que l'intuition suppose ?
Les nouvelles adresses affichées sont-elles proches ou éloignées entre-elles ?
Sont-elles proches ou éloignées des adresses observées précédemment ?
Pourquoi existe-t-il une telle distinction entre ces zones mémoire ?

Complétez alors le dessin pour représenter les deux zones mémoire distinctes :

la pile (stack) servant aux variables locales,
⟶ contient le dessin précédent,
le tas (heap) servant aux données allouées dynamiquement,
⟶ contient la représentation des éléments mémorisés par v,
une flèche qui relie v aux éléments qu'il mémorise.

Poursuivez le code existant de cette façon :

créez une nouveau vector avec de nombreux éléments qui restera inutilisé (grâce à
```
let _v2 = Vec::from_iter(0..10);
```
par exemple),
ajouter de nombreux éléments à v (grâce à
```
v.extend(0..30);
```
par exemple).

Suite à cela, provoquez un nouvel affichage du placement en mémoire de v et de ses trois premier éléments.

Le vector v a-t-il changé d'emplacement ?
Qu'en est-il des éléments qu'il mémorise ?
En déduire la nature dynamique du tas (heap) et l'utilité de son usage.
En déduire le principe de fonctionnement d'un vector.

Activité complémentaire :

Reprenez une démarche similaire à ce qui a été fait avec v mais avec une variable s de type String (chaîne de caractères) :
- un texte très court comme contenu initial,
- affichage du placement en mémoire de s et de ses quelques premier éléments✍
  Il faudra utiliser des invocations de la forme
  s4::show_mem!("s[0]", &s.as_bytes()[0]);
  car les caractères d'une chaîne ne sont pas directement accessibles.
  L'opération .as_bytes() donne accès à la séquence d'octets représentant l'encodage du texte en UTF-8.
  ,
- extension du texte afin qu'il devienne beaucoup plus long,
- nouvel affichage du placement en mémoire de s et de ses quelques premier éléments,
- comparaison de l'ensemble au cas du vector.

{} Effet du déplacement

Code source résultant

Si chaque étape a été respectée scrupuleusement, vous devez obtenir un fichier de code source semblable à celui-ci :

Fichier chapter_1.rs✎

Contenu du fichier chapter_1.rs

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#[allow(unused_imports)]
use crate::s4;

pub const SECTIONS: &[fn()] =
    &[section_1, section_2, section_3, section_4, section_5];

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

fn section_1() {
    println!("\n~~~~ chapter 1, section 1 ~~~~");
    println!("nothing more to be done, here");
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

fn section_2() {
    println!("\n~~~~ chapter 1, section 2 ~~~~");
    let mut var = 12_u8;
    var += 20;
    println!("var: {}", var);
    if false {
        var -= 40; // PANIC!!!
        println!("var: {}", var);
    }
    //
    var = var.saturating_sub(40);
    println!("var: {} (saturated at lower bound)", var);
    var = var.wrapping_sub(40);
    println!("var: {} (wrapped around lower bound)", var);
    var = var.saturating_add(40);
    println!("var: {} (saturated at upper bound)", var);
    var = var.wrapping_add(40);
    println!("var: {} (wrapped around upper bound)", var);
    //
    let (res, overflow) = var.overflowing_add(230);
    if overflow {
        println!("overflow {} ~~> {}", var, res);
    }
    //
    let mut large = 1000_u32;
    let small = large as u8;
    println!("u32 {} ~~> u8 {}", large, small);
    let try_small = u8::try_from(large);
    println!("u32 {} ~~> try u8 {:?}", large, try_small);
    large /= 10;
    let try_small = u8::try_from(large);
    println!("u32 {} ~~> try u8 {:?}", large, try_small);
    //
    let floating = 987.654_f64;
    let integer = floating as u8;
    println!("f64 {} ~~> u8 {}", floating, integer);
    let integer = -floating as u8;
    println!("f64 {} ~~> u8 {}", -floating, integer);
    //
    let big_f32 = 1.2e8_f32;
    let small_f32 = 3.4_f32;
    let sum_f32 = big_f32 + small_f32;
    println!(
        "f32 {} + {} ~~> {} {}",
        big_f32,
        small_f32,
        sum_f32,
        if sum_f32 == big_f32 { "!!!" } else { "OK" }
    );
    //
    let big_f64 = 1.2e8_f64;
    let small_f64 = 3.4_f64;
    let sum_f64 = big_f64 + small_f64;
    println!(
        "f64 {} + {} ~~> {} {}",
        big_f64,
        small_f64,
        sum_f64,
        if sum_f64 == big_f64 { "!!!" } else { "OK" }
    );
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

fn use_vector(mut v: Vec<i32>) -> Vec<i32> {
    v.push(999);
    println!("in use_vector(): {:?}", v);
    v
}

fn use_int(i: i32) {
    println!("in use_int(): {:?}", i);
}

fn use_string(mut s: String) -> String {
    s.push_str(", World!");
    println!("in use_string(): {:?}", s);
    s
}

fn section_3() {
    println!("\n~~~~ chapter 1, section 3 ~~~~");
    let v1 = vec![10, 20, 30];
    println!("v1: {:?}", v1);
    // let v2 = v1; // ERROR!!! moved
    let v2 = v1.clone();
    println!("v2: {:?}", v2);
    println!("v1: {:?}", v1);
    //
    // use_vector(v1); // ERROR!!! moved
    let v3 = use_vector(v1.clone());
    println!("v1: {:?}", v1);
    println!("v3: {:?}", v3);
    let i = 100;
    use_int(i);
    //
    let s1 = "Hello".to_owned();
    println!("s1: {:?}", s1);
    // let s2 = s1; // ERROR!!! moved
    let s2 = s1.clone();
    println!("s2: {:?}", s2);
    println!("s1: {:?}", s1);
    //
    // use_string(s1); // ERROR!!! moved
    let s3 = use_string(s1.clone());
    println!("s1: {:?}", s1);
    println!("s3: {:?}", s3);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

fn section_4() {
    println!("\n~~~~ chapter 1, section 4 ~~~~");
    let u = 98765_u32;
    let f = 12.34_f64;
    let t = [99_u16, 98, 97];
    let mut v = vec![88_u16, 87, 86];
    s4::show_mem!("   u", u);
    s4::show_mem!("   f", f);
    s4::show_mem!("   t", t);
    s4::show_mem!("t[0]", t[0]);
    s4::show_mem!("t[1]", t[1]);
    s4::show_mem!("t[2]", t[2]);
    s4::show_mem!("   v", v);
    s4::show_mem!("v[0]", v[0]);
    s4::show_mem!("v[1]", v[1]);
    s4::show_mem!("v[2]", v[2]);
    //
    v.extend(1..50);
    s4::show_mem!("   v", v);
    s4::show_mem!("v[0]", v[0]);
    s4::show_mem!("v[1]", v[1]);
    s4::show_mem!("v[2]", v[2]);
    //
    let mut s = "Short".to_owned();
    s4::show_mem!("   s", s);
    s4::show_mem!("s[0]", s.as_bytes()[0]);
    s4::show_mem!("s[1]", s.as_bytes()[1]);
    s4::show_mem!("s[2]", s.as_bytes()[2]);
    //
    s.push_str(", and now, with more words, it becomes much longer!");
    s4::show_mem!("   s", s);
    s4::show_mem!("s[0]", s.as_bytes()[0]);
    s4::show_mem!("s[1]", s.as_bytes()[1]);
    s4::show_mem!("s[2]", s.as_bytes()[2]);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

fn show_params(
    pu: u32,
    pf: f64,
    pt: [u16; 3],
    pv: Vec<u16>,
    ps: String,
) {
    s4::show_mem!("   pu", pu);
    s4::show_mem!("   pf", pf);
    s4::show_mem!("   pt", pt);
    s4::show_mem!("pt[0]", pt[0]);
    s4::show_mem!("pt[1]", pt[1]);
    s4::show_mem!("pt[2]", pt[2]);
    s4::show_mem!("   pv", pv);
    s4::show_mem!("pv[0]", pv[0]);
    s4::show_mem!("pv[1]", pv[1]);
    s4::show_mem!("pv[2]", pv[2]);
    s4::show_mem!("   ps", ps);
    s4::show_mem!("ps[0]", ps.as_bytes()[0]);
    s4::show_mem!("ps[1]", ps.as_bytes()[1]);
    s4::show_mem!("ps[2]", ps.as_bytes()[2]);
}

fn section_5() {
    println!("\n~~~~ chapter 1, section 5 ~~~~");
    let u = 98765_u32;
    let f = 12.34_f64;
    let t = [99_u16, 98, 97];
    let v = vec![88_u16, 87, 86];
    let s = "Short".to_owned();
    s4::show_mem!("    u", u);
    s4::show_mem!("    f", f);
    s4::show_mem!("    t", t);
    s4::show_mem!(" t[0]", t[0]);
    s4::show_mem!(" t[1]", t[1]);
    s4::show_mem!(" t[2]", t[2]);
    s4::show_mem!("    v", v);
    s4::show_mem!(" v[0]", v[0]);
    s4::show_mem!(" v[1]", v[1]);
    s4::show_mem!(" v[2]", v[2]);
    s4::show_mem!("    s", s);
    s4::show_mem!(" s[0]", s.as_bytes()[0]);
    s4::show_mem!(" s[1]", s.as_bytes()[1]);
    s4::show_mem!(" s[2]", s.as_bytes()[2]);
    println!("~~~~~~~~ with .clone()");
    show_params(u, f, t, v.clone(), s.clone());
    println!("~~~~~~~~ without .clone()");
    show_params(u, f, t, v, s);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

À ne consulter qu'après avoir tenté de réaliser un exercice !