CodeBlanks Logo Icon CodeBlanks
Login Register

syn and quote

Generate code with the syn and quote crates.

syn and quote

The two basic tools for writing procedural macros:

  • syn: parses a TokenStream into a Rust syntax tree (DeriveInput, ItemFn, Expr...).
  • quote: turns Rust code written inside quote! { .. }, with #variable interpolations, back into a TokenStream.
let ad = &ast.ident;                 // syn::Ident: Kisi
let n = alanlar.len();
let uretilen = quote! {
    impl #ad {
        fn alan_sayisi() -> usize { #n }
    }
};

In the intermediate step the code isn't text but structured tokens; this lets error messages point to the right source location.

Seeing code generation as text

We can see what quote! produces by building the same template with text; in macro debugging, cargo expand shows exactly this:

fn impl_uret(ad: &str, alanlar: &[&str]) -> String {
    format!(
        "impl {ad} {{ fn alan_sayisi() -> usize {{ {} }} }}",
        alanlar.len()
    )
}

Real macros use quote! instead of string concatenation; the text approach is open to quoting, escaping and location problems.

Practice Code from a template

Write the impl_uret function above. Print the result of impl_uret("Kisi", &["ad", "yas"]).

Starter code

main.rs
fn main() {
    // buraya yaz
}

Sample solution

main.rs
fn impl_uret(ad: &str, alanlar: &[&str]) -> String {
    format!(
        "impl {ad} {{ fn alan_sayisi() -> usize {{ {} }} }}",
        alanlar.len()
    )
}

fn main() {
    println!("{}", impl_uret("Kisi", &["ad", "yas"]));
}

Expected output

impl Kisi { fn alan_sayisi() -> usize { 2 } }

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 How should a user error in a macro (e.g. a struct macro applied to an enum) be reported?

  • A compile error at the right location with syn::Error::new_spanned(..).to_compile_error() Correct answer
  • panic!
  • Silently empty output
  • println!

Explanation: A panic also gives a compile error but with a vague location; an error with a span takes the user to the right line.

2 Interpolate a variable

Question 
quote! {
    impl ____ad {
        fn alan_sayisi() -> usize { #n }
    }
}
Answer 
quote! {
    impl #ad {
        fn alan_sayisi() -> usize { #n }
    }
}

Explanation: Inside quote!, #ad interpolates the ad variable into the code.

3 Tool and output

Term Meaning
syn::parse_macro_input! Syntax tree
quote! TokenStream
cargo expand Expanded code
syn::Error Error with location

All lessons in Advanced

1 async/await

  1. async fn
  2. await
  3. Future trait
  4. async block
  5. Pin
  6. Summary - async/await

2 Tokio

  1. Tokio runtime
  2. spawn
  3. tokio::sync
  4. tokio::fs
  5. select!
  6. Summary - Tokio

3 Concurrency

  1. thread::spawn
  2. Mutex<T>
  3. RwLock<T>
  4. Arc<T>
  5. Send and Sync
  6. Summary - Concurrency

4 Channels

  1. mpsc channel
  2. send and recv
  3. Multiple producers
  4. try_recv
  5. tokio::sync::mpsc
  6. Summary - Channels

5 Project: Chat server

  1. TCP listener
  2. Client thread
  3. Channel messaging
  4. Broadcast
  5. Arc<Mutex> state

6 Unsafe Rust

  1. unsafe block
  2. Raw pointers
  3. unsafe fn
  4. static mut
  5. FFI call
  6. Summary - Unsafe Rust

7 FFI

  1. extern block
  2. #[repr(C)]
  3. CString and CStr
  4. Callback
  5. Drop and cleanup
  6. Summary - FFI

8 Declarative macros

  1. macro_rules!
  2. Repetitions
  3. Types
  4. Macro hygiene
  5. Inspecting println!
  6. Summary - Declarative macros

9 Procedural macros

  1. proc_macro crate
  2. derive macro
  3. attribute macro
  4. syn and quote
  5. TokenStream
  6. Summary - Procedural macros

10 Trait objects

  1. dyn Trait
  2. Box<dyn Trait>
  3. Static vs dynamic dispatch
  4. Object safety
  5. &dyn Trait
  6. Summary - Trait objects

11 Advanced traits

  1. Associated type
  2. Associated constant
  3. GAT
  4. Supertrait
  5. Newtype pattern
  6. Summary - Advanced traits

12 Const generics

  1. [T; N]
  2. const fn
  3. Const trait bound
  4. Min_const_generics
  5. Array and slice
  6. Summary - Const generics

13 Advanced patterns

  1. Struct patterns
  2. Destructuring
  3. @ binding
  4. Guard
  5. Binding modes
  6. Summary - Advanced patterns

14 Advanced final

  1. Async web server
  2. ThreadPool
  3. derive macro
  4. FFI wrapper