# Exemples / DO-DON'T — Chapitre 22 — Collections et itération

> Document compagnon. Les exemples illustrent les règles du chapitre ; la formulation normative reste dans le chapitre lui-même.

## Exemples extraits du chapitre

### Exemple 1

```text
T primitif -> valeur by-value
T struct   -> valeur by-value
T class    -> référence de classe
```

### Exemple 2

```text
Array<int32> values = [1, 2, 3];
Array<int32> empty = [];
```

### Exemple 3

```text
Array<T>::filled(uint64 length, T value)
```

### Exemple 4

```text
User firstUser = ...;
User otherUser = ...;

Array<User> users = Array<User>::filled(3, firstUser);
users[1] = otherUser; // OK si l'accès n'est pas const
```

### Exemple 5

```text
Array<T>::empty()
```

### Exemple 6

```text
StaticArray<int32, 3> values = [10, 20, 30];
StaticArray<int32, 0> empty = [];
```

### Exemple 7

```text
StaticArray<T,N>::filled(T value)
```

### Exemple 8

```text
Array<int32> values = ...;
Slice<int32> part = values::slice(10..<20);

part[0] = 42; // modifie values[10]
```

### Exemple 9

```text
reste attachée à la portion qu'elle désigne
conserve une longueur fixe
n'est pas redimensionnable
n'est pas déplaçable vers une autre portion
peut modifier les éléments uniquement si l'accès source l'autorise
ne peut jamais augmenter les droits de mutabilité de la source
```

### Exemple 10

```text
const Array<User> users = ...;
const Slice<User> part = users::slice(0..<4);

part[0] = otherUser;       // ERROR
part[0]::setName("Alice"); // ERROR
part[0]::getName();        // OK
```

### Exemple 11

```text
Iterable<T>
    ↓
Collection<T>
    ↓
List<T>
    ↓
SettableList<T>
    ↓
ResizableList<T>
```

### Exemple 12

```text
count() -> uint64
isEmpty() -> bool
contains(const T value) -> bool
```

### Exemple 13

```text
ordre stable
indexation positionnelle en lecture
length() -> uint64
```

### Exemple 14

```text
count() == length()
```

### Exemple 15

```text
list[index] = value;
```

### Exemple 16

```text
SettableList<User> users = ...;
const SettableList<User> readonly = users;
```

### Exemple 17

```text
StaticArray<T,N>
    List<T>
    SettableList<T>
    pas ResizableList<T>

Array<T>
    List<T>
    SettableList<T>
    pas ResizableList<T>

Slice<T>
    List<T>
    SettableList<T>
    pas ResizableList<T>

Vector<T>
    List<T>
    SettableList<T>
    ResizableList<T>
```

### Exemple 18

```text
a..b        [a, b]    bornes basse et haute incluses
a>..b       (a, b]    borne basse exclue, borne haute incluse
a..<b       [a, b)    borne basse incluse, borne haute exclue
a>..<b      (a, b)    bornes basse et haute exclues
```

### Exemple 19

```text
Range<uint64> ids = 1..100;
```

### Exemple 20

```text
NaN                  interdit comme borne
+Infinity            interdit comme borne
-Infinity            interdit comme borne
valeur finie         autorisée
```

### Exemple 21

```text
a..a        contient exactement a
a>..a       vide
a..<a       vide
a>..<a      vide
```

### Exemple 22

```text
range::lower()
range::upper()
range::includesLower()
range::includesUpper()
range::isEmpty()
range::contains(value)
```

### Exemple 23

```text
Range<T>                         intervalle ordonné
RangeIterable<T>                 parcours canonique vers l'avant
RangeStep<T,Step>                parcours avant avec pas explicite
RangeReverse<T>                  parcours canonique vers l'arrière
RangeReverseStep<T,Step>         parcours arrière avec pas explicite
RangeProgression<T,Step>         valeur de progression produite
```

### Exemple 24

```text
(range)::step(step)
```

### Exemple 25

```text
RangeStep<int32,int32>
RangeStep<int32,uint32>
RangeStep<char,uint32>
RangeStep<Date,Duration>
```

### Exemple 26

```text
(range)::reverse()
(range)::reverse()::step(step)
```

### Exemple 27

```text
range
    [::reverse()]
    [::step(step)]
```

### Exemple 28

```text
(250u8..255u8)::step(2u8)
```

### Exemple 29

```text
250 252 254
```

### Exemple 30

```text
(1..10)::step(4)
```

### Exemple 31

```text
1 5 9
```

## DO / DON'T / WHY / compiler error / edge cases

À consolider progressivement avant la baseline publique V3 et à transformer, lorsque pertinent, en tests de conformité de la toolchain.