Mon code pour movaicode/4

movaicode_4.rs

// Les warnings c'est claqué, il faut les enlever
#![allow(non_snake_case)]
#![allow(non_camel_case_types)]
#![allow(dead_code)]
#![allow(unused_variables)]
#![allow(unused_macros)]

// Les macros ça génère du code, donc ca veut dire que c'est moins de travail pour moi, je crois

// La fonction principale est spéciale, donc elle a sa propre macro 😎
macro_rules! fonction_principale_de_c_est_la_premiere_qui_s_execute {
    ($code:block) => {
        fn main() {
            $code
        }
    }
}

// Je préfère demander poliment à l'ordinateur d'imprimer quelque chose à l'écran
macro_rules! IMPRIME_A_L_ECRAN_stp {
    ($($arguments:tt)*) => {
        println!($($arguments)*)
    }
}

// On reste toujours poli quand on demande quelque chose
macro_rules! je_veux_renommer_un_type_stp {
    (voici mon nouvo nom: $t1:ident, et la c'est l'ancien: $t2:ty) => {
        type $t1 = $t2;
    }
}

// On demande poliment à l'ordinateur de FAIRE UNE PUTAIN DE FONCTION
macro_rules! fait_moi_une_fonction_stp {
    (
        elle s'apelle $nom:ident,
        elle prend comme arguments $($nom_arg:ident: $type_arg:ty);*,
        puis elle va retourner $retour:ty,
        et enfin y'aura ça à l'intérieur: $code:tt
    ) => {
        fn $nom($($nom_arg: $type_arg),*) -> $retour {
            $code
        }
    }
}

macro_rules! fait_moi_une_variable_stp {
    (je veux la nommer $nom:ident et elle aura comme valeur $val:expr) => {
        let $nom = $val;
    }
}

macro_rules! invoque_cette_fonction_stp {
    (elle s'appelle $nom:ident et je lui donne comme arguments $($arg:expr),*) => {
        $nom($($arg)*);
    }
}

macro_rules! LISTEUH {
    ($($val:expr),*) => {
        vec![$($val),*]
    }
}

macro_rules! le_programme_est_fini {
    () => {
        IMPRIME_A_L_ECRAN_stp!("le programme est se términe 😎");
    }
}

// Parce que le langage rouillé est vraiment attardé, y'a quinze types de chaines de caractères,
// donc voila ca fait chier quoi :'(
macro_rules! vrai_chaine_de_caractere {
    ($str:expr) => {
        String::from($str)
    }
}

macro_rules! BOUCLE_POUR {
    (pour $nom:ident DANS $liste:expr => $code:block) => {
        for $nom in $liste {
            $code
        }
    }
}

macro_rules! BOUCLE_SI {
    (si $condition:expr => $code:block $(SINON SI $cond_sinon_si:expr => $code_sinon_si:block)* $(SInon => $code_sinon:block)*) => {
        if $condition {
            $code
        } $(else if $cond_sinon_si {
            $code_sinon_si
        })* $(else {
            $code_sinon
        })*
    }
}

macro_rules! SONT_EGAUX {
    ($cote_gauche:expr, $cote_droit:expr) => {
        $cote_gauche == $cote_droit
    }
}

macro_rules! LE_NOM_DE_MON_BFF {
    () => {
        vrai_chaine_de_caractere!("Jean-BFF <3")
    }
}

macro_rules! RETOURNE_VRAI {
    () => {
        return true;
    }
}

macro_rules! RETOURNE_FAUX {
    () => {
        return false;
    }
}

macro_rules! RETOUrne {
    ($val:expr) => {
        return $val;
    }
}

// On renomme les types avec un meilleur nom, les noms de base sont vraiment incrompréhensibles
je_veux_renommer_un_type_stp!(voici mon nouvo nom: ChAine_de_CaracTERE, et la c'est l'ancien: String);
je_veux_renommer_un_type_stp!(voici mon nouvo nom: VRAI_OU_FAUX, et la c'est l'ancien: bool);
je_veux_renommer_un_type_stp!(voici mon nouvo nom: super_giga_liste_de_chaines_de_caracTERE, et la c'est l'ancien: Vec<ChAine_de_CaracTERE>);
je_veux_renommer_un_type_stp!(voici mon nouvo nom: RIEN_DU_TOUT, et la c'est l'ancien: ());

fait_moi_une_fonction_stp! {
    elle s'apelle is_there_mon_BFF_dans_ma_classe,
    elle prend comme arguments liste_des_eleves: super_giga_liste_de_chaines_de_caracTERE,
    puis elle va retourner VRAI_OU_FAUX,
    et enfin y'aura ça à l'intérieur: {
        BOUCLE_POUR![
            pour nom_eleve DANS liste_des_eleves => {
                BOUCLE_SI! {
                    si ces_chaines_de_caracteres_sont_pareilles(nom_eleve, LE_NOM_DE_MON_BFF!()) => {
                        RETOURNE_VRAI!(); 
                    }
                }
            }
        ];

        RETOURNE_FAUX!();
    }
}

fait_moi_une_fonction_stp![
    elle s'apelle ces_chaines_de_caracteres_sont_pareilles,
    elle prend comme arguments chaine_une: ChAine_de_CaracTERE; chaine_deux: ChAine_de_CaracTERE,
    puis elle va retourner VRAI_OU_FAUX,
    et enfin y'aura ça à l'intérieur: {
        RETOUrne!(SONT_EGAUX!(chaine_une, chaine_deux))
    }
];

fonction_principale_de_c_est_la_premiere_qui_s_execute![{
    fait_moi_une_variable_stp!(je veux la nommer liste_des_eleves et elle aura comme valeur LISTEUH![
        vrai_chaine_de_caractere!("Bobby"),
        vrai_chaine_de_caractere!("Lucie"),
        vrai_chaine_de_caractere!("Kevin"),
        vrai_chaine_de_caractere!("Maxime"),
        vrai_chaine_de_caractere!("Anne"),
        // vrai_chaine_de_caractere!("Jean-BFF <3"),
        vrai_chaine_de_caractere!("Jacques"),
        vrai_chaine_de_caractere!("Julie")
    ]);
    BOUCLE_SI![
        si invoque_cette_fonction_stp! {
            elle s'appelle is_there_mon_BFF_dans_ma_classe
            et je lui donne comme arguments liste_des_eleves
        } => {
            IMPRIME_A_L_ECRAN_stp!("MON BFF {} EST DANS LA CLASSE <3", LE_NOM_DE_MON_BFF!());
        } SInon => {
            IMPRIME_A_L_ECRAN_stp!("MON BFF {} N'est pas dans la classe :'(((((((", LE_NOM_DE_MON_BFF!());
        }
    ];

    le_programme_est_fini!();
}];