Types

Write macros with type parameters like $ty:ty.

Fragment types

The fragment type says which code piece the macro expects:

$x:expr     // expression: 1 + 2, f(x)
$x:ident    // identifier: ad, Kutu
$x:ty       // type: u32, Vec<String>
$x:pat      // pattern: Some(_), 1..=5
$x:block    // block: { .. }
$x:item     // item: fn, struct, impl
$x:literal  // literal: 42, "metin"
$x:tt       // a single token tree (anything)

ident and ty let macros generate function and type definitions; this is impossible with functions.

An item-generating macro

To reduce repetitive definitions to a single line:

macro_rules! sabit_fn {
    ($ad:ident, $tur:ty, $deger:expr) => {
        fn $ad() -> $tur {
            $deger
        }
    };
}

sabit_fn!(surum, &'static str, "1.0");
sabit_fn!(port, u16, 8080);
println!("{} {}", surum(), port());

The standard library generates dozens of trait implementations for number types with macros like this.

Exercise Function-generating macro

Write the sabit_fn! macro above and generate the functions surum (&'static str, "1.0") and port (u16, 8080). Print the results of both functions separated by a space.

Show example solution

macro_rules! sabit_fn {
    ($ad:ident, $tur:ty, $deger:expr) => {
        fn $ad() -> $tur {
            $deger
        }
    };
}

sabit_fn!(surum, &'static str, "1.0");
sabit_fn!(port, u16, 8080);

fn main() {
    println!("{} {}", surum(), port());
}

Test yourself

Which fragment is needed for a macro to generate a new function name?
- literal
- ident
- expr
- ty
Show answer

ident — A name taken with $ad:ident is used in the body as fn $ad().

Type fragment

macro_rules! sabit_fn {
    ($ad:ident, $tur:____, $deger:expr) => {
        fn $ad() -> $tur { $deger }
    };
}

Show answer

macro_rules! sabit_fn {
    ($ad:ident, $tur:ty, $deger:expr) => {
        fn $ad() -> $tur { $deger }
    };
}

Fragment and example

ident

surum
ty

&'static str
expr

"1.0"
pat

Some(_)

Next lesson: Macro hygiene

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies