Idioms, Patterns & API Guidelines

fn title_case(title: &str) -> String {               // not &String
    title.split(' ').map(|w| {
        let mut chars = w.chars();
        chars.next().map(|c| c.to_uppercase().collect::<String>() + chars.as_str()).unwrap_or_default()
    }).collect::<Vec<_>>().join(" ")
}

fn total_pages(pages: &[u32]) -> u32 {                // not &Vec<u32>
    pages.iter().sum()
}

fn main() {
    let owned = String::from("the left hand of darkness");
    println!("{} | {}", title_case(&owned), title_case("dune messiah"));
    let pages: Vec<u32> = "412 180".split(' ').filter_map(|p| p.parse().ok()).collect();
    println!("{} {}", total_pages(&pages), total_pages(&[96; 3])); // &Vec<u32> and &[u32; 3] both coerce
}

use std::mem;

enum Draft {
    Editing { text: String },
    Submitted { text: String, reviewer: String },
}

impl Draft {
    fn submit(&mut self, reviewer: &str) {
        if let Draft::Editing { text } = self {
            let text = mem::take(text);           // move the String out, leave "" behind
            *self = Draft::Submitted { text, reviewer: reviewer.into() };
        }
    }
}

fn main() {
    let mut d = Draft::Editing { text: "A great read.".into() };
    d.submit("librarian");
    if let Draft::Submitted { text, reviewer } = &d {
        println!("{reviewer}: {text}");
    }
}

#[derive(Debug)]
pub struct SearchQuery {
    text: String,
    limit: usize,
    include_lent: bool,
    sort_by_year: bool,
}

#[derive(Default)]
pub struct SearchQueryBuilder {
    text: Option<String>,
    limit: Option<usize>,
    include_lent: bool,
    sort_by_year: bool,
}

impl SearchQueryBuilder {
    pub fn text(mut self, text: impl Into<String>) -> Self {
        self.text = Some(text.into());
        self
    }
    pub fn limit(mut self, limit: usize) -> Self {
        self.limit = Some(limit);
        self
    }
    pub fn include_lent(mut self, yes: bool) -> Self {
        self.include_lent = yes;
        self
    }
    pub fn sort_by_year(mut self) -> Self {
        self.sort_by_year = true;
        self
    }
    pub fn build(self) -> Result<SearchQuery, String> {
        let text = self.text.filter(|t| !t.trim().is_empty()).ok_or("text is required")?;
        let limit = self.limit.unwrap_or(20);
        if limit == 0 || limit > 100 {
            return Err(format!("limit must be 1-100, got {limit}"));
        }
        Ok(SearchQuery { text, limit, include_lent: self.include_lent, sort_by_year: self.sort_by_year })
    }
}

impl SearchQuery {
    pub fn builder() -> SearchQueryBuilder {
        SearchQueryBuilder::default()
    }
}

fn main() {
    let q = SearchQuery::builder().text("dune").limit(10).sort_by_year().build();
    println!("{q:?}");
    println!("{:?}", SearchQuery::builder().limit(500).text("x").build());
}

trait FeePolicy {
    fn fee_cents(&self, days_late: u32) -> u32;
}

struct Standard;
struct Student;

impl FeePolicy for Standard {
    fn fee_cents(&self, days_late: u32) -> u32 {
        days_late.min(10) * 50
    }
}
impl FeePolicy for Student {
    fn fee_cents(&self, days_late: u32) -> u32 {
        days_late.saturating_sub(2).min(10) * 25
    }
}

fn invoice(policy: &dyn FeePolicy, days: u32) -> u32 {          // strategy chosen at run time
    policy.fee_cents(days)
}

fn invoice_with(days: u32, fee: impl Fn(u32) -> u32) -> u32 {    // strategy as a closure
    fee(days)
}

fn main() {
    let policies: [(&str, Box<dyn FeePolicy>); 2] = [("standard", Box::new(Standard)), ("student", Box::new(Student))];
    for (name, p) in &policies {
        println!("{name}: {}", invoice(p.as_ref(), 5));
    }
    println!("holiday: {}", invoice_with(5, |_| 0));
}

#[derive(Debug, Clone)]
enum Command {
    Lend { isbn: String, member: String },
    Return { isbn: String },
}

#[derive(Default)]
struct Desk {
    lent: Vec<(String, String)>,
    history: Vec<Command>,
}

impl Desk {
    fn execute(&mut self, cmd: Command) {
        match &cmd {
            Command::Lend { isbn, member } => self.lent.push((isbn.clone(), member.clone())),
            Command::Return { isbn } => self.lent.retain(|(i, _)| i != isbn),
        }
        self.history.push(cmd); // commands are data: easy to log, replay or undo
    }
}

fn main() {
    let mut desk = Desk::default();
    desk.execute(Command::Lend { isbn: "978".into(), member: "alice".into() });
    desk.execute(Command::Return { isbn: "978".into() });
    println!("{} on loan, {} commands logged", desk.lent.len(), desk.history.len());
}