Simplifier une fonction pour répéter un caractère

Bonjour,

Suite aux conseils d’un ami, je me met doucement au Rust (et j’avoue que c’est un langage agréable). Voici un code qui me permet de dessiner un rectangle et un triangle rectangle dans ma console :

fn main() {
    draw_rectangle(5, 5, '.');
    draw_right_triangle(5, '.')
}

fn draw_rectangle(width: u32, height: u32, pattern: char) {
    for _ in 0..height {
        println!("{}", repeat(pattern, width));
    }
}

fn draw_right_triangle(height: u32, pattern: char) {
    for row in 0..height {
        println!("{}", repeat(pattern, row));
    }
}

fn repeat(pattern: char, times: u32) -> String {
    let mut result = String::new();
    for _ in 0..times {
        result.push(pattern);
        result.push(' ');
    }

    return result;
}

Ce code me parait compliqué pour ce que ça fait. Dans d’autres langages, un simple '.' * 5 aurait suffit pour répéter un caractère mais là je me retrouve à devoir faire une fonction pour faire ça. Est-ce qu’il y aurait quelque chose qui m’aurait échappé ? Ou alors je ferais mieux d’utiliser des String dans mes fonctions directement plutôt que des caractères ?

Merci pour vos conseils !

Merci pour ton aide !

En effet, une solution simple est de passé aux String. Mais imaginons le cas où dans mes définitions de fonctions je dois rester avec des char, comment faire ? La bonne solution est celle que j’ai trouvé ?

EDIT : je ne veux pas que l’utilisateur ai à passer la chaîne de caractères . (avec un espace après). J’ai donc fait cette solution avec les strings :

fn main() {
    draw_rectangle(5, 5, ".");
}

fn draw_rectangle(width: usize, height: usize, pattern: &str) {
    for _ in 0..height {
        println!("{}", format!("{} ", pattern).repeat(width));
    }
}

Mais dans ce cas autant utiliser les char non ? J’ai l’impression que ça complique terriblement le code si je souhaite les utiliser…

EDIT 2 : je n’ai rien dit, la fonction format! accepte également les char !

fn main() {
    draw_rectangle(5, 5, '.');
    draw_right_triangle(5, '.');
}

fn draw_rectangle(width: usize, height: usize, pattern: char) {
    for _ in 0..height {
        println!("{}", format!("{} ", pattern).repeat(width));
    }
}

fn draw_right_triangle(height: usize, pattern: char) {
    for row in 0..height {
        println!("{}", format!("{} ", pattern).repeat(row));
    }
}

Oui les macros format!, println! et consorts fonctionnent avec n’importe quels types de données qui implémentent le trait Display. C’est l’équivalent Rust de surcharger la méthode __str__ en Python, et du coup ça marche avec tous les types primitifs.

Super merci pour cette précision ! Il faut vraiment que j’aborde les traits alors !

Je pense qu’il serait intéressant de calculer format!("{} ", pattern) avant ta boucle, pour éviter de le répéter height fois.

Petit HS, mais pour compléter le message de @nohar, il est à noter que {} utilise le trait Display, quand {:?} utilise le trait Debug (que tu peux dériver sans avoir besoin de fournir une implémentation, de ce que je me souviens).

(c’est dans ces cas là que les commentaires de StackOverflow me manquent)

Rien à dire à part merci ! Je ne savais pas que Rust avait aussi les templates comme en C++ (bon ça ne doit pas être exactement la même chose mais le principe est là ).

C’est un peu l’idée oui.

La différence principale (par rapport à g++ en tout cas) c’est que le compilo te sort des messages d’erreurs concis et explicites quand tu te plantes.

L’autre différence c’est que tu peux aussi (et tu es parfois obligé) utiliser cette syntaxe générique pour donner des informations au compilateur sur la durée de vie des références que ta fonction accepte en paramètres/retourne. Mais tu verras ça en temps et en heure : c’est une des notions de Rust les moins évidentes à piger, mais le book explique ça très bien.