---
title: "Trait Bounds"
description: "Utilisation des trait bounds en Rust pour la sécurité de type et les performances dans les calculs mathématiques"
url: "https://mayorana.ch/fr/blog/trait-bounds-rust"
language: "fr"
date: "2025-10-21"
author: "Mohamed Bennekrouf"
tags:
- "rust"
- "generics"
- "trait-bounds"
- "monomorphization"
- "performance"
en_version: "https://mayorana.ch/en/blog/trait-bounds-rust.md"
---
# Trait Bounds
Dans une bibliothèque Rust sensible aux performances pour les calculs mathématiques, les trait bounds comme `T: Add + Mul` assurent la sécurité de type et maximisent les performances en restreignant les types génériques à ceux qui supportent les opérations requises, permettant un code efficace et spécifique au type via la monomorphization.
dot_product<T: Add+Mul+Default+Copy>
où T::Output = T
Monomorphization
Version f32
fldz / fmul / fadd
inliné, sans appels
Version i32
xor / imul / add
inliné, sans appels
Un seul corps générique, des chemins de code natifs séparés par T — pas de vtable
## Exemple : fonction de produit scalaire
Considère une fonction de produit scalaire pour deux vecteurs, critique dans le traitement du signal ou l'apprentissage automatique :
```rust
use std::ops::{Add, Mul};
fn dot_product(a: &[T], b: &[T]) -> T
where
T: Add + Mul + Default + Copy,
{
assert_eq!(a.len(), b.len());
let mut sum = T::default();
for i in 0..a.len() {
sum = sum + (a[i] * b[i]);
}
sum
}
// Usage
fn main() {
let v1 = vec![1.0, 2.0, 3.0];
let v2 = vec![4.0, 5.0, 6.0];
let result = dot_product(&v1, &v2); // 32.0 (1*4 + 2*5 + 3*6)
println!("{}", result);
}
```
## Application des Trait Bounds
- `T: Add` : S'assure que `T` supporte `+` et retourne `T`, permettant `sum + ...`.
- `T: Mul` : S'assure que `T` supporte `*` et retourne `T`, activant `a[i] * b[i]`.
- `T: Default` : Fournit une valeur de départ similaire à zéro pour `sum`, commune pour les types numériques.
- `T: Copy` : Permet la copie sur la pile des valeurs `T` (ex : `a[i]`), évitant le clonage coûteux ou les références pour les primitives comme `f32`.
Bound
La ligne qu'il rend légale
T: Add<Output = T>
sum = sum + … (reste T)
T: Mul<Output = T>
a[i] * b[i]
T: Default
let mut sum = T::default()
T: Copy
lire a[i] sans move, sans clone
Retire un bound et c'est exactement cette ligne qui ne compile plus — rien n'attend l'exécution
## Assurer la sécurité de type
- **Vérifications pendant la compilation** : Les bounds rejettent les types invalides pendant la compilation. Par exemple :
```rust
let strings = vec!["a", "b"];
dot_product(&strings, &strings); // Erreur : String n'implémente pas Add/Mul
```
Cela prévient les erreurs à l'exécution, crucial pour une bibliothèque où les utilisateurs fournissent des types divers.
- **Exactitude** : `Output = T` s'assure que les opérations s'enchaînent sans incompatibilités de type (ex : pas d'`Option` ou `Result` inattendu).
## Assurer les performances
- **[Dispatch statique](https://mayorana.ch/fr/blog/dispatch-performance-rust)** : Les bounds activent le dispatch statique via les generics. Le compilateur fait la monomorphization de `dot_product` pour chaque `T`, générant du code spécialisé (ex : un pour `f32`, un autre pour `i32`).
- **Inlining** : Les petites opérations comme `+` et `*` (de `Add` et `Mul`) sont inlined, réduisant l'overhead d'appel et activant les optimisations de boucle (ex : unrolling ou [SIMD](https://mayorana.ch/fr/blog/simd-matrix-mult-rust) si `T` est une primitive).
- **Pas d'overhead d'abstraction** : Contrairement à `dyn Trait`, il n'y a pas de vtable—du code machine pur adapté à `T`.
## Impact sur la Monomorphization
La monomorphization duplique la fonction générique pour chaque type concret utilisé :
- **Pour `f32`** :
```asm
; Pseudocode assembleur
fldz ; sum = 0.0
loop:
fld [rsi + rax*4] ; Charge a[i]
fmul [rdi + rax*4]; Multiplie avec b[i]
fadd st(0), st(1) ; Ajoute à sum
inc rax
cmp rax, rcx
jl loop
```
- **Pour `i32`** :
```asm
xor eax, eax ; sum = 0
loop:
mov ebx, [rsi + rcx*4] ; Charge a[i]
imul ebx, [rdi + rcx*4]; Multiplie avec b[i]
add eax, ebx ; Ajoute à sum
inc rcx
cmp rcx, rdx
jl loop
```
**Résultat** : Chaque version utilise des instructions natives pour les opérations de `T`, sans vérifications de type à l'exécution ou indirection.
## Compromis et considérations
- **Taille du code** : La monomorphization augmente la taille du binaire (ex : code séparé pour `f32`, `i32`, `f64`). Dans une bibliothèque avec beaucoup de types ou fonctions, cela pourrait gonfler l'exécutable, potentiellement nuisant à l'efficacité du cache d'instructions.
- **Temps de compilation** : Plus d'instances monomorphisées signifient des builds plus longs, bien que ce soit un coût unique.
- **Atténuation** : Utilise les bounds judicieusement—ex : `T: Copy` évite les références pour les primitives mais exclut les types complexes. Pour un usage plus large, considère `T: Clone` comme alternative, avec un compromis de performance.
## Vérifier le résultat
- **Benchmark** : Utilise `criterion` pour confirmer les performances :
```rust
use criterion::{black_box, Criterion};
fn bench(c: &mut Criterion) {
let v1 = vec![1.0_f32; 1000];
let v2 = vec![2.0_f32; 1000];
c.bench_function("dot_product_f32", |b| b.iter(|| dot_product(black_box(&v1), black_box(&v2))));
}
```
Attends-toi à des temps serrés et cohérents (ex : 1µs) grâce à l'inlining et aux opérations natives.
- **Assembleur** : `cargo rustc --release -- --emit asm` montre des boucles optimisées, pas d'appels.
## Conclusion
Les trait bounds comme `T: Add + Mul + Default + Copy` dans `dot_product` appliquent la sécurité (seulement les types numériques) et les performances (code statique, inlined). La monomorphization transforme cela en code machine spécifique au type, idéal pour une bibliothèque mathématique. Équilibrer ces bounds assure une API flexible mais efficace, avec du profiling pour éviter les coûts cachés.