Procedural macros

Parser for Rust source code Syn is a parsing library for parsing a stream of Rust tokens into a syntax tree of Rust source code. Currently this librar

derive_more Rust has lots of builtin traits that are implemented for its basic types, such as Add, Not, From or Display. However, when wrapping these

Rust Quasi-Quoting This crate provides the quote! macro for turning Rust syntax tree data structures into tokens of source code. Procedural macros in

getset Getset, we're ready to go! A procedural macro for generating the most basic getters and setters on fields. Getters are generated as fn field(&s

Rust mdo Presentation Rust mdo is a monadic do notation using macros and duck typing. It provides a syntax extension providing something that looks li

Procedural macros in expression position As of Rust 1.30, the language supports user-defined function-like procedural macros. However these can only b

procspawn This crate provides the ability to spawn processes with a function similar to thread::spawn. Unlike thread::spawn data cannot be passed by t

I thought Rust doesn't have reflection...? This crate explores what it could look like to tackle the 80% use case of custom derive macros through a pr

absolution "Freedom from syn" This crate provides an introspectible token tree representation for writing Rust proc macros. It's still somewhat unstab

Blackjack Your Rusty 🦀 procedural 3d modeler Blackjack is a procedural modelling application, following the steps of great tools like Houdini or Blen

Crepe   Crepe is a library that allows you to write declarative logic programs in Rust, with a Datalog-like syntax. It provides a procedural macro tha

derive-ocaml - Custom derive and procedural macros for easier ocaml <-> rust FFI WARNING this crate is very experimental derive-ocaml is based on top

spanr A tool for procedural macro authors to be able to interactively view and debug the Spans on generated code. Screenshot Example usage #[proc_macr

Debug Plotter This crate provides a convenient macro to quickly plot variables. Example In this example, we quickly want to plot the variables a, b, a

Rust Quasiquoter This crate implements the quote! macro as a procedural macro, instead of the original quote! macro, implemented with macro_rules!. Th

Proc Macro Roids Traits and functions to make writing proc macros more ergonomic. proc_macro_roids = "0.7.0" Makes writing procedural macros much easi

toml-cfg Rough ideas: Crates can declare variables that can be overridden Anything const, e.g. usize, strings, etc. (Only) The "root crate" can overri

Advent of Code helper This crate provides a macro to generate a handful main for your advent of code participation. The intention is to provide someth

parse-generics This repository contains several pieces related to the proposed RFC #1583: parse-generics-poc - a proof-of-concept implementation of th

Pipette A small crate for using pipes in Rust. use pipette::{Pipeline, pipe}; let input = 1; let output = pipe(( input |a| a * 2, |a| a

valq   valq provides a macro for querying and extracting value from structured data in very concise manner, like the JavaScript syntax. Look & Feel: u

Adds #[zoet] macro to reduce boilerplate when implementing common traits. If you are sick of writing impl Deref for Bar etc. and it didn't compile bec

gpt3_macro Rust macro that uses GPT3 codex to generate code at compiletime. Just describe what you want the function to do and (optionally) define a f

js-macros Quickly prototype Rust procedural macros using JavaScript or TypeScript! Have you ever thought "this would be a great use case for a procedu

inner - The inner! macro descends into an enum variant. It’s more flexible than try!() and unwrap(), and it works with your enum, too!

macro enum-ordinalize - This crates provides a procedural macro to let enums not only get its variants’ ordinal but also be constructed from an ordinal

inline-rust This is a stupid macro inspired by inline-python that compiles and executes Rust and spits the output directly into your Rust code. There