Modules, Crates & Visibility

mod catalog {
    pub mod search {
        pub fn by_title(titles: &[&str], query: &str) -> Vec<String> {
            titles.iter().filter(|t| t.to_lowercase().contains(query)).map(|t| t.to_string()).collect()
        }
    }

    pub fn summary(titles: &[&str]) -> String {
        format!("{} titles, {} match 'dune'", titles.len(), search::by_title(titles, "dune").len())
    }
}

fn main() {
    let titles = ["Dune", "Dune Messiah", "Emma"];
    println!("{}", catalog::summary(&titles));
    println!("{:?}", catalog::search::by_title(&titles, "emma"));
}

mod model {
    #[derive(Debug)]
    pub struct Book {
        pub title: String,
    }

    pub mod loans {
        pub fn describe(book: &super::Book) -> String {          // super:: = the parent module
            format!("loan of {}", book.title)
        }
        pub fn shelf_label(book: &crate::model::Book) -> String { // absolute path
            self::prefix() + &book.title                           // self:: = this module
        }
        fn prefix() -> String {
            "SHELF/".into()
        }
    }
}

fn main() {
    let b = model::Book { title: "Dune".into() };
    println!("{} | {}", model::loans::describe(&b), crate::model::loans::shelf_label(&b));
}

use std::collections::{BTreeMap, HashMap};   // nested import
use std::fmt::{self, Display};               // `self` imports the module too
use std::io::Result as IoResult;             // rename with `as`
use std::sync::atomic::*;                    // glob import (use sparingly)

struct Count(usize);

impl Display for Count {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} books", self.0)
    }
}

fn load() -> IoResult<usize> {
    Ok(3)
}

fn main() {
    let mut by_genre: HashMap<&str, usize> = HashMap::new();
    by_genre.insert("sci-fi", 2);
    let sorted: BTreeMap<_, _> = by_genre.into_iter().collect();
    let counter = AtomicUsize::new(0);
    counter.fetch_add(1, Ordering::Relaxed);
    println!("{sorted:?} {} {:?}", Count(load().unwrap_or(0)), counter);
}

mod shelf_core {
    mod isbn {
        #[derive(Debug)]
        pub struct Isbn(pub String);
    }
    mod catalog {
        pub trait Catalog {
            fn len(&self) -> usize;
        }
    }
    pub use catalog::Catalog;   // public at shelf_core::Catalog
    pub use isbn::Isbn;         // public at shelf_core::Isbn, though `isbn` itself is private
}

use shelf_core::{Catalog, Isbn};

struct Empty;
impl Catalog for Empty {
    fn len(&self) -> usize {
        0
    }
}

fn main() {
    println!("{:?} {}", Isbn("9780441013593".into()), Empty.len());
    // shelf_core::isbn::Isbn(...) would not compile: module `isbn` is private (E0603)
}

mod catalog {
    pub struct Catalog {
        pub name: String,            // public field
        pub(crate) books: Vec<String>, // visible anywhere in this crate
        loans: u32,                  // private: only inside `catalog`
    }

    impl Catalog {
        pub fn new(name: &str) -> Self {
            Catalog { name: name.into(), books: Vec::new(), loans: 0 }
        }
        pub fn lend(&mut self) {
            self.loans += 1;
            audit::record(self.loans);
        }
    }

    mod audit {
        pub(super) fn record(n: u32) {   // only `catalog` may call this
            println!("loan #{n} recorded");
        }
    }
}

fn main() {
    let mut c = catalog::Catalog::new("main");
    c.books.push("Dune".into());         // ok: pub(crate)
    c.lend();
    println!("{} {}", c.name, c.books.len());
    // c.loans;                         // would not compile: field `loans` is private (E0616)
    // catalog::audit::record(1);       // would not compile: module `audit` is private (E0603)
}