book

Write Powerful Rust Macros

Name: Write Powerful Rust Macros
Author: Sam Van Overmeire
ISBN: 9781633437494

by Sam Van Overmeire

June 2024

Beginner to intermediate

320 pages

8h 59m

English

Manning Publications

Read now

Unlock full access

copyright
contents
Write Powerful Rust Macros
preface
acknowledgments
about this book
about the author
about the cover illustration
1 Going meta
1.1 A day in the life of a Rust developer1.2 What is metaprogramming?1.3 Metaprogramming in Rust1.3.1 Macro galore1.3.2 Appropriate use cases1.3.3 Unfit for purpose: When not to use macros1.4 Approach of this book
2 Declarative macros
2.1 Creating vectors2.1.1 Syntax basics2.1.2 Declaring and exporting declarative macros2.1.3 The first matcher explained2.1.4 Nonemtpy matchers2.2 Use cases2.2.1 Varargs and default arguments2.2.2 More than one way to expand code2.2.3 Newtypes2.2.4 DSLs2.2.5 Composing is easy2.2.6 Currying, on the other hand . . .2.2.7 Hygiene is something to consider as well2.3 From the real world

3 A “Hello, World” procedural macro
3.1 Basic setup of a procedural macro project3.2 Analyzing the procedural macro setup3.3 Generating output3.4 Experimenting with our code3.5 cargo expand3.6 The same macro—without syn and quote3.7 From the real world
4 Making fields public with attribute macros
4.1 Setup of an attribute macro project4.2 Attribute macros vs. derive macros4.3 First steps in public visibility4.4 Getting and using fields4.5 Possible extensions4.6 More than one way to parse a stream4.6.1 Delegating tasks to a custom struct4.6.2 Implementing the Parse trait4.6.3 Going low, low, low with cursor4.7 Even more ways to develop and debug4.8 From the real world
5 Hiding information and creating mini-DSLs with function-like macros
5.1 Hiding information5.1.1 Setup of the information-hiding macro5.1.2 Recreating the struct5.1.3 Generating the helper methods5.2 Debugging by writing normal code5.3 Composing5.4 Anything you can do, I can do better5.5 From the real world
6 Testing a builder macro
6.1 Builder macro project setup6.2 Fleshing out the structure of our setup6.3 Adding white-box unit tests6.4 Black-box unit tests6.4.1 A happy path test6.4.2 A happy path test with an actual property6.4.3 Testing enables refactoring6.4.4 Further improvements and testing6.4.5 An alternative approach6.4.6 Unhappy path6.5 What kinds of unit tests do I need?6.6 Beyond unit tests6.7 From the real world
7 From panic to result: Error handling
7.1 Errors and control flow7.2 Pure and impure functions7.3 Alternatives to exceptions7.4 Rust’s Result and panics7.5 Setup of the panic project7.6 Mutable or immutable returns7.7 Getting results7.8 Don’t panic7.8.1 Changing the panic into a Result7.8.2 Debugging observations7.9 Error-handling flavors7.9.1 Using syn for error handling7.9.2 Using proc_macro_error for error handling7.9.3 Deciding between syn and proc_macro_error7.10 From the real world
8 Builder with attributes
8.1 A rename attribute8.1.1 Testing the new attribute8.1.2 Implementing the attribute’s behavior8.1.3 Parsing variations8.2 Alternative naming for attributes8.3 Sensible defaults8.4 A better error message for defaults8.5 Build back better8.5.1 Avoiding illegal states and the type state pattern8.5.2 Combining the builder pattern with type state8.6 Avoiding scattered conditionals8.7 Attribute tokens and attributes8.8 Other attributes8.9 From the real world
9 Writing an infrastructure DSL
9.1 What is IaC? What is AWS?9.2 How our DSL works9.3 Parsing our input9.3.1 Project setup and usage examples9.3.2 Implementing the Parse trait for our structs9.4 Two alternative parsing approaches9.4.1 Using Punctuated with a custom struct9.4.2 Using Punctuated with a custom enum and builder9.5 Actually creating the services9.6 The two AWS clients9.7 Errors and declarative macros9.8 The right kind of testing9.9 From the real world
10 Macros and the outside world
10.1 A function-like configuration macro10.1.1 Macro project structure10.1.2 Code overview10.1.3 Using full paths10.2 Adding another macro10.3 Features10.4 Documenting a macro10.5 Publishing our macro10.6 From the real world10.7 Where to go from here
appendix Exercise solutions

Content preview from Write Powerful Rust Macros

5 Hiding information and creating mini-DSLs with function-like macros

This chapter covers

Hiding information to improve code
Using function-like macros to modify and extend code
Using function-like macros to manipulate structs and functions
Debugging macros by getting the compiler or IDE to help you
Writing DSLs with flexible function-like macros
Deciding what macro fits a use case

The third and final type of procedural macro is the function-like macro, which—unlike the other two—is not limited to annotating structs, enums, and the like. Here, two examples will demonstrate its power. In our first example, we will stay close to familiar grounds by sticking to manipulating structs. Wilder experiments can wait until later in this chapter ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781633437494Publisher Support Publisher Website Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Write Powerful Rust Macros

by Sam Van Overmeire