Rust Macros Quiz

0 Passed

0% acceptance

Master Rust's metaprogramming system with declarative and procedural macros for code generation and compile-time programming

40 Questions

~80 minutes

Question 1

What is a macro in Rust?

Code that generates code at compile time

Runtime code execution

Function that returns values

Macros don't exist in Rust

Question 2

What is the difference between macros and functions?

Macros generate code, functions execute code; macros can take variable args

They are identical

Functions are more powerful

No difference

Question 3

What does macro_rules! define?

Declarative macro using pattern matching rules

Procedural macro

Function macro

macro_rules! doesn't exist

Question 4

What does this basic macro example do?

rust

macro_rules! say_hello {
    () => {
        println!("Hello!");
    };
}

say_hello!();

Expands to println!("Hello!") at compile time

Compilation error

Runtime error

Does nothing

Question 5

What are macro fragments (designators)?

Matchers like $x:expr, $y:ty for different code elements

Macro arguments

Macro output

Fragments don't exist

Question 6

What does this parameterized macro show?

rust

macro_rules! multiply {
    ($x:expr, $y:expr) => {
        $x * $y
    };
}

let result = multiply!(2 + 3, 4);

Expands to (2 + 3) * 4, result is 20

Compilation error

Expands to 2 + 3 * 4

Runtime error

Question 7

What is macro repetition?

Using $(...)* to repeat patterns zero or more times

Macro execution multiple times

Loop inside macro

Repetition doesn't exist

Question 8

What does this repetition macro do?

rust

macro_rules! vec_macro {
    ($($x:expr),*) => {
        {
            let mut temp_vec = Vec::new();
            $(temp_vec.push($x);)*
            temp_vec
        }
    };
}

Creates Vec from comma-separated expressions

Compilation error

Creates array

Runtime error

Question 9

What is macro hygiene?

Prevention of variable name conflicts between macro and call site

Macro cleanliness

Macro performance

Hygiene doesn't exist

Question 10

What is variable capture in macros?

When macro variables shadow or conflict with call site variables

Variable assignment

Variable declaration

Capture doesn't exist

Question 11

What does $crate mean in macros?

Refers to crate where macro is defined, hygiene bypass

Current crate

Macro crate

$crate doesn't exist

Question 12

What are procedural macros?

Macros that run Rust code to generate code, more powerful than declarative

Step-by-step macros

Function-like macros

Procedural macros don't exist

Question 13

What are the three types of procedural macros?

Custom derive, attribute-like, function-like

Declarative, procedural, functional

Simple, complex, advanced

No types exist

Question 14

What is a custom derive macro?

Generates impl blocks for traits based on struct/enum fields

Derives functions

Derives variables

Custom derive doesn't exist

Question 15

What is the syn crate used for?

Parsing Rust code into AST for procedural macros

Syntax highlighting

Code generation

syn doesn't exist

Question 16

What is quote crate used for?

Generating Rust code from AST back to TokenStream

Code quoting

String manipulation

quote doesn't exist

Question 17

What does this custom derive skeleton show?

rust

use proc_macro::TokenStream;
use syn::{parse_macro_input, DeriveInput};
use quote::quote;

#[proc_macro_derive(MyTrait)]
pub fn my_trait_derive(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);
    let name = &ast.ident;
    let gen = quote! {
        impl MyTrait for #name {
            // implementation
        }
    };
    gen.into()
}

Basic structure of custom derive macro using syn and quote

Compilation error

Runtime macro

Declarative macro

Question 18

What is an attribute-like macro?

#[my_macro] that can appear on items, generates or modifies code

Function attribute

Variable attribute

Attribute macros don't exist

Question 19

What is a function-like macro?

my_macro!(...) that looks like function call but generates code

Regular function

Method

Function-like macros don't exist

Question 20

What is TokenStream?

Sequence of tokens representing Rust source code

Data stream

Binary stream

TokenStream doesn't exist

Question 21

What is macro expansion?

Process where macros are replaced with generated code

Code execution

Compilation

Expansion doesn't exist

Question 22

How do you debug macro expansion?

Use cargo expand or intellij-rust's macro expansion

Use println! in macro

Use debugger

Cannot debug macros

Question 23

What is macro recursion?

Macro calling itself or other macros in expansion

Runtime recursion

Function recursion

Recursion doesn't exist in macros

Question 24

What is TT muncher pattern?

Recursive macro pattern that processes tokens one by one

Token eating

Pattern matching

TT muncher doesn't exist

Question 25

What does this TT muncher example show?

rust

macro_rules! my_vec {
    ($($x:expr),* $(,)?) => {
        {
            let mut temp = Vec::new();
            $(temp.push($x);)*
            temp
        }
    };
}

Handles optional trailing comma in macro arguments

Compilation error

Required comma

Runtime error

Question 26

What is macro shadowing?

Local macro definition shadows global one

Variable shadowing

Function overriding

Shadowing doesn't exist in macros

Question 27

What is the difference between macro_rules! and procedural macros?

macro_rules! is simpler but limited, procedural more powerful but complex

They are identical

macro_rules! is better

No difference

Question 28

What is the performance impact of macros?

Compile-time cost only, no runtime overhead

Runtime performance cost

Memory overhead

No performance impact

Question 29

What is macro export?

#[macro_export] makes macro available to other crates

Macro distribution

Macro printing

Export doesn't exist

Question 30

What is the problem with this macro?

rust

macro_rules! bad_macro {
    ($x:expr) => {
        let y = 2;
        $x + y
    };
}

Variable y may conflict with call site variables

Compilation error

Runtime error

No problem

Question 31

What is a common use case for macros?

DSL creation, reducing boilerplate, compile-time code generation

Runtime code execution

Dynamic typing

No common use cases

Question 32

What is the difference between macro and const fn?

Macros generate code at any position, const fn limited to values

They are identical

const fn is more powerful

No difference

Question 33

What is macro_rules_transducer?

Tool for debugging macro expansion step by step

Macro transformer

Code generator

Doesn't exist

Question 34

What is the recursion limit for macros?

Default 64, prevents infinite recursion

No limit

1000

Limit doesn't exist

Question 35

What is a macro anti-pattern?

Using macros when functions would work, overly complex macros

Simple macros

Well-documented macros

No anti-patterns

Question 36

What is the difference between local and global macros?

Local macros visible in scope, global exported with #[macro_export]

They are identical

Local are faster

No difference

Question 37

What is the problem with macros in expressions?

Macros can expand to multiple statements where single expression expected

Type checking

Performance

No problem

Question 38

What is declarative macro limitation?

Cannot inspect code structure, only pattern match syntax

Too powerful

Too slow

No limitations

Question 39

What is the future of macros in Rust?

Procedural macros becoming more important, better tooling

Macros being removed

No changes

Future unknown

Question 40

In a project needing to generate repetitive code for database models, create a DSL for configuration, and implement custom serialization logic, which macro approaches would you choose and why?

Custom derive for serialization, procedural macros for DSL, macro_rules! for simple repetition

Only functions

Only procedural macros

No macros needed

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Python

29 quizzes

Introduction & Core Fundamentals

Data Types & Zero Values

Operators & Expressions

C++

26 quizzes

Basics

Variables & Data Types

Operators & Expression

Java

22 quizzes

Java Basics & JVM Fundamentals

Variables, Data Types & Type Casting

Operators & Expressions

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Rust

Cargo and Project Setup

40 comprehensive questions on Rust's package manager Cargo, covering project initialization, building, running, project structure, and dependency management — with 15 code examples demonstrating practical Cargo usage.

Variables and Mutability

40 comprehensive questions on Rust's variable system, covering let bindings, mut keyword, shadowing, type inference, and constants — with 12 code examples demonstrating practical variable usage patterns.

Data Types

45 comprehensive questions on Rust's type system, covering scalar types, compound types, type conversions, numeric operations, and string types — with 15 code examples demonstrating practical type usage patterns.

Control Flow

45 comprehensive questions on Rust's control flow constructs, covering if expressions, loops, and control flow keywords — with 15 code examples demonstrating practical control flow usage.

Functions

40 questions covering function parameters, return values, expressions, diverging functions, and function scope in Rust.

Ownership

45 in-depth questions covering Rust's ownership system, move semantics, copy types, resource cleanup through Drop trait, precise drop timing, and ownership transfer patterns — with 12 code examples to solidify understanding.

Borrowing

45 in-depth questions covering Rust's borrowing system, immutable and mutable references, aliasing rules, reference scopes, and borrow checker validation — with 13 code examples to solidify understanding.

Lifetimes

40 in-depth questions covering Rust's lifetime system, lifetime annotations, elision rules, function signatures with lifetimes, struct references, and common lifetime errors — with 11 code examples to solidify understanding.

Strings

40 comprehensive questions on Rust's string types, covering String vs &str, UTF-8 behavior, slicing, mutating strings, and conversions — with 11 code examples demonstrating practical string handling patterns.

Collections

40 comprehensive questions on Rust's collection types, covering Vec, HashMap, VecDeque, iteration patterns, and capacity management — with 11 code examples demonstrating practical collection usage.

Slices

40 comprehensive questions on Rust's slice types, covering borrowed views, indexing, mutable slices, ranges, and slice methods — with 11 code examples demonstrating practical slice usage patterns.

Pattern Matching

40 comprehensive questions on Rust's pattern matching system, covering match expressions, destructuring, guards, wildcards, and enum matching — with 11 code examples demonstrating practical pattern matching techniques.

Enums

40 comprehensive questions on Rust's enum system, covering simple variants, data-carrying variants, enum matching, methods on enums, and Option/Result patterns — with 11 code examples demonstrating practical enum usage.

Struct

40 comprehensive questions on Rust's struct system, covering named fields, tuple structs, methods, associated functions, and field ownership — with 11 code examples demonstrating practical struct usage.

Modules

40 comprehensive questions on Rust's module system, covering module creation, visibility, imports, paths, and the use keyword — with 11 code examples demonstrating practical module organization patterns.

Traits

40 comprehensive questions on Rust's trait system, covering trait definitions, implementations, bounds, associated types, and trait objects — with 11 code examples demonstrating practical trait usage patterns.

Generic

40 comprehensive questions on Rust's generic programming system, covering generic functions, structs, enums, impl blocks, and monomorphization — with 11 code examples demonstrating practical generic usage patterns.

Iterators

Master Rust's powerful iterator system for efficient data processing and transformation

Closures

Master Rust's closure system for capturing environment variables and creating flexible function-like constructs

Error Handling

Master Rust's robust error handling system with Result, Option, and the ? operator for reliable code

File and I/O Operations

Master Rust's file system operations and I/O handling for robust data persistence and streaming

Smart Pointers

Master Rust's smart pointer types for automatic memory management and safe heap allocation

Concurrency

Master Rust's concurrency model with threads, channels, and synchronization primitives for safe parallel programming

Async Programming

Master asynchronous programming in Rust with futures, async/await, and concurrent execution patterns

Memory Management

Deep dive into Rust's ownership system, borrowing rules, and advanced memory management patterns for safe and efficient code

Macros

Master Rust's metaprogramming system with declarative and procedural macros for code generation and compile-time programming

Attributes

Master Rust's attribute system for conditional compilation, testing, documentation, and code generation

Testing

Master comprehensive testing strategies in Rust including unit tests, integration tests, documentation tests, and testing best practices

Crate Architecture

Master the design and organization of Rust crates including module systems, workspace management, dependency handling, and publishing strategies

Performance and Optimization

Master advanced performance techniques in Rust including profiling, benchmarking, memory optimization, and compiler optimizations

Rust Macros Quiz

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Question 21

Question 22

Question 23

Question 24

Question 25

Question 26

Question 27

Question 28

Question 29

Question 30

Question 31

Question 32

Question 33

Question 34

Question 35

Question 36

Question 37

Question 38

Question 39

Question 40

What are Macros in Rust?

What You Will Practise

Other Quiz Categories

QUIZZES IN Rust

Cargo and Project Setup

Variables and Mutability

Data Types

Control Flow

Functions

Ownership

Borrowing

Lifetimes

Strings

Collections

Slices

Pattern Matching

Enums

Struct

Modules

Traits

Generic

Iterators

Closures

Error Handling

File and I/O Operations

Smart Pointers

Concurrency

Async Programming

Memory Management

Macros

Attributes

Testing

Crate Architecture

Performance and Optimization