Macros

/// Defines a fieldless enum plus a `ALL` array and `name()` -- a common code-generation chore.
macro_rules! labelled_enum {
    ($vis:vis enum $name:ident { $( $variant:ident = $label:literal ),* $(,)? }) => {
        #[derive(Debug, Clone, Copy, PartialEq, Eq)]
        $vis enum $name { $( $variant ),* }

        impl $name {
            pub const ALL: &'static [$name] = &[ $( $name::$variant ),* ];
            pub fn label(self) -> &'static str {
                match self { $( $name::$variant => $label ),* }
            }
        }
    };
}

/// Counts token trees with recursion: count!(a b c) == 3.
macro_rules! count {
    () => { 0usize };
    ($head:tt $($tail:tt)*) => { 1usize + count!($($tail)*) };
}

labelled_enum! {
    pub enum Format { Hardcover = "hardcover", Paperback = "paperback", Ebook = "e-book" }
}

fn main() {
    for f in Format::ALL {
        print!("{} ", f.label());
    }
    println!("| {} formats, count = {}", Format::ALL.len(), count!(x y z));
}

macro_rules! double {
    ($e:expr) => {{
        let tmp = $e;   // `tmp` is private to the macro: hygiene
        tmp * 2
    }};
}

fn main() {
    let tmp = 10;
    println!("{}", double!(tmp + 1)); // 22: the caller's `tmp` and the macro's `tmp` do not clash
}

# shelf-macros/Cargo.toml
[package]
name = "shelf-macros"
version = "0.1.0"
edition = "2024"

[lib]
proc-macro = true

[dependencies]
syn = { version = "3.0.6", features = ["full"] }
quote = "1.0.47"
proc-macro2 = "1.0.107"

// shelf-macros/src/lib.rs
use proc_macro::TokenStream;
use quote::{format_ident, quote};
use syn::{Data, DeriveInput, Fields, parse_macro_input};

/// Derives a `FooBuilder` type with one setter per field and a `build` method.
#[proc_macro_derive(Builder)]
pub fn derive_builder(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;
    let builder = format_ident!("{name}Builder");

    let Data::Struct(data) = &input.data else {
        return syn::Error::new_spanned(&input, "Builder can only be derived for structs").to_compile_error().into();
    };
    let Fields::Named(fields) = &data.fields else {
        return syn::Error::new_spanned(&input, "Builder needs named fields").to_compile_error().into();
    };

    let names: Vec<_> = fields.named.iter().map(|f| f.ident.as_ref().expect("named field")).collect();
    let types: Vec<_> = fields.named.iter().map(|f| &f.ty).collect();

    let expanded = quote! {
        #[derive(Default)]
        pub struct #builder {
            #( #names: ::core::option::Option<#types>, )*
        }

        impl #builder {
            #(
                pub fn #names(mut self, value: impl ::core::convert::Into<#types>) -> Self {
                    self.#names = ::core::option::Option::Some(value.into());
                    self
                }
            )*

            pub fn build(self) -> ::core::result::Result<#name, ::std::string::String> {
                ::core::result::Result::Ok(#name {
                    #( #names: self.#names.ok_or(concat!("missing field `", stringify!(#names), "`"))?, )*
                })
            }
        }

        impl #name {
            pub fn builder() -> #builder {
                #builder::default()
            }
        }
    };
    expanded.into()
}

// any crate that depends on shelf-macros
use shelf_macros::Builder;

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

fn main() {
    let q = SearchQuery::builder().text("dune").limit(20u32).include_lent(false).build();
    println!("{q:?}");
    let missing = SearchQuery::builder().text("emma").build();
    println!("{missing:?}"); // Err("missing field `limit`")
}