Type aliases

type Nom = TypeExistant;

type Kilometres = f64;
type Octets = Vec<u8>;
type Grille = [[u8; 9]; 9];
type Rappel = fn(i32) -> i32;

Le nom suit la convention des types : PascalCase. Un alias peut être pub, pub(crate) ou privé, comme tout élément.

type Kilometres = f64;

fn distance(a: Kilometres, b: Kilometres) -> Kilometres {
    (a - b).abs()
}

let trajet: Kilometres = 42.0;
let d = distance(trajet, 10.0);

use std::collections::HashMap;

type Scores = HashMap<String, u32>;

struct Partie {
    scores: Scores,
}

impl Partie {
    fn new() -> Self {
        Self { scores: Scores::new() }     // les fonctions associées passent par l'alias
    }
}

type Metres = f64;
type Secondes = f64;

fn vitesse(d: Metres, t: Secondes) -> f64 {
    d / t
}

let d: Metres = 100.0;
let t: Secondes = 9.58;
vitesse(t, d);              // compile : les arguments sont inversés, aucune erreur

use std::collections::HashMap;
use std::sync::{Arc, Mutex};

type Partage<T> = Arc<Mutex<T>>;
type Index<V> = HashMap<String, V>;

let compteur: Partage<u32> = Arc::new(Mutex::new(0));
let villes: Index<u32> = Index::new();

use std::collections::HashMap;

type Table<K, V> = HashMap<K, V>;
type TableTexte<V> = Table<String, V>;        // K fixé
type TableComptes = TableTexte<u64>;           // K et V fixés

Chaque niveau fixe un paramètre de plus : on part d'un alias générique et on le spécialise.

// type Affichable<T: std::fmt::Display> = Vec<T>;
// avertissement : bounds on generic parameters are not enforced in type aliases

Une contrainte dans un alias est ignorée (le compilateur avertit). On la met sur les fonctions et les impl qui utilisent le type.

#[derive(Debug)]
pub enum Erreur {
    Introuvable,
    Base(String),
}

pub type Result<T> = std::result::Result<T, Erreur>;

pub fn charger(id: u32) -> Result<String> {
    if id == 0 {
        return Err(Erreur::Introuvable);
    }
    Ok("Ada".into())
}

La bibliothèque standard fait de même : std::io::Result<T>, std::fmt::Result. SeaORM, anyhow (anyhow::Result<T>) et Runique (AppResult<T>) aussi.

use std::io;

type Result<T> = std::result::Result<T, io::Error>;

// fn analyser(s: &str) -> Result<i32, std::num::ParseIntError> { ... }
// ERREUR : ce Result-là n'a qu'un paramètre
fn analyser(s: &str) -> std::result::Result<i32, std::num::ParseIntError> {
    s.parse()
}

Un alias nommé Result masque celui du prélude dans tout le module. Deux façons d'éviter la confusion :

// 1. Lui donner un nom distinct
type IoResult<T> = std::result::Result<T, std::io::Error>;

// 2. L'utiliser préfixé depuis un autre module : io::Result<T>, ma_lib::Result<T>

pub type Resultat<T, E = Erreur> = std::result::Result<T, E>;

fn a() -> Resultat<u32> { Ok(1) }                         // E = Erreur
fn b() -> Resultat<u32, String> { Err("autre".into()) }   // E choisi

use std::future::Future;
use std::pin::Pin;

type Ecouteur = Box<dyn Fn(&str) + Send + Sync>;
type FuturEnvoyable<T> = Pin<Box<dyn Future<Output = T> + Send>>;
type GestionnaireAsync = Box<dyn Fn(String) -> FuturEnvoyable<String> + Send + Sync>;

struct Bus {
    ecouteurs: Vec<Ecouteur>,
}

Sans alias, Vec<Box<dyn Fn(&str) + Send + Sync>> revient dans chaque signature.

type Operation = fn(f64, f64) -> f64;

fn appliquer(op: Operation, a: f64, b: f64) -> f64 {
    op(a, b)
}

let table: [(&str, Operation); 2] = [("+", |a, b| a + b), ("*", |a, b| a * b)];

use std::collections::HashMap;
use std::sync::{Arc, RwLock};

type Cache = Arc<RwLock<HashMap<String, Vec<u8>>>>;

fn lire(cache: &Cache, cle: &str) -> Option<Vec<u8>> {
    cache.read().unwrap().get(cle).cloned()
}

type Note = Option<u8>;

let a: Note = Note::Some(15);       // les variantes passent par l'alias
let b = Note::None;

#[cfg(feature = "grands-nombres")]
pub type Entier = i64;

#[cfg(not(feature = "grands-nombres"))]
pub type Entier = i32;

pub fn doubler(x: Entier) -> Entier { x * 2 }

#[cfg(unix)]
pub type Descripteur = std::os::unix::io::RawFd;      // i32
#[cfg(windows)]
pub type Descripteur = std::os::windows::io::RawHandle;

// 1. Alias : un synonyme
type IdUtilisateur = u32;

// 2. Newtype : un nouveau type
struct IdCommande(u32);

// 3. Renommage à l'import : un autre nom pour un élément existant
use std::collections::HashMap as Table;

// Alias : rien n'empêche l'erreur
type Euros = i64;
type Centimes = i64;
fn payer(montant: Centimes) {}
let prix: Euros = 12;
payer(prix);                              // compile : bug (12 centimes au lieu de 12 euros)

// Newtype : l'erreur devient une erreur de compilation
struct EnEuros(i64);
struct EnCentimes(i64);
impl From<EnEuros> for EnCentimes {
    fn from(e: EnEuros) -> Self { EnCentimes(e.0 * 100) }
}
fn payer2(montant: EnCentimes) {}
// payer2(EnEuros(12));                   // ERREUR : expected EnCentimes
payer2(EnEuros(12).into());               // conversion explicite

struct Point(i32, i32);
type P = Point;

// let p = P(1, 2);               // ERREUR E0423 : l'alias n'existe que comme type
let p = Point(1, 2);
let q: P = Point(3, 4);
let r = P { 0: 5, 1: 6 };         // la forme avec accolades passe par l'alias

Pour une struct à champs nommés, P { x, y } fonctionne.

type Liste = Vec<i32>;

// impl std::fmt::Display for Liste { ... }
// ERREUR E0117 : Display et Vec viennent de la bibliothèque standard (règle de l'orphelin)

L'alias est Vec<i32> : l'implémentation viserait Vec<i32>, ce que seule la bibliothèque standard peut faire. Un newtype (struct Liste(Vec<i32>)) le permet.

À l'inverse, sur un alias d'un type local, impl fonctionne normalement, puisqu'il vise le type local.

// src/types.rs
use std::collections::HashMap;
use std::sync::Arc;

pub type StrMap = HashMap<String, String>;
pub type Partage<T> = Arc<T>;
pub type Result<T> = std::result::Result<T, crate::Erreur>;

// src/lib.rs
pub mod types;
pub use types::*;          // ou via un prelude

// runique/src/utils/config/pk.rs
#[cfg(all(feature = "big-pk", feature = "pk-uuid"))]
compile_error!("features `big-pk` and `pk-uuid` are mutually exclusive — enable at most one of them");

#[cfg(feature = "pk-uuid")]
pub type Pk = uuid::Uuid;

#[cfg(all(feature = "big-pk", not(feature = "pk-uuid")))]
pub type Pk = i64;

#[cfg(not(any(feature = "big-pk", feature = "pk-uuid")))]
pub type Pk = i32;

Tout le framework écrit Pk. Changer de type de clé primaire, c'est changer une feature dans Cargo.toml, pas des centaines de signatures. Le compile_error! empêche d'activer deux choix contradictoires.

// runique/src/db/adb.rs
#[cfg(not(feature = "test-utils"))]
type Inner = sea_orm::DatabaseConnection;
#[cfg(feature = "test-utils")]
type Inner = crate::db::RuniqueDb;      // connexion réelle ou transaction de test

#[derive(Clone, Debug)]
pub struct ADb(Arc<Inner>);

L'alias est privé : l'utilisateur ne voit que ADb, quelle que soit la feature.

// runique/src/utils/aliases/definition.rs
pub type AEngine = Arc<RuniqueEngine>;
pub type StrMap = HashMap<String, String>;
pub type StrVecMap = HashMap<String, Vec<String>>;
pub type JsonMap = HashMap<String, serde_json::Value>;
pub type AppResult<T> = Result<T, Box<AppError>>;

// Dans un handler
pub async fn contact(mut request: Request) -> AppResult<Response> {
    // ...
}

// runique/src/app/builder/mod.rs
pub mod state {
    pub struct No;
    pub struct Yes;
    pub type Fresh = (No, No, No, No, No, No, No);
}

Le builder de Runique note dans son type quels réglages uniques ont déjà été faits (No ou Yes par réglage). Fresh nomme l'état de départ : sans l'alias, il faudrait écrire le tuple de sept No dans chaque signature qui en parle.