Type aliases — Runique

Guide Complet et Pratique

Pour développeurs Rust intermédiaires

Généré le 28 January 2026

1. Introduction aux Type Aliases

Les type aliases (alias de types) sont un outil puissant en Rust qui permet de créer des noms alternatifs pour des types existants. Contrairement à ce qu'on pourrait penser, ils ne créent pas de nouveaux types, mais simplement des synonymes pour des types existants.

Pourquoi utiliser des type aliases ?

Lisibilité : Simplifier des types complexes ou longs

Maintenabilité : Centraliser les définitions de types

Documentation : Donner un sens métier aux types techniques

Réduction de verbosité : Éviter la répétition de types génériques

Abstraction : Masquer les détails d'implémentation

I Note importante : Les type aliases n'ajoutent AUCUN overhead au runtime. Le compilateur les remplace par le type réel lors de la compilation. C'est du zero-cost abstraction .

2.1 Syntaxe générale

type NomAlias = TypeExistant; // Exemples type UserId = i32; type Username =
String; type Result = std::result::Result;

2.2 Premier exemple concret

// Sans type alias I fn create_user(id: i32, name: String) -> i32 { // ... id } fn get_user(id: i32) -> Option { // ... None } // Avec type alias I type UserId = i32; type Username = String; fn create_user(id: UserId, name: Username) -> UserId { // ... id } fn get_user(id: UserId) -> Option { // ... None }

Dans cet exemple, l'intention du code devient beaucoup plus claire . On comprend immédiatement qu'on manipule un identifiant utilisateur et un nom d'utilisateur, pas juste des entiers et des chaînes génériques.

2.3 Type aliases dans les structures

type Timestamp = i64; type JsonData = serde_json::Value; struct Event { id:
UserId, created_at: Timestamp, data: JsonData, } // Utilisation let event =
Event { id: 42, created_at: 1706400000, data: serde_json::json!({"action":
"login"}), };

3.1 Simplifier les types de retour

// Avant I fn process_data(input: &str;) -> Result>, Box> { // ... } // Après I type ProcessResult = Result>, Box>; fn process_data(input: &str;) -> ProcessResult { // ... } // Encore mieux II type DataMap = HashMap; type ProcessResult = Result, Box>; fn process_data(input: &str;) -> ProcessResult { // ... }

3.2 Types complexes récurrents

// Types de bases de données type DbPool = Arc>; type DbResult = Result; //
Utilisation cohérente async fn get_user(pool: &DbPool;, id: UserId) -> DbResult
{ // ... } async fn create_user(pool: &DbPool;, user: User) -> DbResult<()> { //
... } async fn delete_user(pool: &DbPool;, id: UserId) -> DbResult<()> { // ...
}

II Attention : Trop d'alias peut rendre le code moins lisible. Utilisez-les avec parcimonie et seulement quand ils apportent une vraie valeur ajoutée.

3.3 Abstraire les détails d'implémentation

// Dans votre API publique pub type Cache = HashMap; // Plus tard, vous pouvez
changer l'implémentation // pub type Cache = LruCache; // ou // pub type Cache =
DashMap; // Les utilisateurs de votre API n'ont pas besoin de changer leur code
!

4.1 La différence fondamentale

// Type Alias - PAS un nouveau type type UserId = i32; // Newtype Pattern -
NOUVEAU type struct UserId(i32); // Conséquences : let id1: UserId = 42; // Type
alias - OK let id2: i32 = id1; // OK - même type ! let id3 = UserId(42); //
Newtype - OK let id4: i32 = id3; // ERREUR - types différents ! let id5: i32 =
id3.0; // OK - accès explicite

4.2 Quand utiliser quoi ?

Critère	Type Alias	Newtype
Type-safety	IIFaible	IForte
Runtime overhead	IAucun	IAucun (optimisé)
Méthodes custom	INon	IOui
Traits custom	INon	IOui
Verbosité	IFaible	IIMoyenne
Interopérabilité	ITransparente	IIConversion manuelle

4.3 Recommandations

Type Alias : Pour simplifier la syntaxe sans ajouter de garanties de type supplémentaires

Newtype : Pour créer des types distincts avec validation ou méthodes spécifiques

Exemple Type Alias : Result, collections spécifiques, types de callback

Exemple Newtype : Unités (Meters, Seconds), identifiants validés, types métier

5.1 Alias génériques basiques

// Alias pour Result personnalisé type AppResult = Result; // Utilisation fn
create_user(name: &str;) -> AppResult { // ... } fn delete_user(id: UserId) ->
AppResult<()> { // ... }

5.2 Spécialisation partielle

// Type générique complet type GenericResult = Result; // Spécialisation de
l'erreur type AppResult = Result; // Spécialisation complète type UserResult =
Result; // Hiérarchie de spécialisation type DbResult = Result; type
UserDbResult = DbResult;

5.3 Alias pour types complexes

// Collection de callbacks type EventHandler = Box () + Send + Sync>; type
EventHandlers = Vec>; // State management type StateUpdater = Arc>; type
SharedState = Arc>; // Async futures type AsyncResult = Pin> + Send>>;

I Astuce Pro : Les type aliases génériques sont parfaits pour créer des APIs consistantes dans tout votre codebase. Définissez-les une fois dans un module central.

6.1 Organiser vos aliases

// I Mauvais - dispersé partout mod user { type UserId = i32; // ... } mod product { type ProductId = i32; // ... } // I Bon - centralisé // types.rs ou common_types.rs pub type UserId = i32; pub type ProductId = i32; pub type Timestamp = i64; pub type JsonData = serde_json::Value; // Usage dans les autres modules use crate::types::*;

6.2 Structure recommandée

// src/types/mod.rs pub mod db; pub mod api; pub mod errors; pub use db::*; pub
use api::*; pub use errors::*; // src/types/db.rs pub type DbPool = Arc; pub
type DbResult = Result; // src/types/api.rs pub type ApiResult = Result; pub
type JsonResponse = Json; // src/types/errors.rs pub type AppError = Box; pub
type AppResult = Result;

6.3 Conventions de nommage

Suffixes descriptifs : UserId, UserResult, UserError

Préfixes de module : DbPool, ApiResponse, WebConfig

Contexte métier : OrderId plutôt que Id, Price plutôt que Decimal

Évitez les abréviations : DatabaseConnection, pas DbConn (sauf conventions établies)

PascalCase obligatoire : Suivez les conventions Rust

7.1 Pas de vérification de type supplémentaire

type UserId = i32; type ProductId = i32; fn get_user(id: UserId) -> User { /* ... */ } // II Ceci compile sans erreur ! let product_id: ProductId = 123; let user = get_user(product_id); // BUG silencieux // Solution : Utilisez le Newtype Pattern pour une vraie type-safety struct UserId(i32); struct ProductId(i32); fn get_user(id: UserId) -> User { /* ... */ } let product_id = ProductId(123); // get_user(product_id); // I ERREUR de compilation !

7.2 Messages d'erreur du compilateur

type ComplexType = HashMap, Error>>>; fn process(data: ComplexType) { /* ... */
} // Erreur du compilateur affichera le type COMPLET, pas l'alias ! // expected
`HashMap, Error>>>`, // found `HashMap, Error>>>`

II Limitation : Les messages d'erreur montrent toujours le type réel, pas l'alias. Cela peut rendre les erreurs plus difficiles à comprendre.

7.3 Pas d'implémentation de traits

type UserId = i32; // I Impossible d'implémenter des traits sur un alias impl Display for UserId { // ERREUR fn fmt(&self;, f: &mut; Formatter) -> fmt::Result { write!(f, "User #{}", self) } } // I Solution : Utilisez un Newtype struct UserId(i32); impl Display for UserId { // OK fn fmt(&self;, f: &mut; Formatter) -> fmt::Result { write!(f, "User #{}", self.0) } }

8.1 Types de vue

// runique/src/forms/types.rs use crate::forms::utils::ViewContext; use
crate::forms::fields::*; // Vues de formulaires pub type RegisterView =
ViewContext; pub type LoginView = ViewContext; pub type ContactView =
ViewContext; pub type ProfileView = ViewContext; // Usage dans les handlers pub
async fn register_view(view: RegisterView) -> AppResult { if view.is_get() {
return view.handle_get("register.html"); } // ... }

8.2 Types de base de données

// runique/src/db/types.rs use sea_orm::{DatabaseConnection, DbErr}; use
std::sync::Arc; // Pool de connexions pub type DbPool = Arc; // Résultats de
requêtes pub type DbResult = Result; // Collections courantes pub type UserList
= Vec; pub type UserMap = HashMap; // Usage pub async fn get_users(pool:
&DbPool;) -> DbResult { User::find().all(pool.as_ref()).await }

8.3 Types de contexte

// runique/src/context/types.rs use crate::context::{AppError,
TemplateContext}; use axum::response::Response; // Résultats applicatifs pub
type AppResult = Result; pub type AppResponse = Result; // Context handlers pub
type HandlerResult = AppResult; // Extractors pub type CtxResult = Result;

9.1 Type Aliases conditionnels

// Différents types selon la configuration #[cfg(feature = "async")] pub type
Handler = Box Pin>>>; #[cfg(not(feature = "async"))] pub type Handler = Box ()>;
// Usage identique dans le code fn register_handler(handler: Handler) { // ... }

9.2 Chaînage d'aliases

// Construction progressive type RawData = Vec; type ParsedData = Result; type
ValidatedData = Result; // Chaîne de traitement fn parse(raw: RawData) ->
ParsedData { /* ... */ } fn validate(parsed: ParsedData) -> ValidatedData { /*
... */ }

9.3 Aliases pour traits objets

// Simplifier les trait objects type EventListener = Box; type AsyncHandler =
Box Pin>> + Send>; // Collections de handlers type EventHandlers = Vec; type
Middleware = Vec Response + Send + Sync>>;

I Pattern Pro : Combinez type aliases et génériques pour créer des APIs flexibles et faciles à utiliser. C'est exactement ce que fait la stdlib avec Result, Option, etc.

Exercice 1 : Refactoring basique

Refactorez ce code en utilisant des type aliases appropriés :

// Code à refactorer fn get_user(id: i32, db: &Arc;>) -> Result, Box> { // ... }
fn create_user( name: String, email: String, db: &Arc;> ) -> Result> { // ... }

Exercice 2 : Organisation modulaire

Organisez ces types dans une hiérarchie de modules appropriée :

// Types en vrac type UserId = i32; type ProductId = i32; type OrderId = i32;
type UserResult = Result; type ProductResult = Result; type ApiError = Box; type
JsonPayload = serde_json::Value;

Exercice 3 : Généricité

Créez une hiérarchie de type aliases génériques pour ce système de cache :

// Système de cache à implémenter struct Cache { data: HashMap, } // Créez des
aliases pour : // 1. Un cache de chaînes vers chaînes // 2. Un cache générique
avec erreurs // 3. Un cache asynchrone avec timeout

Solution Exercice 1

// Types centralisés type UserId = i32; type DbPool = Arc>; type AppError = Box;
type AppResult = Result; // Code refactoré fn get_user(id: UserId, db: &DbPool;)
-> AppResult> { // ... } fn create_user(name: String, email: String, db:
&DbPool;) -> AppResult { // ... }

Solution Exercice 2

// src/types/mod.rs pub mod ids; pub mod db; pub mod api; // src/types/ids.rs
pub type UserId = i32; pub type ProductId = i32; pub type OrderId = i32; //
src/types/db.rs use super::ids::*; pub type UserResult = Result; pub type
ProductResult = Result; // src/types/api.rs pub type ApiError = Box; pub type
JsonPayload = serde_json::Value; pub type ApiResult = Result;

Solution Exercice 3

// 1. Cache simple type StringCache = Cache; // 2. Cache avec gestion d'erreur
type CacheResult = Result, CacheError>; // 3. Cache asynchrone type AsyncCache =
Arc>>; type CacheFuture = Pin>>>; // Bonus: Cache avec TTL type TtlCache =
Cache;

Conclusion

Les type aliases sont un outil simple mais puissant en Rust. Utilisés correctement, ils améliorent significativement la lisibilité et la maintenabilité de votre code sans aucun coût au runtime.

Points clés à retenir :

Les type aliases sont des synonymes , pas de nouveaux types

Zero-cost abstraction : aucun overhead au runtime

Excellents pour simplifier les types complexes récurrents

Organisez-les dans des modules dédiés (types.rs)

Utilisez le Newtype Pattern quand vous avez besoin de vraie type-safety

Les messages d'erreur du compilateur montrent le type réel, pas l'alias

Ressources complémentaires

The Rust Book : Chapitre sur les type aliases

Rust by Example : Section sur les types personnalisés

Rust API Guidelines : Conventions de nommage

Documentation Rust std : Exemples dans std::result, std::io