ENIB Rust 05_Sequences - Les conteneurs et les séquences

{} Les tableaux

Les tableaux servent à stocker un nombre fixe et connu à la compilation✍ d'éléments qui sont tous du même type✍.

fn main() {
    let mut a1 = [1.1, 2.2, 3.3, 4.4, 5.5]; // five values
    a1[2] += 90.09; // mutate an element
    println!("a1 contains {} elements: {:?}", a1.len(), a1);
    let mut a2 = [99_u16; 8]; // 8 identical values
    a2[5] *= 100; // mutate an element
    println!("a2 contains {} elements: {:?}", a2.len(), a2);
}
/*
a1 contains 5 elements: [1.1, 2.2, 93.39, 4.4, 5.5]
a2 contains 8 elements: [99, 99, 99, 99, 99, 9900, 99, 99]
*/

Remarquez que, pour le propos de cet exemple, nous avons utilisé l'opération d'indexation ([ ]), ce qui pourrait suggérer que des boucles avec compteur seraient envisageables pour passer en revue le contenu d'un tableau ; c'est effectivement possible, mais il est déconseillé d'exploiter systématiquement l'opération d'indexation✍.
En effet, l'opération d'indexation est sous-optimale dans la mesure où chaque accès nécessite de vérifier si l'indice est bien dans les limites valides de la séquence d'éléments.
Au contraire, les quelques démarches qui sont à la fois optimales et conventionnelles pour parcourir les éléments d'une séquence sont décrites dans cette section et dans celle-ci.

Documents utiles

{} Les tableaux dynamiques (vectors)

Les tableaux dynamiques, communément désignés par le terme vector, correspondent au type std::vec::Vec de la bibliothèque standard de Rust ; ils sont si souvent utiles que le langage les rend directement accessibles par le nom Vec.
Il s'agit de tableaux qui permettent de stocker un nombre variable d'éléments qui sont tous du même type.
Nous pouvons ajouter et retirer des éléments selon nos besoins dans un tel vector qui se charge alors d'allouer dynamiquement la mémoire en conséquence.

fn main() {
    let mut v = Vec::new();
    if v.is_empty() {
        println!("v is initially empty");
    }
    v.push(1.2); // insert ...
    v.push(3.4); // ... some ...
    v.push(5.6); // ... f64 ...
    v.push(7.8); // ... values
    v[2] += 90.09; // mutate an element
    println!("now, v contains {} elements: {:?}", v.len(), v);
    v.remove(1); // v[1] disappears, v[2] and v[3] are moved down
    println!("and then, v contains {} elements: {:?}", v.len(), v);
}
/*
v is initially empty
now, v contains 4 elements: [1.2, 3.4, 95.69, 7.8]
and then, v contains 3 elements: [1.2, 95.69, 7.8]
*/

En toute rigueur, le type exact est

std::vec::Vec<T>

, ou simplement

Vec<T>

, avec T indiquant un type de notre choix.
Nous aurions pu, par exemple, utiliser ici

let mut v: Vec<f64> = Vec::new();

ou encore

let mut v = Vec::<f64>::new();

, mais, puisque le langage permet la déduction automatique des types, il est rare que nous ayons besoin de donner autant de détails.

Vous trouverez certainement dans d'autres exemples l'initialisation de vectors sous une forme qui rappelle l'initialisation des tableaux✍ :

la notation let v = vec![1.2, 3.4, 5.6, 7.8]; fabrique un vector avec les quelques valeurs énumérées explicitement,
la notation let v = vec![1.2; nb_values]; fabrique un vector en répétant un nombre de fois choisi la valeur donnée explicitement.

Cependant, au delà de quelques exemples triviaux, il est rare que des cas réalistes d'utilisation d'un vector aient besoin de cette écriture.

Remarquez que, pour le propos de cet exemple, nous avons utilisé l'opération d'indexation ([ ]), ce qui pourrait suggérer que des boucles avec compteur seraient envisageables pour passer en revue le contenu d'un tableau ; c'est effectivement possible, mais il est déconseillé d'exploiter systématiquement l'opération d'indexation✍.
En effet, l'opération d'indexation est sous-optimale dans la mesure où chaque accès nécessite de vérifier si l'indice est bien dans les limites valides de la séquence d'éléments.
Au contraire, les quelques démarches qui sont à la fois optimales et conventionnelles pour parcourir les éléments d'une séquence sont décrites dans cette section et dans celle-ci.

Les vectors représentent de très loin le moyen le plus courant de mémoriser un nombre variable d'éléments.
Toutefois, il est assez rare que des fonctions attendent comme paramètre un tel type ; en effet, il est très courant que les fonctions attendent des slices afin de ne s'intéresser qu'au contenu d'un vector déjà constitué plutôt qu'à ses potentielles propriétés de redimensionnement.

Documents utiles

{} Les parcours de séquences

Lorsque nous envisageons de parcourir la séquence des éléments contenus dans un tableau ou un vector par exemple✍, la priorité absolue est de déterminer précisément notre intention parmi les trois suivantes✍ :

soit nous souhaitons consommer cette séquence✍
À titre de métaphore, pensez à un cahier qu'on vous a donné.
Vous en arrachez les feuilles une-à-une :
- certaines ne vous intéressent pas et vous les jetez,
- d'autres vous paraissent intéressantes et vous les lisez à haute-voix pour en faire profiter votre entourage,
- plusieurs vous semblent tellement importantes que vous décidez d'y inscrire quelques annotations personnelles et de les conserver dans un classeur.
Quelles que furent vos décisions, ce cahier n'existe plus dorénavant ; il ne subsiste plus que l'effet de vos lectures à haute-voix sur votre entourage et les quelques feuilles consignées dans votre classeur.
,
- nous prenons possession de chaque élément,
- nous pouvons en faire ce que nous voulons (les détruire après usage, les stocker ailleurs...),
- donc la séquence n'existera plus après ce parcours,
ou alors nous souhaitons juste consulter les éléments de cette séquence✍
À titre de métaphore, pensez à un cahier qu'on vous a prêté avec la consigne de ne pas du tout le modifier.
Vous en lisez les feuilles une-à-une :
- éventuellement à haute-voix pour en faire profiter votre entourage,
- en vous gardant bien de les tâcher, de les déchirer ou d'y inscrire quoi que ce soit.
Après ces lectures, ce cahier pourra être rendu à son propriétaire qui le retrouvera dans son état original et pourra continuer à en faire ce que bon lui semblera.
,
- nous accéderons à chaque élément grâce à une référence partagée (non-mutable),
- ni les éléments, ni la séquence elle-même ne seront modifiés,
- donc, après ce parcours, la séquence restera utilisable et identique à son état initial,
ou encore nous souhaitons modifier les éléments de cette séquence✍
À titre de métaphore, pensez à un cahier qu'on vous a prêté avec la consigne de rectifier les éventuelles erreurs.
Vous en corrigez les feuilles une-à-une :
- en lisant éventuellement à haute-voix pour en faire profiter votre entourage,
- en rectifiant et en complétant avec un stylo les quelques phrases qui le méritent,
- en vous gardant bien d'arracher les pages, tout de même.
Après ces corrections, ce cahier pourra être rendu à son propriétaire qui y retrouvera vos annotations et pourra continuer à en faire ce que bon lui semblera.
,
- nous accéderons à chaque élément grâce à une référence exclusive (mutable),
- chaque élément pourra ainsi être librement modifié, mais pas détruit,
- donc, après ce parcours, la séquence restera utilisable, mais chaque élément sera probablement différent de son état initial.

La consommation d'une séquence est provoquée par sa fonction .into_iter().
Il s'agit du cas de parcours le moins fréquent en pratique ; il sert principalement à exploiter des données fournies temporairement✍.

fn main() {
    let prepared = vec![11, 22, 33, 44, 55];
    let mut kept = Vec::new();
    println!("before: prepared={:?}  kept={:?}", prepared, kept);
    for elem in prepared.into_iter() { // .into_iter() ~~> consume
        if elem % 2 == 1 {
            kept.push(elem); // consider only odd integers
        }
    }
    // println!("after: prepared={:?}", prepared); // error, value borrowed here after move
    println!("after: kept={:?}", kept);
}
/*
before: prepared=[11, 22, 33, 44, 55]  kept=[]
after: kept=[11, 33, 55]
*/

La fonction .into_iter() appliquée au vector prepared doit se comprendre comme “turn yourself into an iterator”✍, ce qui explique le fait que prepared ne soit plus utilisable lors de sa dernière tentative d'affichage.

La consultation des éléments d'une séquence est provoquée par sa fonction .iter().
Il s'agit d'un cas de parcours très fréquent en pratique.

fn main() {
    let v = vec![1.1, 2.2, 3.3, 4.4, 5.5];
    println!("before: v={:?}", v);
    let mut square_sum = 0.0;
    for ref_to_elem in v.iter() { // .iter() ~~> iterate as non-mutable
        let value = *ref_to_elem; // consult this element
        square_sum += value * value;
    }
    println!("square_sum={}", square_sum);
    println!("after: v={:?}", v);
}
/*
before: v=[1.1, 2.2, 3.3, 4.4, 5.5]
square_sum=66.55
after: v=[1.1, 2.2, 3.3, 4.4, 5.5]
*/

La modification des éléments d'une séquence est provoquée par sa fonction .iter_mut().
Il s'agit d'un cas de parcours très fréquent en pratique.

fn main() {
    let mut v = vec![1.1, 2.2, 3.3, 4.4, 5.5];
    println!("before: v={:?}", v);
    let mut idx = 0;
    for ref_to_elem in v.iter_mut() { // .iter_mut() ~~> iterate as mutable
        let factor = if idx % 2 == 1 { 0.5 } else { -0.5 };
        idx += 1;
        *ref_to_elem *= factor; // mutate this element
    }
    println!("after: v={:?}", v);
}
/*
before: v=[1.1, 2.2, 3.3, 4.4, 5.5]
after: v=[-0.55, 1.1, -1.65, 2.2, -2.75]
*/

Remarquez qu'ici nous avons dû gérer explicitement un indice permettant alterner le signe du facteur multiplicatif ; une reformulation selon le style fonctionnel facilite largement cette démarche.

fn main() {
    let mut v = vec![1.1, 2.2, 3.3, 4.4, 5.5];
    println!("before: v={:?}", v);
    for (idx, ref_to_elem) in v.iter_mut().enumerate() { // .iter_mut() ~~> iterate as mutable
        let factor = if idx % 2 == 1 { 0.5 } else { -0.5 };
        *ref_to_elem *= factor; // mutate this element
    }
    println!("after: v={:?}", v);
}
/*
before: v=[1.1, 2.2, 3.3, 4.4, 5.5]
after: v=[-0.55, 1.1, -1.65, 2.2, -2.75]
*/

La séquence fournie par .iter_mut() est combinée avec la fonction .enumerate().
Cette dernière réémet des tuples constitués d'un indice auto-incrémenté et de ce qui a été obtenu en entrée ; nous déstructurons chaque tuple afin d'en extraire deux variables distinctes, plus facile à manipuler.

La boucle for est normalement capable d'obtenir automatiquement un itérateur depuis la séquence qu'on lui présente.
Par exemple :

for elem in sequence { ... }

Toutefois, selon les circonstances, il s'agira de l'équivalent de .into_iter(), .iter() ou encore .iter_mut().
Tant que le langage n'est pas très bien maîtrisé, il est plus prudent de faire un usage explicite de ces trois fonctions, afin d'éviter toute confusion.

Documents utiles

{} Le style fonctionnel

Les langages modernes, dont Rust fait partie, encouragent l'emploi d'un style fonctionnel consistant à réaliser des traitements élaborés sur des séquences de données, par composition de traitements élémentaires.
Le lien entre ces traitements élémentaires est assuré par la notion d'itérateur : chaque traitement est une fonction qui consomme ce que produit un itérateur et qui fournit elle-même un itérateur pour alimenter la fonction suivante.
Cette démarche assure une bonne réutilisabilité du code avec une efficacité optimale✍.
Même dans ce cas, la décision d'utiliser .into_iter(), .iter() ou .iter_mut() doit rester la réflexion prioritaire.

Voici une reformulation de l'exemple choisi pour .into_iter() dans cette section✍.

fn main() {
    let prepared = vec![11, 22, 33, 44, 55];
    println!("before: prepared={:?}", prepared);
    let kept = Vec::from_iter(prepared.into_iter().filter(|ref_to_elem| {
        let value = *ref_to_elem; // consult this element
        value % 2 == 1 // consider only odd integers
    }));
    println!("after: kept={:?}", kept);
}
/*
before: prepared=[11, 22, 33, 44, 55]
after: kept=[11, 33, 55]
*/

L'étape de filtrage forme un traitement bien identifiable en tant que tel : il s'agit de la fonction .filter() dont la closure indiquée en paramètre exprime le critère choisi.
La fabrication du vector résultant (Vec::from_iter() exploite directement ce qui est délivré par ce dernier itérateur.

Voici à nouveau une reformulation de l'exemple choisi pour .iter() dans cette section.

fn main() {
    let v = vec![1.1, 2.2, 3.3, 4.4, 5.5];
    println!("before: v={:?}", v);
    let square_sum = v
        .iter()
        .map(|ref_to_elem| {
            let value = *ref_to_elem; // consult this element
            value * value // emit its square
        })
        .sum::<f64>();
    println!("square_sum={}", square_sum);
    println!("after: v={:?}", v);
}
/*
before: v=[1.1, 2.2, 3.3, 4.4, 5.5]
square_sum=66.55
after: v=[1.1, 2.2, 3.3, 4.4, 5.5]
*/

L'étape d'élévation au carré forme un traitement bien identifiable en tant que tel : il s'agit de la fonction .map() dont la closure indiquée en paramètre émet une nouvelle valeur à partir de celle qui est consultée.
La somme résultante est un autre traitement identifiable par .sum().

La combinaison de ces quelques traitements élémentaires nous permet d'exprimer un traitement plus élaboré.
Par exemple, la fonction .zip() combine les éléments d'un itérateur avec ceux d'un second itérateur pour émettre à son tour des paires d'éléments provenant des deux séquences; nous déstructurons chaque tuple afin d'en extraire deux variables distinctes, plus facile à manipuler.

fn main() {
    let mut va = vec![1.1, 2.2, 3.3, 4.4, 5.5];
    let vb = vec![2.5, 0.5, 0.25, 1.25, 0.75];
    println!("before: va={:?}  vb={:?}", va, vb);
    for (ref_to_a, ref_to_b) in va.iter_mut().zip(vb.iter()) {
        // .iter_mut() ~~> iterate va as mutable
        // .iter() ~~> iterate vb as non-mutable
        let a = *ref_to_a;
        let b = *ref_to_b;
        let value = a * b;
        *ref_to_a = value; // mutate this element
    }
    println!("after: va={:?}  vb={:?}", va, vb);
}
/*
before: va=[1.1, 2.2, 3.3, 4.4, 5.5]  vb=[2.5, 0.5, 0.25, 1.25, 0.75]
after: va=[2.75, 1.1, 0.825, 5.5, 4.125]  vb=[2.5, 0.5, 0.25, 1.25, 0.75]
*/

Ici, la fonction .zip() nous a permis de progresser simultanément à travers deux séquences afin d'alimenter la boucle for : l'une de ces séquences autorise la modification de ses éléments, l'autre n'en autorise que la consultation.
Bien entendu, cet itérateur fournissant une séquence de paires d'éléments peut lui-même être complété par d'autres traitements.

fn main() {
    let mut va = vec![1.1, 2.2, 3.3, 4.4, 5.5];
    let vb = vec![2.5, 0.5, 0.25, 1.25, 0.75];
    println!("before: va={:?}  vb={:?}", va, vb);
    let square_sum = va
        .iter_mut() // .iter_mut() ~~> iterate va as mutable
        .zip(vb.iter()) // .iter() ~~> iterate vb as non-mutable
        .map(|(ref_to_a, ref_to_b)| {
            let a = *ref_to_a;
            let b = *ref_to_b;
            let value = a * b;
            *ref_to_a = value; // mutate this element
            value * value // emit its square
        })
        .sum::<f64>();
    println!("square_sum={}", square_sum);
    println!("after: va={:?}  vb={:?}", va, vb);
}
/*
before: va=[1.1, 2.2, 3.3, 4.4, 5.5]  vb=[2.5, 0.5, 0.25, 1.25, 0.75]
square_sum=56.71875
after: va=[2.75, 1.1, 0.825, 5.5, 4.125]  vb=[2.5, 0.5, 0.25, 1.25, 0.75]
*/

Ici, la fonction .map() faisant suite à .zip() nous a permis d'exploiter les paires d'éléments✍ comme dans la boucle for précédente, mais également d'émettre une nouvelle séquence de valeurs alimentant l'étape .sum().

Au delà de ces quelques exemples, il existe bien entendu une très grande variété d'opérations sur les itérateurs ; en voici, par exemple, de très utiles✍ :

.rev() transforme un itérateur en un autre fournissant les mêmes éléments mais dans l'ordre inverse✍,

.chain() permet d'enchaîner deux séquences d'éléments comme s'il n'en s'agissait que d'une seule✍,

.filter_map() est la combinaison de .filter() et .map(), en utilisant une unique closure afin de ne retenir que certains éléments qui sont transformés à la volée✍,

.min() (respectivement .max()) recherche le plus petit (respectivement le plus grand) élément en les comparant directement✍,

.min_by_key() (respectivement .max_by_key()) recherche le plus petit (respectivement le plus grand) élément en comparant les résultats indiqués par une closure✍,

.fold() combine tous les éléments d'une séquence pour obtenir une unique valeur, selon l'opération indiquée par une closure✍,

.all() (respectivement .any()) indique si tous les (respectivement au moins un des) éléments vérifient une propriété indiquée par une closure✍.

Certaines autres opérations tout aussi utiles ont pour propos la recherche d'éléments dans une séquence.

Documents utiles

{} La recherche dans les séquences

La fonction .find() fournit, depuis une séquence désignée par un itérateur, le premier élément pour lequel la closure transmise renvoie un résultat booléen “vrai”.

fn main() {
    let v = vec![11, 22, 33, 44, 55, 66];
    let optional_ref_to_found = v.iter().find(|ref_to_ref_to_elem| {
        // test if this element is a multiple of three
        **ref_to_ref_to_elem % 3 == 0
    });
    if let Some(ref_to_found) = optional_ref_to_found {
        println!("found a multiple of three: {}", *ref_to_found);
    }
}
/*
found a multiple of three: 33
*/

Bien entendu, puisqu'il s'agit d'une recherche, celle-ci peut échouer ; le résultat attendu est alors une Option.
Dans cet exemple, nous parcourons le vector avec .iter(), ce qui implique qu'en cas de succès nous obtenons une référence partagée (non-mutable) vers l'élément du vector qui a été trouvé ; nous ne pouvons alors que consulter cet élément (nous ne pouvons pas le modifier).
Remarquez que la closure reçoit ici une seconde référence qui désigne une première référence vers un élément du vector✍ ; cela nous oblige à effectuer deux opérations de déréférencement (**) pour accéder à la valeur de l'élément visité.

Si nous souhaitons maintenant avoir la possibilité de modifier l'élément trouvé, la même démarche s'applique en parcourant le vector avec .iter_mut().

fn main() {
    let mut v = vec![11, 22, 33, 44, 55, 66];
    println!("before: v={:?}", v);
    let optional_ref_to_found = v.iter_mut().find(|ref_to_ref_to_elem| {
        // test if this element is a multiple of three
        **ref_to_ref_to_elem % 3 == 0
    });
    if let Some(ref_to_found) = optional_ref_to_found {
        *ref_to_found += 9900; // mutate the multiple of three
    }
    println!("after: v={:?}", v);
}
/*
before: v=[11, 22, 33, 44, 55, 66]
after: v=[11, 22, 9933, 44, 55, 66]
*/

En cas de succès, nous obtenons une référence exclusive (mutable) vers l'élément du vector qui a été trouvé ; nous pouvons alors le modifier à notre convenance.

La fonction .position() offre la facilité de s'affranchir des deux niveaux de référence imbriqués vus précédemment.

fn main() {
    let mut v = vec![11, 22, 33, 44, 55, 66];
    println!("before: v={:?}", v);
    let optional_idx = v.iter().position(|ref_to_elem| {
        // test if this element is a multiple of three
        *ref_to_elem % 3 == 0
    });
    if let Some(idx) = optional_idx {
        println!("changing multiple of three at index {}", idx);
        v[idx] += 9900;
    }
    println!("after: v={:?}", v);
}
/*
before: v=[11, 22, 33, 44, 55, 66]
changing multiple of three at index 2
after: v=[11, 22, 9933, 44, 55, 66]
*/

Remarquez que, dans cette solution, nous utilisons .iter() (seule la consultation des éléments est possible) pour la recherche et ce n'est qu'en cas de succès que nous décidons d'un nouvel accès au vector avec l'intention de le modifier à l'indice déterminé.
Cela est légèrement sous-optimal puisque l'opération d'indexation [ ] vérifie si l'indice utilisé est bien dans les limites valides du vector alors que la fonction .position() nous a nécessairement fourni un indice valide au moment où nous le demandions.

Documents utiles

{} Les slices

Les tableaux et les vectors ont en commun le fait de mémoriser une séquence d'éléments de même type qui sont stockés de façon contiguë dans la mémoire.
La plupart du temps, les traitements concernent une séquence d'éléments déjà constituée ; le fait qu'un vector utilise de la mémoire allouée dynamiquement (le tas, the heap) pour offrir la possibilité d'une évolution du nombre d'éléments n'est généralement pas du tout pris en compte par un tel traitement (le nombre d'éléments traités n'évolue pas au cours du traitement en question).
Il serait alors dommage d'avoir à écrire, comme ci-dessous, en plusieurs exemplaires des traitements identiques selon qu'on souhaite les appliquer aux données préparées dans un tableau (de quelle taille, d'ailleurs ?) ou dans un vector.

fn array_of_six_magnitude(elements: &[f64; 6]) -> f64 {
    elements.iter().map(|e| *e * *e).sum::<f64>().sqrt()
}

fn vector_magnitude(elements: &Vec<f64>) -> f64 {
    elements.iter().map(|e| *e * *e).sum::<f64>().sqrt()
}

fn slice_magnitude(elements: &[f64]) -> f64 {
    elements.iter().map(|e| *e * *e).sum::<f64>().sqrt()
}

fn slice_normalise(elements: &mut [f64]) {
    let factor = 1.0 / slice_magnitude(elements);
    for e in elements.iter_mut() {
        *e *= factor;
    }
}

fn main() {
    let mut a = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6];
    let m1 = array_of_six_magnitude(&a);
    // let m2 = vector_magnitude(&a);       // error, expected struct `Vec`, found array `[f64; 6]`
    let m3 = slice_magnitude(&a);
    slice_normalise(&mut a);
    println!("a: {} {} ~~> {}", m1, m3, slice_magnitude(&a));
    //
    let mut v = vec![1.1, 2.2, 3.3, 4.4, 5.5, 6.6];
    // let m4 = array_of_six_magnitude(&v); // error, expected array `[f64; 6]`, found struct `Vec`
    let m5 = vector_magnitude(&v);
    let m6 = slice_magnitude(v.as_slice());
    slice_normalise(v.as_mut_slice());
    println!("v: {} {} ~~> {}", m5, m6, slice_magnitude(v.as_slice()));
}
/*
a: 10.493331215586402 10.493331215586402 ~~> 1
v: 10.493331215586402 10.493331215586402 ~~> 1
*/

Les trois premières fonctions de cet exemple réalisent un calcul identique✍ :

la première attend précisément une référence partagée (non-mutable) vers un tableau de six réels,
la deuxième attend précisément une référence partagée (non-mutable) vers un vector de réels,
la troisième attend une slice désignant un nombre variable des réels stockés de façon contiguë dans la mémoire,
- l'écriture semble proche de celle d'une référence vers un tableau mais nous ne précisons pas le nombre d'éléments.

Bien entendu, à l'appel de ces fonctions nous ne pouvons pas utiliser une référence vers un tableau là où une référence vers un vector est attendue et réciproquement (voir les erreurs au niveau des variables m2 et m4).
En revanche, la fonction qui attend une slice fonctionne tout aussi bien dans les deux cas✍ !
Les deux premières fonctions sont alors complètement inutiles puisque la troisième convient parfaitement à tous les cas.
La slice utilisée ici se comporte comme une référence partagée (non-mutable) ; le même raisonnement s'applique dans la quatrième fonction pour avoir recours à une slice se comportant comme une référence exclusive (mutable)✍.

Il est important de comprendre que les slices, qu'elles soient partagées (non-mutables) ou exclusives (mutables), ne possèdent pas les données auxquelles elles donnent accès (tout comme les références)✍.
Elles se contentent de mémoriser un emplacement dans la mémoire où se trouvent des données possédées par une autre variable (un tableau ou un vector par exemple) ainsi que le nombre de ces données.
La garantie de la disposition contiguë de ces données en mémoire assure une efficacité optimale des traitements.
Étant données leur efficacité et la variété d'usages qu'elles offrent✍, en pratique, et notamment dans la bibliothèque standard, les slices sont énormément utilisées comme paramètres de fonctions✍.

Puisque les slices ne possèdent pas les données auxquelles elles donnent accès, elles peuvent se contenter de ne désigner qu'un sous-ensemble de ces données.

fn main() {
    let mut v = Vec::from_iter(0..12);
    println!("before: v={:?}", v);
    let s1 = &mut v[2..10];     // s1 is a sub-slice of v
    for elem in s1.iter_mut() { // work on slice s1
        *elem += 900;
    }
    println!("s1={:?}", s1);
    let s2 = &mut s1[2..6];     // s2 is a sub-slice of s1
    for elem in s2.iter_mut() { // work on slice s2
        *elem += 8000;
    }
    println!("s2={:?}", s2);
    println!("after: v={:?}", v);
}
/*
before: v=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
s1=[902, 903, 904, 905, 906, 907, 908, 909]
s2=[8904, 8905, 8906, 8907]
after: v=[0, 1, 902, 903, 8904, 8905, 8906, 8907, 908, 909, 10, 11]
*/

Les traitements sur les slices s1 et s2 ignorent tout de l'origine des données manipulées.
À la fin nous constatons que l'effet a bien eu lieu sur des sous-ensembles des données d'origine.

Documents utiles

{} Les chaînes de caractères

Une chaîne de caractères, comme le nom le suggère, correspond bien à l'énumération d'une séquence de caractères pour produire des mots, des phrases...

La problématique de l'encodage

Une vision simplifiée de cette problématique consiste à considérer qu'un byte (un octet, un entier de huit bits) suffit à décrire un caractère reconnaissable par un être humain✍ ; un exemple très courant repose sur l'encodage ASCII dans lequel seulement sept bits de chaque byte décrivent de manière standardisée le caractère souhaité✍.

Toutefois, s'il s'agit d'exprimer tous les caractères possibles qui puissent décrire du texte dans des cultures très diverses, la solution précédente n'est pas suffisante.
Unicode décrit une très grande variété de caractères, pour des cultures et des usages très variés : chacun est désigné par un code numérique dépassant les limites d'un byte (un entier de 32 bits suffit largement).
La solution consistant à décrire une chaîne de caractères comme une séquence de codes Unicode est envisageable✍, mais elle est largement sous-optimale en termes d'espace de stockage.
En effet, la plupart des textes courants dans une très grande variété de cultures (principalement occidentales, convenons-en) contiennent surtout des caractères déjà présents dans l'encodage ASCII et seulement quelques autres caractères (accentués, graphiques, mathématiques...).
Utiliser systématiquement un entier de 32 bits là où un byte suffirait revient quasiment à multiplier par quatre l'espace de stockage en mémoire pour le texte en question.

L'encodage UTF-8 est un compromis très largement répandu✍ : il représente un caractère par une séquence de un à quatre bytes selon la valeur de son code Unicode.
Les caractères les plus fréquents (ceux de l'encodage ASCII) ont en Unicode une valeur faible tenant sur un seul byte ; les caractères moins fréquents (accentués, graphiques, mathématiques...) peuvent nécessiter quant à eux de deux à quatre bytes.
L'espace de stockage en mémoire requis par un texte conventionnel est alors à peine plus grand que si l'on se contentait de l'encodage ASCII, mais nous bénéficions dorénavant de caractères bien plus diversifiés s'il le faut.

L'éventuel inconvénient de l'encodage UTF-8 vient du fait qu'un texte doit nécessairement être parcouru à partir de son début pour accéder à un caractère quelconque qu'il contient.
Cela est dû au fait que chaque caractère a potentiellement une longueur variable en nombre de bytes et qu'il n'est pas possible de la prévoir sans l'analyser : comment accéder directement au N^ième caractère alors ?
En pratique, cet inconvénient n'en est pas un puisqu'il est difficile de trouver un cas d'usage réaliste dans lequel il serait nécessaire de s'intéresser à un caractère particulier au sein d'un texte mais pas aux autres : au delà de quelques exemples complètement artificiels à vocation pédagogique, nous exploitons généralement un texte dans sa globalité.

Le langage Rust considère par défaut que le texte est encodé en UTF-8.
Cet exemple s'intéresse à la représentation de deux textes très proches : l'un contient un caractère accentué, l'autre non.

fn main() {
    for txt in ["sur", "sûr"] {
        println!("text {:?} has length {}", txt, txt.len());
        print!("  chars:");
        for c in txt.chars() {
            print!(" {:?}", c);
        }
        println!();
        print!("  bytes:");
        for b in txt.as_bytes().iter() {
            print!(" {}", b);
        }
        println!();
    }
}
/*
text "sur" has length 3
  chars: 's' 'u' 'r'
  bytes: 115 117 114
text "sûr" has length 4
  chars: 's' 'û' 'r'
  bytes: 115 195 187 114
*/

Remarquez que l'information de longueur indique le nombre de bytes (octets, entiers de huit bits, u8) nécessaires au stockage du texte et non au nombre de caractères qu'un être humain reconnaît✍.
Si nous souhaitons nous intéresser à chaque caractère individuellement, nous n'avons pas d'autre solution que de réclamer avec la fonction .chars() un itérateur qui nous les fournira un-à-un depuis le début du texte.

L'exemple précédent ne s'intéresse qu'à des chaînes littérales (exprimées entre guillemets " ").
Les séquences de bytes qui constituent ces chaînes littérales sont stockées une fois pour toutes dans une zone mémoire non modifiable qui existe pendant toute la durée d'exécution du programme.
Une telle chaîne littérale a le type
&str
, qui est habituellement nommé string-slice : il s'agit bien d'une slice mais qui fait référence à une séquence contiguë de bytes stockés quelque part.
Toutefois, il ne s'agit pas d'une quelconque slice

&[u8]

car les bytes qui la constituent doivent nécessairement former une séquence de caractères UTF-8 valide✍.

Les chaînes littérales ne peuvent pas changer de contenu mais il est possible de créer d'autres chaînes dont le contenu évoluera à notre guise✍ grâce au type std::string::String de la bibliothèque standard de Rust ; il est si souvent utile que le langage le rend directement accessibles par le nom String.
Le type String est, dans une certaine mesure, aux string-slices ce que les vectors sont au slices : une String possède un séquence de bytes, allouée dynamiquement, qu'elle peut redimensionner selon les besoins et qui peut être désignée par une string-slice.

fn count_chars(txt: &str) -> usize {
    txt.chars().count()
}

fn count_letters(txt: &str) -> usize {
    txt.chars().filter(|c| c.is_alphabetic()).count()
}

fn append_sentence(
    txt: &mut String,
    sentence: &str,
    max_width: usize,
) {
    if let Some(last_line) = txt.split('\n').last() {
        if !last_line.is_empty() {
            let new_width = count_chars(last_line) + count_chars(sentence);
            let separator = if new_width < max_width { ' ' } else { '\n' };
            txt.push(separator); // append suitable separator if needed
        }
    }
    txt.push_str(sentence); // append sentence in any case
}

fn main() {
    let mut my_text = "Êtes-vous sûrs d'avoir bien étudié ?".to_owned();
    let chars = count_chars(my_text.as_str());
    let letters = count_letters(my_text.as_str());
    let str1 = format!("The initial content was {} characters long", chars);
    let str2 = format!("but had only {} letters", letters);
    let max_width = 70;
    append_sentence(&mut my_text, &str1, max_width);
    append_sentence(&mut my_text, &str2, max_width);
    println!("{}{}", "~".repeat(max_width), max_width);
    println!("{}", my_text);
}
/*
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~70
Êtes-vous sûrs d'avoir bien étudié ?
The initial content was 36 characters long but had only 28 letters
*/

Remarquez que la création d'une String peut se faire à partir de la fonction .to_owned()✍ appliquée à une chaîne littérale✍ ; par ailleurs, la composition d'une String par la macro format!() suit le même formalisme que l'affichage.
Remarquez également que 28 lettres ont bien été dénombrées dans le texte choisi initialement pour l'exemple ; les caractères accentués sont bien compris comme tels, conformément à UTF-8.
Les deux premières fonctions, qui sont très similaires✍, attendent en paramètre une string-slice et non une référence partagée (non-mutable) vers une String ; en effet, ces fonctions ne s'intéressent qu'au texte déjà constitué plutôt qu'à ses potentielles propriétés de redimensionnement✍.
En revanche, la troisième fonction a vocation à modifier la String en complétant son contenu✍ ; nous avons alors toutes les raisons de transmettre une référence exclusive (mutable) vers la String à compléter.

Documents utiles