Justine le 3 novembre 2022 à 09:19

2022-11-03T09:19:57Z

← Version précédente		Version du 3 novembre 2022 à 09:19
Ligne 1 :		Ligne 1 :
	lib.rs		lib.rs
	<~~nowiki~~>		<syntaxhighlight lang='rust'>
	//J'ai créé une librairie avec cargo new malib --lib		//J'ai créé une librairie avec cargo new malib --lib
	//Je suis ici dans la crate (la crate, c'est ce fichier !)		//Je suis ici dans la crate (la crate, c'est ce fichier !)
Ligne 152 :		Ligne 152 :


	</~~nowiki~~>		</syntaxhighlight>

	front_of_house.rs		front_of_house.rs
	<~~nowiki~~>		<syntaxhighlight lang='rust'>
	//Je rend le module public pour pouvoir l'appeller dans eat_at_restaurant()		//Je rend le module public pour pouvoir l'appeller dans eat_at_restaurant()
	pub mod hosting {		pub mod hosting {
Ligne 173 :		Ligne 173 :
	}		}

	</~~nowiki~~>		</syntaxhighlight>

Justine : Page créée avec « lib.rs //J'ai créé une librairie avec cargo new malib --lib //Je suis ici dans la crate (la crate, c'est ce fichier !) //Je pourrais avoir deux crate dans le même package (un main.rs et un lib.rs) // //ici j'ai plusieurs modules, certains sont imbriqués. Ils sont privés par défaut //Un parent ne peut pas utiliser ses enfants privés, mais l'inverse est vrai. // //Les règles sont les suivantes: //* Une fonction/module peut toujours appeller ses so... »

2022-11-03T09:14:59Z

Page créée avec « lib.rs <nowiki> //J'ai créé une librairie avec cargo new malib --lib //Je suis ici dans la crate (la crate, c'est ce fichier !) //Je pourrais avoir deux crate dans le même package (un main.rs et un lib.rs) // //ici j'ai plusieurs modules, certains sont imbriqués. Ils sont privés par défaut //Un parent ne peut pas utiliser ses enfants privés, mais l'inverse est vrai. // //Les règles sont les suivantes: //* Une fonction/module peut toujours appeller ses so... »

Nouvelle page

lib.rs
<nowiki>
//J'ai créé une librairie avec cargo new malib --lib
//Je suis ici dans la crate (la crate, c'est ce fichier !)
//Je pourrais avoir deux crate dans le même package (un main.rs et un lib.rs)
//
//ici j'ai plusieurs modules, certains sont imbriqués. Ils sont privés par défaut
//Un parent ne peut pas utiliser ses enfants privés, mais l'inverse est vrai.
//
//Les règles sont les suivantes:
//* Une fonction/module peut toujours appeller ses soeurs
//* Pour appeller les enfants de ses soeurs, ceux-ci doivent être publics
//* On peut appeller un module ou une fonction marquée publique, si on a accès à son parent
//
//Le module suivant est dans un fichier à part;
//J'appelle son mod uniquement ici, je n'ai pas besoin de le remettre dans le deuxième fichier
//qui s'appelle front_of_house.rs
mod front_of_house;
pub use crate::front_of_house::hosting;

//Je vais créer ma fonction publique, qui elle sera accessible de l'extérieur
//eat_at_restaurant et front_of_house sont siblings, je peux donc appeller l'un
//depuis l'autre
pub fn get_seated() {
//Je peux appeller une fonction dans la même crate par un chemin absolu...
//crate est un mot-clef
crate::front_of_house::hosting::add_to_waitlist();

//...ou relatif
front_of_house::hosting::add_to_waitlist();
}

fn deliver_order() {}

mod back_of_house {
fn fix_incorrect_order() {
cook_order();
//Ici, le mot-clef super permet d'appeller quelque chose dans le parent
//Un peu comme utiliser .. dans un système de fichiers
super::deliver_order();
}

fn cook_order() {}

//On peut aussi rendre un struct ou un enum public
//Pour un struct, ses éléments restent privés par défaut
pub struct Breakfast {
pub toast: String,
//seasonal_fruit est privé
seasonal_fruit: String,
}

impl Breakfast {
//Ici, j'ai une méthode publique pour construire mon objet
//et le renvoyer
pub fn summer(toast: &str) -> Breakfast {
Breakfast {
toast: String::from(toast),
seasonal_fruit: String::from("peaches"),
}
}
}

//Les éléments d'un enum public sont publics
//par défaut
pub enum Appetizer {
Soup,
Salad,
}
}

pub fn eat_at_restaurant() {
// Order a breakfast in the summer with Rye toast
let mut meal = back_of_house::Breakfast::summer("Rye");
// Change our mind about what bread we'd like
meal.toast = String::from("Wheat");
println!("I'd like {} toast please", meal.toast);

// The next line won't compile if we uncomment it; we're not allowed
// to see or modify the seasonal fruit that comes with the meal
// meal.seasonal_fruit = String::from("blueberries");
//
//Calling my public enum:
//back_of_house is a sibling so I can access it
//the enum itself is public so no issues
let order1 = back_of_house::Appetizer::Soup;
}

//On peut utiliser le mot use pour raccourcir les appels
//Un peu comme un lien symbolique
//...mais cela ne marche que dans le scope où l'on utilise use
//La façon habituelle d'appeller des modules et des fonctions est d'appeller
//son parent...
use crate::front_of_house::hosting;

//Ceci ne fonctionne pas !
//mod customer_notworking {
// pub fn somethingsomething() {
// hosting::add_to_waitlist();
// }
//}

//Ceci fonctionne
mod customer {
pub fn something() {
use crate::front_of_house::hosting;
hosting::add_to_waitlist;
}
}

//...en revanche la façon idiomatique d'appeller des enums
//et des structs est de les appeller directement
//(Sauf si on en appelle 2 qui ont le même nom)
use std::collections::HashMap;
fn notmain() {
let mut map = HashMap::new();
map.insert(1, 2);
}

//On peut aussi faire des alias comme en Python...
use std::io::Result as IoResult;

//On peut combiner pub et use pour importer du code
//et le rendre public
//Cela s'appelle du re-exporting

pub use crate::front_of_house::hosting;

pub fn whatever() {
hosting::add_to_waitlist();
}

//Si l'on a beaucoup d'imports, on peut factoriser
//Ceci
use std::cmp::Ordering;
use std::io;

//Peut s'écrire
use std::{cmp::Ordering, io};

//On peut importer tous les éléments publics dans le scope
use std::collections::*;

</nowiki>

front_of_house.rs
<nowiki>
//Je rend le module public pour pouvoir l'appeller dans eat_at_restaurant()
pub mod hosting {
pub fn add_to_waitlist() {
//Ici, je peux appeller une fonction privée,
//par exemple seat_at_table()
}
fn seat_at_table() {}
}

mod serving {
fn take_order() {}

fn serve_order() {}

fn take_payment() {}
}

</nowiki>

Rust : packages - Historique des versions

Justine le 3 novembre 2022 à 09:19