API Design Idioms

pub struct Username(String);

impl Username {
    pub fn new(raw: &str) -> Username {
        Username(raw.trim().to_lowercase())
    }
    pub fn as_str(&self) -> &str {
        &self.0 // cheap: just a view
    }
    pub fn len(&self) -> usize {
        self.0.len() // a getter: no `get_` prefix
    }
    pub fn is_admin(&self) -> bool {
        self.0.starts_with("admin")
    }
    pub fn to_display_name(&self) -> String {
        let mut c = self.0.chars(); // allocates a new String
        c.next().map(|f| f.to_uppercase().chain(c).collect()).unwrap_or_default()
    }
    pub fn into_string(self) -> String {
        self.0 // consumes self, no copy
    }
}

fn main() {
    let u = Username::new("  AdminAna ");
    println!("{} ({} chars), admin: {}", u.as_str(), u.len(), u.is_admin());
    println!("{}", u.to_display_name());
    let raw: String = u.into_string();
    println!("{raw}");
}

fn count_vowels(s: &str) -> usize {
    s.chars().filter(|c| "aeiouAEIOU".contains(*c)).count()
}

fn average(values: &[f64]) -> Option<f64> {
    (!values.is_empty()).then(|| values.iter().sum::<f64>() / values.len() as f64)
}

fn main() {
    let owned = String::from("Programming in Rust");
    println!("{}", count_vowels(&owned)); // &String -> &str
    println!("{}", count_vowels("literal")); // &'static str
    println!("{}", count_vowels(&owned[..11])); // a slice of a String

    let v = vec![1.0, 2.0, 4.5];
    println!("{:?}", average(&v)); // &Vec<f64> -> &[f64]
    println!("{:?}", average(&[10.0, 20.0])); // an array
    println!("{:?}", average(&v[1..])); // a sub-slice
}

struct Email {
    to: String,
    subject: String,
}

impl Email {
    fn new(to: impl Into<String>, subject: impl Into<String>) -> Email {
        Email { to: to.into(), subject: subject.into() }
    }
}

fn main() {
    let a = Email::new("ana@example.com", "Hi"); // &str: converted
    let subject = format!("Invoice #{}", 42);
    let b = Email::new(String::from("ben@example.com"), subject); // String: moved, no copy
    println!("{} / {}", a.to, a.subject);
    println!("{} / {}", b.to, b.subject);
}

use std::path::Path;

fn extension_of(path: impl AsRef<Path>) -> Option<String> {
    path.as_ref().extension().map(|e| e.to_string_lossy().to_lowercase())
}

fn main() {
    let owned = String::from("report.PDF");
    let buf = std::path::PathBuf::from("/var/log/app.log");
    println!("{:?}", extension_of("photo.jpeg"));
    println!("{:?}", extension_of(&owned));
    println!("{:?}", extension_of(&buf));
    println!("{:?}", extension_of(Path::new("Makefile")));
}

use std::collections::BTreeSet;

fn total_cents(prices: impl IntoIterator<Item = u32>) -> u64 {
    prices.into_iter().map(u64::from).sum()
}

fn main() {
    println!("{}", total_cents(vec![199, 250]));
    println!("{}", total_cents([100, 200, 300]));
    println!("{}", total_cents(BTreeSet::from([5, 10])));
    println!("{}", total_cents((1..=4).map(|n| n * 100))); // a lazy chain, no Vec
}

struct Inventory {
    items: Vec<(String, u32)>,
}

impl Inventory {
    fn low_stock(&self, below: u32) -> impl Iterator<Item = &str> {
        self.items.iter().filter(move |(_, qty)| *qty < below).map(|(name, _)| name.as_str())
    }
}

fn main() {
    let inv = Inventory { items: vec![("pens".into(), 3), ("paper".into(), 120), ("ink".into(), 1), ("tape".into(), 9)] };

    let first = inv.low_stock(10).next(); // stops after the first match
    let count = inv.low_stock(10).count();
    let joined = inv.low_stock(5).collect::<Vec<_>>().join(", ");
    println!("{first:?}, {count} low, critically low: {joined}");
}

use std::ops::Add;

#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
struct Meters(f64);

#[derive(Debug, Clone, Copy)]
struct Feet(f64);

impl From<Feet> for Meters {
    fn from(f: Feet) -> Meters {
        Meters(f.0 * 0.3048)
    }
}

impl Add for Meters {
    type Output = Meters;
    fn add(self, other: Meters) -> Meters {
        Meters(self.0 + other.0)
    }
}

fn main() {
    let runway = Meters(2500.0);
    let extension: Meters = Feet(1000.0).into(); // explicit conversion
    let total = runway + extension;
    println!("{total:?}");
    println!("long enough for a 747: {}", total >= Meters(2800.0));
}

#[derive(Debug, Clone)]
pub struct Email(String);

impl Email {
    pub fn parse(raw: &str) -> Result<Email, String> {
        let raw = raw.trim();
        let (user, domain) = raw.split_once('@').ok_or(format!("{raw:?} has no @"))?;
        if user.is_empty() || !domain.contains('.') || domain.starts_with('.') {
            return Err(format!("{raw:?} is not a valid address"));
        }
        Ok(Email(raw.to_lowercase()))
    }

    pub fn domain(&self) -> &str {
        self.0.split_once('@').map(|(_, d)| d).unwrap() // can't fail: checked in parse
    }
}

// No validation needed here: the type guarantees it.
fn send_welcome(to: &Email) -> String {
    format!("welcome mail queued for {} (domain {})", to.0, to.domain())
}

fn main() {
    for raw in ["Ana@Example.com", "no-at-sign", "x@.com", "ben@mail.org"] {
        match Email::parse(raw) {
            Ok(email) => println!("{}", send_welcome(&email)),
            Err(e) => println!("rejected: {e}"),
        }
    }
}

#[derive(Debug)]
enum Connection {
    Disconnected,
    Connecting { attempt: u32 },
    Connected { session_id: u64 },
    Failed { reason: String },
}

impl Connection {
    fn step(self, ok: bool) -> Connection {
        match self {
            Connection::Disconnected => Connection::Connecting { attempt: 1 },
            Connection::Connecting { attempt } if ok => Connection::Connected { session_id: 1000 + attempt as u64 },
            Connection::Connecting { attempt } if attempt < 3 => Connection::Connecting { attempt: attempt + 1 },
            Connection::Connecting { .. } => Connection::Failed { reason: String::from("3 attempts failed") },
            done => done, // Connected and Failed stay as they are
        }
    }
}

fn main() {
    let mut c = Connection::Disconnected;
    for ok in [false, false, true, false] {
        c = c.step(ok);
        println!("{c:?}");
    }
    // There's no way to build "Connected with a failure reason".
}

use std::marker::PhantomData;

struct Draft;
struct Reviewed;
struct Published;

struct Article<State> {
    title: String,
    body: String,
    _state: PhantomData<State>,
}

impl Article<Draft> {
    fn new(title: &str) -> Self {
        Article { title: title.to_string(), body: String::new(), _state: PhantomData }
    }
    fn write(mut self, text: &str) -> Self {
        self.body.push_str(text);
        self
    }
    fn submit(self) -> Article<Reviewed> {
        Article { title: self.title, body: self.body, _state: PhantomData }
    }
}

impl Article<Reviewed> {
    fn publish(self) -> Article<Published> {
        Article { title: self.title, body: self.body, _state: PhantomData }
    }
}

impl Article<Published> {
    fn url(&self) -> String {
        format!("/posts/{}", self.title.to_lowercase().replace(' ', "-"))
    }
}

fn main() {
    let draft = Article::new("Typestate in Rust").write("States as types...");
    // draft.publish(); // error: no method `publish` on Article<Draft>
    let live = draft.submit().publish();
    println!("{} ({} chars) at {}", live.title, live.body.len(), live.url());
}

#[derive(Debug, Clone)]
struct ServerConfig {
    host: String,
    port: u16,
    workers: usize,
    tls: bool,
    max_body_kb: u32,
}

impl Default for ServerConfig {
    fn default() -> Self {
        ServerConfig { host: String::from("127.0.0.1"), port: 8080, workers: 4, tls: false, max_body_kb: 1024 }
    }
}

fn main() {
    let dev = ServerConfig::default();
    let prod = ServerConfig { host: String::from("0.0.0.0"), port: 443, tls: true, ..Default::default() };
    println!("{dev:?}");
    println!("{prod:?}");
}

#[derive(Debug)]
pub struct HttpRequest {
    method: String,
    url: String,
    headers: Vec<(String, String)>,
    timeout_ms: u64,
}

#[derive(Default)]
pub struct HttpRequestBuilder {
    method: Option<String>,
    url: Option<String>,
    headers: Vec<(String, String)>,
    timeout_ms: Option<u64>,
}

impl HttpRequest {
    pub fn builder() -> HttpRequestBuilder {
        HttpRequestBuilder::default()
    }
}

impl HttpRequestBuilder {
    pub fn get(mut self, url: impl Into<String>) -> Self {
        self.method = Some(String::from("GET"));
        self.url = Some(url.into());
        self
    }
    pub fn header(mut self, name: &str, value: &str) -> Self {
        self.headers.push((name.to_string(), value.to_string()));
        self
    }
    pub fn timeout_ms(mut self, ms: u64) -> Self {
        self.timeout_ms = Some(ms);
        self
    }
    pub fn build(self) -> Result<HttpRequest, String> {
        let url = self.url.ok_or("url is required")?;
        if !url.starts_with("http") {
            return Err(format!("invalid url {url:?}"));
        }
        Ok(HttpRequest { method: self.method.unwrap_or_else(|| String::from("GET")), url, headers: self.headers, timeout_ms: self.timeout_ms.unwrap_or(30_000) })
    }
}

fn main() {
    let req = HttpRequest::builder().get("https://api.example.com/users").header("Accept", "application/json").timeout_ms(5_000).build();
    println!("{req:#?}");
    println!("{:?}", HttpRequest::builder().header("X", "1").build());
    println!("{:?}", HttpRequest::builder().get("ftp://old").build());
}

use std::marker::PhantomData;

struct Missing;
struct Set;

struct EmailBuilder<To, Subject> {
    to: Option<String>,
    subject: Option<String>,
    body: String,
    _state: PhantomData<(To, Subject)>,
}

struct Email {
    to: String,
    subject: String,
    body: String,
}

impl EmailBuilder<Missing, Missing> {
    fn new() -> Self {
        EmailBuilder { to: None, subject: None, body: String::new(), _state: PhantomData }
    }
}

impl<S> EmailBuilder<Missing, S> {
    fn to(self, addr: &str) -> EmailBuilder<Set, S> {
        EmailBuilder { to: Some(addr.into()), subject: self.subject, body: self.body, _state: PhantomData }
    }
}

impl<T> EmailBuilder<T, Missing> {
    fn subject(self, s: &str) -> EmailBuilder<T, Set> {
        EmailBuilder { to: self.to, subject: Some(s.into()), body: self.body, _state: PhantomData }
    }
}

impl<T, S> EmailBuilder<T, S> {
    fn body(mut self, text: &str) -> Self {
        self.body.push_str(text); // optional, allowed in any state
        self
    }
}

impl EmailBuilder<Set, Set> {
    // `build` only exists once both required fields are set; it can't fail.
    fn build(self) -> Email {
        Email { to: self.to.unwrap(), subject: self.subject.unwrap(), body: self.body }
    }
}

fn main() {
    let mail = EmailBuilder::new().subject("Your order shipped").body("Tracking: 1Z999").to("ana@example.com").build();
    println!("to {} | {} | {}", mail.to, mail.subject, mail.body);
    // EmailBuilder::new().to("x@y.z").build(); // error: `build` not found for EmailBuilder<Set, Missing>
}

#[derive(Debug, Clone, Copy, PartialEq)]
enum Overwrite {
    Yes,
    No,
}

#[derive(Debug, Clone, Copy, PartialEq)]
enum Permissions {
    Preserve,
    Reset,
}

fn copy_file(from: &str, to: &str, overwrite: Overwrite, perms: Permissions) -> String {
    let exists = to.ends_with(".bak");
    if exists && overwrite == Overwrite::No {
        return format!("skipped {to}: already exists");
    }
    format!("copied {from} -> {to} ({})", if perms == Permissions::Preserve { "permissions kept" } else { "default permissions" })
}

fn main() {
    println!("{}", copy_file("db.sqlite", "db.sqlite.bak", Overwrite::No, Permissions::Preserve));
    println!("{}", copy_file("db.sqlite", "db.sqlite.bak", Overwrite::Yes, Permissions::Reset));
}

use std::collections::{BTreeSet, HashMap};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
enum Priority {
    Low,
    Medium,
    High,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
struct Ticket {
    priority: Priority, // derived Ord compares fields top to bottom
    id: u32,
}

fn main() {
    let tickets = vec![
        Ticket { priority: Priority::Low, id: 3 },
        Ticket { priority: Priority::High, id: 7 },
        Ticket { priority: Priority::High, id: 2 },
    ];

    let sorted: BTreeSet<Ticket> = tickets.iter().cloned().collect(); // needs Ord
    println!("{:?}", sorted.iter().map(|t| t.id).collect::<Vec<_>>());

    let mut per_priority: HashMap<Priority, usize> = HashMap::new(); // needs Hash + Eq
    for t in &tickets {
        *per_priority.entry(t.priority).or_default() += 1;
    }
    println!("high: {}", per_priority[&Priority::High]);
    println!("max: {:?}", tickets.iter().max()); // needs Ord
}

use std::fmt;

#[derive(Debug)]
struct Money {
    cents: i64,
    currency: &'static str,
}

impl fmt::Display for Money {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let sign = if self.cents < 0 { "-" } else { "" };
        let abs = self.cents.abs();
        write!(f, "{sign}{}{}.{:02}", self.currency, abs / 100, abs % 100)
    }
}

fn main() {
    let refund = Money { cents: -1250, currency: "$" };
    println!("{refund}");
    println!("{refund:?}");
    let label: String = refund.to_string(); // from Display
    println!("{label:>12}|"); // padding applies to the whole formatted value
}

use std::fmt;
use std::str::FromStr;

#[derive(Debug, PartialEq, Clone, Copy)]
struct Version {
    major: u32,
    minor: u32,
    patch: u32,
}

impl FromStr for Version {
    type Err = String;

    fn from_str(s: &str) -> Result<Version, String> {
        let parts: Vec<&str> = s.trim_start_matches('v').split('.').collect();
        let [major, minor, patch] = parts.as_slice() else {
            return Err(format!("{s:?}: expected MAJOR.MINOR.PATCH"));
        };
        let num = |p: &str| p.parse::<u32>().map_err(|_| format!("{s:?}: {p:?} is not a number"));
        Ok(Version { major: num(major)?, minor: num(minor)?, patch: num(patch)? })
    }
}

impl fmt::Display for Version {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
    }
}

fn main() {
    let v: Version = "v1.42.3".parse().unwrap();
    println!("{v} ({v:?})");
    println!("round trip: {}", v.to_string().parse::<Version>() == Ok(v));
    println!("{:?}", "1.2".parse::<Version>());
    println!("{:?}", "1.x.0".parse::<Version>());
}

use std::convert::TryFrom;

#[derive(Debug, Clone, Copy, PartialEq)]
struct Percent(u8);

impl TryFrom<i32> for Percent {
    type Error = String;
    fn try_from(v: i32) -> Result<Percent, String> {
        u8::try_from(v).ok().filter(|p| *p <= 100).map(Percent).ok_or(format!("{v} is not a percentage"))
    }
}

impl From<Percent> for f64 {
    fn from(p: Percent) -> f64 {
        p.0 as f64 / 100.0
    }
}

fn discounted(price: f64, off: Percent) -> f64 {
    price * (1.0 - f64::from(off))
}

fn main() {
    let off: Percent = 25.try_into().unwrap();
    println!("{:.2}", discounted(80.0, off));
    println!("{:?} {:?}", Percent::try_from(150), Percent::try_from(-3));
    let as_fraction: f64 = off.into();
    println!("{as_fraction}");
}

struct Playlist {
    name: String,
    songs: Vec<String>,
}

impl Playlist {
    fn iter(&self) -> std::slice::Iter<'_, String> {
        self.songs.iter()
    }
}

impl<'a> IntoIterator for &'a Playlist {
    type Item = &'a String;
    type IntoIter = std::slice::Iter<'a, String>;
    fn into_iter(self) -> Self::IntoIter {
        self.songs.iter()
    }
}

impl IntoIterator for Playlist {
    type Item = String;
    type IntoIter = std::vec::IntoIter<String>;
    fn into_iter(self) -> Self::IntoIter {
        self.songs.into_iter()
    }
}

fn main() {
    let p = Playlist { name: String::from("focus"), songs: vec!["Intro".into(), "Deep Work".into(), "Outro".into()] };
    for song in &p {
        print!("{song}; ");
    }
    println!("({} has {} songs)", p.name, p.iter().count());
    let owned: Vec<String> = p.into_iter().filter(|s| s.len() > 5).collect(); // consumes the playlist
    println!("{owned:?}");
}

use std::collections::BTreeMap;

#[derive(Debug, Default)]
struct Histogram {
    buckets: BTreeMap<u32, usize>, // bucket start -> count
    width: u32,
}

impl Histogram {
    fn add(&mut self, value: u32) {
        let w = if self.width == 0 { 10 } else { self.width };
        *self.buckets.entry(value / w * w).or_default() += 1;
    }
}

impl FromIterator<u32> for Histogram {
    fn from_iter<I: IntoIterator<Item = u32>>(iter: I) -> Self {
        let mut h = Histogram { width: 10, ..Default::default() };
        h.extend(iter);
        h
    }
}

impl Extend<u32> for Histogram {
    fn extend<I: IntoIterator<Item = u32>>(&mut self, iter: I) {
        for v in iter {
            self.add(v);
        }
    }
}

fn main() {
    let latencies = [12, 15, 27, 31, 8, 22, 45, 19];
    let mut h: Histogram = latencies.into_iter().collect();
    h.extend([41, 44, 49]);
    for (start, n) in &h.buckets {
        println!("{start:>2}-{:<2} {}", start + h.width - 1, "#".repeat(*n));
    }
}

pub trait StrExt {
    fn truncate_words(&self, max_words: usize) -> String;
    fn is_blank(&self) -> bool;
}

impl StrExt for str {
    fn truncate_words(&self, max_words: usize) -> String {
        let words: Vec<&str> = self.split_whitespace().collect();
        if words.len() <= max_words {
            words.join(" ")
        } else {
            format!("{}...", words[..max_words].join(" "))
        }
    }

    fn is_blank(&self) -> bool {
        self.trim().is_empty()
    }
}

fn main() {
    let summary = "Rust gives you control over memory without a garbage collector";
    println!("{}", summary.truncate_words(5));
    println!("{}", "short text".truncate_words(5));
    println!("{} {}", "   ".is_blank(), String::from(" x ").is_blank()); // String derefs to str
}

// Called immediately: impl Fn.
fn retry_count(attempts: u32, op: impl Fn(u32) -> bool) -> Option<u32> {
    (1..=attempts).find(|&n| op(n))
}

// Stored, one closure type per struct: a generic.
struct Validator<F: Fn(&str) -> bool> {
    name: &'static str,
    check: F,
}

// Stored, many different closures: Box<dyn Fn>.
struct Hooks {
    on_save: Vec<Box<dyn Fn(&str) -> String>>,
}

fn main() {
    println!("{:?}", retry_count(5, |n| n * n > 10));

    let v = Validator { name: "no-spaces", check: |s: &str| !s.contains(' ') };
    println!("{}: {}", v.name, (v.check)("hello world"));

    let prefix = String::from("[audit]");
    let hooks = Hooks {
        on_save: vec![Box::new(|doc| format!("indexed {doc}")), Box::new(move |doc| format!("{prefix} saved {doc}"))],
    };
    for h in &hooks.on_save {
        println!("{}", h("report.md"));
    }
}

struct Profile {
    nickname: Option<String>,
    avatar_urls: Option<Vec<String>>,
}

impl Profile {
    fn nickname(&self) -> Option<&str> {
        self.nickname.as_deref() // Option<String> -> Option<&str>
    }
    fn first_avatar(&self) -> Option<&str> {
        self.avatar_urls.as_ref()?.first().map(String::as_str)
    }
}

fn main() {
    let a = Profile { nickname: Some(String::from("ana_dev")), avatar_urls: Some(vec![String::from("/a.png")]) };
    let b = Profile { nickname: None, avatar_urls: None };
    for p in [&a, &b] {
        println!("{} / {}", p.nickname().unwrap_or("anonymous"), p.first_avatar().unwrap_or("/default.png"));
    }
}

use std::fmt;
use std::iter::Sum;
use std::str::FromStr;

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Currency {
    Eur,
    Usd,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Money {
    cents: i64,
    currency: Currency,
}

impl Money {
    pub fn zero(currency: Currency) -> Money {
        Money { cents: 0, currency }
    }

    pub fn checked_add(self, other: Money) -> Result<Money, String> {
        if self.currency != other.currency {
            return Err(format!("cannot add {} to {}", other, self));
        }
        Ok(Money { cents: self.cents + other.cents, currency: self.currency })
    }
}

impl FromStr for Money {
    type Err = String;
    fn from_str(s: &str) -> Result<Money, String> {
        let (amount, code) = s.trim().rsplit_once(' ').ok_or(format!("{s:?}: expected e.g. \"12.50 EUR\""))?;
        let currency = match code {
            "EUR" => Currency::Eur,
            "USD" => Currency::Usd,
            other => return Err(format!("unknown currency {other}")),
        };
        let (whole, frac) = amount.split_once('.').unwrap_or((amount, "0"));
        let frac = format!("{frac:0<2}");
        let bad_amount = |_| format!("{s:?}: invalid amount {amount:?}");
        let cents = whole.parse::<i64>().map_err(bad_amount)? * 100 + frac[..2].parse::<i64>().map_err(bad_amount)?;
        Ok(Money { cents, currency })
    }
}

impl fmt::Display for Money {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let code = match self.currency {
            Currency::Eur => "EUR",
            Currency::Usd => "USD",
        };
        write!(f, "{}.{:02} {code}", self.cents / 100, self.cents % 100)
    }
}

/// Sums amounts of one currency. Panics on mixed currencies; use `checked_add` to handle that case.
impl Sum for Money {
    fn sum<I: Iterator<Item = Money>>(mut iter: I) -> Money {
        let first = iter.next().unwrap_or(Money::zero(Currency::Eur));
        iter.fold(first, |acc, m| acc.checked_add(m).expect("mixed currencies"))
    }
}

fn main() {
    let lines: Vec<Money> = ["12.50 EUR", "3.5 EUR", "100 EUR"].iter().map(|s| s.parse().unwrap()).collect();
    let total: Money = lines.iter().copied().sum();
    println!("total: {total}");

    let usd: Money = "9.99 USD".parse().unwrap();
    println!("{:?}", total.checked_add(usd));
    println!("{:?}", "12,50 EUR".parse::<Money>());
    println!("{:?}", "5 GBP".parse::<Money>());
}

use std::collections::HashMap;
use std::fmt;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ProjectId(u32);

#[derive(Debug)]
pub struct Project {
    id: ProjectId,
    name: String,
    owner: Option<String>,
}

impl Project {
    pub fn id(&self) -> ProjectId {
        self.id
    }
    pub fn name(&self) -> &str {
        &self.name
    }
    pub fn owner(&self) -> Option<&str> {
        self.owner.as_deref()
    }
}

#[derive(Debug)]
pub enum ClientError {
    NotFound(ProjectId),
    Unauthorized,
}

impl fmt::Display for ClientError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ClientError::NotFound(id) => write!(f, "project {} not found", id.0),
            ClientError::Unauthorized => write!(f, "missing or invalid API token"),
        }
    }
}

impl std::error::Error for ClientError {}

pub struct Client {
    token: Option<String>,
    base_url: String,
    projects: HashMap<ProjectId, Project>, // stands in for the remote service
}

pub struct ClientBuilder {
    token: Option<String>,
    base_url: String,
}

impl Client {
    pub fn builder() -> ClientBuilder {
        ClientBuilder { token: None, base_url: String::from("https://api.example.com") }
    }

    pub fn project(&self, id: ProjectId) -> Result<&Project, ClientError> {
        self.token.as_ref().ok_or(ClientError::Unauthorized)?;
        self.projects.get(&id).ok_or(ClientError::NotFound(id))
    }

    pub fn projects_owned_by<'a>(&'a self, owner: &'a str) -> impl Iterator<Item = &'a Project> + 'a {
        self.projects.values().filter(move |p| p.owner() == Some(owner))
    }
}

impl ClientBuilder {
    pub fn token(mut self, t: impl Into<String>) -> Self {
        self.token = Some(t.into());
        self
    }
    pub fn base_url(mut self, url: impl Into<String>) -> Self {
        self.base_url = url.into();
        self
    }
    pub fn build(self) -> Client {
        let projects = [(1, "website", Some("ana")), (2, "mobile-app", Some("ben")), (3, "docs", Some("ana")), (4, "sandbox", None)]
            .into_iter()
            .map(|(id, name, owner)| (ProjectId(id), Project { id: ProjectId(id), name: name.into(), owner: owner.map(Into::into) }))
            .collect();
        Client { token: self.token, base_url: self.base_url, projects }
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::builder().token("secret-token").build();
    let p = client.project(ProjectId(2))?;
    println!("{} (id {:?}) owned by {:?} via {}", p.name(), p.id(), p.owner(), client.base_url);

    let mut anas: Vec<&str> = client.projects_owned_by("ana").map(Project::name).collect();
    anas.sort();
    println!("ana owns {anas:?}");

    println!("{}", client.project(ProjectId(9)).unwrap_err());
    let anonymous = Client::builder().base_url("http://localhost:8080").build();
    println!("{}", anonymous.project(ProjectId(1)).unwrap_err());
    Ok(())
}