-
memchr
Safe interface to memchr
-
once_cell
Single assignment cells and lazy values
-
async-trait
Type erasure for async trait methods
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
bitflags
A macro to generate structures which behave like bitflags
-
float-cmp
Floating point approximate comparison traits
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
anyhow
Flexible concrete Error type built on std::error::Error
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
synstructure
Helper methods and macros for custom derives
-
derivative
A set of alternative
deriveattributes for Rust -
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
educe
This crate provides procedural macros to help you implement Rust-built-in traits quickly
-
typed-builder
Compile-time type-checked builder derive
-
enum_dispatch
Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed
-
memoffset
offset_of functionality for Rust structs
-
snafu
An ergonomic error handling library
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive -
ordered-float
Wrappers for total ordering on floats
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
beef
More compact Cow
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren’t compiler hackers
-
frunk
Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
async-recursion
Recursion for async functions
-
tap
Generic extensions for tapping values in Rust
-
io-lifetimes
A low-level I/O ownership and borrowing library
-
typenum
Typenum is a Rust library for type-level numbers evaluated at compile time. It currently supports bits, unsigned integers, and signed integers. It also provides a type-level array of type-level numbers…
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
az
Casts and checked casts
-
thiserror
derive(Error)
-
uninit
A collection of tools for a safer usage of uninitialized memory
-
annotate-snippets
Library for building code annotations
-
pin-project
A crate for safe and ergonomic pin-projection
-
displaydoc
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
indoc
Indented document literals
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
tt-call
Token tree calling convention
-
standback
New standard library, old compiler
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
hex-literal
Procedural macro for converting hexadecimal string to byte array at compile time
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
retain_mut
Provide retain_mut method that has the same functionality as retain but gives mutable borrow to the predicate
-
geo-types
Geospatial primitive data types
-
float-ord
A total ordering for floating-point numbers
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
conv
This crate provides a number of conversion traits with more specific semantics than those provided by ‘as’ or ‘From’/‘Into’
-
inlinable_string
The
inlinable_stringcrate provides theInlinableStringtype – an owned, grow-able UTF-8 string that stores small strings inline and avoids heap-allocation – and theStringExt… -
frunk_derives
frunk_derives contains the custom derivations for certain traits in Frunk
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
joinery
A small crate for generically joining iterators with a separator
-
k8-client
Core Kubernetes metadata traits
-
with_locals
Function attribute to return references to locals by using CPS
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
if_chain
Macro for writing nested
if letexpressions -
approx
Approximate floating point equality comparisons and assertions
-
cynic
A GraphQL query builder & data mapper for Rust
-
assertables
Assertables: Rust crate of macros
assert…!,assume…!,assure…!, all for runtime reliability checking. By SixArm.com. -
tokenlock
Provides cell types that decouple permissions from data
-
safe-transmute
A safeguarded transmute() for Rust
-
lazy-static-include
This crate provides
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
buffered-reader
A super-powered Reader
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
advent-of-code
Solutions to Advent of Code
-
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]checks -
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
evcxr_repl
A REPL for Rust
-
stdext
Extensions for the Rust standard library structures
-
failsafe
A circuit breaker implementation
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
enum-kinds
Generate enums with matching variants but without any of the associated data
-
blanket
A simple macro to derive blanket implementations for your traits
-
typestate
A proc macro DSL for typestates
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the “hidden lifetime in impl Trait” issue
-
quick-error
A macro which makes error types pleasant to write
-
unchecked_unwrap
Adds an unchecked version of
unwrap()andexpect()to Option and Result -
peeking_take_while
Like
Iterator::take_while, but calls the predicate on a peeked value. This allows you to useIterator::by_refandIterator::take_whiletogether, and still get the first value… -
scopeguard
A RAII scope guard that will run a given closure when it goes out of scope, even if the code between panics (assuming unwinding panic). Defines the macros
defer!, `defer_on_unwind… -
mode
A behavioral state machine library written in Rust
-
auto_enums
A library for to allow multiple return types by automatically generated enum
-
pipe-trait
Make it possible to chain regular functions
-
cryo
Extend the lifetime of a reference. Safely.
-
prima_bridge
A library to implement the bridge pattern
-
semval
Semantic validation
-
sealed
Macro for sealing traits and structures
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
smart-default
Rust custom-derive macro for Default with more control on the fields
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
concat-idents
Allows concatenating multiple identifiers and using them everywhere
-
ffi_helpers
A crate to help make working with FFI easier
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
lazy_format
A utility crate for lazily formatting values for later
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
delegate-attr
Attribute proc-macro to delegate method to a field
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
v_escape_derive
Procedural macro package for v_escape
-
sugars
An useful collection of macros to make tasks easier
-
extend
Create extensions for types you don’t own with extension traits but without the boilerplate
-
cast
Ergonomic, checked cast functions for primitive types
-
maybe-owned
provides a
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
drop_guard
The drop_guard crate enables you to implement the Drop trait on any type. So you can run a closure on any value running out of scope
-
abi_stable_derive
Implementation detail of abi_stable
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
variant_count
Derive macro for enum which adds to it the count of variants
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
bool_ext
A crate which defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
shellexpand
Shell-like expansions in strings
-
random-number
Generate random numbers quickly
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
bounded-integer
Bounded integers
-
one_err
OneErr to rule them all
-
intertrait
Allow for inter-trait casting
-
simple_parse
A declarative converter for Rust type to and from binary
-
easy-error
Simple error utilities
-
drop_bomb
A runtime guard for implementing linear types
-
gazebo
A collection of well-tested utilities
-
take_mut
Take a T from a &mut T temporarily
-
tylift
Lift enum variants to the type-level
-
tryhard
Easily retry futures
-
downcast
Trait for downcasting trait objects back to their original types
-
data-rw
io buffer write reader
-
compound-error
Compound errors with flat hierarchy
-
rust_info
Extracts the current rust compiler information
-
require_unsafe_in_body
Make
unsafe fnstill requireunsafeblocks in the function’s body -
rust-fsm-dsl
Macros for rust-fsm DSL
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
enum-iterator-derive
Procedural macro to iterate over the variants of a field-less enum
-
deltoid
A library to calculate and apply deltas to structs and enums
-
fallible_collections
a crate which adds fallible allocation api to std collections
-
utils-results
The easiest and most intuitive error handling solution
-
try_match
An expression macro to match a pattern and return the bound variables in
Result -
djin-protocol-derive
A for of protocol, for aoe-djin
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator -
dict_derive
Derive macros for some PyO3 traits to convert python dicts into rust structs
-
bitwrap_derive
macro for bitwrap
-
event-listener-primitives
Low-level primitive for building Node.js-like event listeners
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
components-arena
Simple library for creating complex domain-specific self-referential data structures
-
result-like
Option/Result-like monad interface for your own enum
-
esrs
A Prima.it-opinionated library to achieve cqrs/es
-
macrofied-toolbox
This library provides an ergonomic experience of adding debugging messages to rust’s Result<T,E> and Option patterns
-
fstrings
Python3 fstring interpolation in Rust
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
builder-pattern
A derivable macro for declaring a builder pattern
-
batch_oper
batch_oper provides some batch operation macro for some operations
-
send_wrapper
This Rust library implements a wrapper type called SendWrapper which allows you to move around non-Send types between threads, as long as you access the contained value only from within the original thread…
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
concat-with
Extend the function of the
concat!macro instd -
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
chalk-derive
A helper crate for use by chalk crates for
derivemacros -
thiserror-impl
Implementation detail of the
thiserrorcrate -
teloc
Simple, compile-time DI framework for Rust
-
beaver
A library for setting up Rust objects inspired by factory_bot
-
arraygen
Derive macro for generating arrays from struct fields
-
bit_field
Simple bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust’s integral types
-
variant_access_traits
A set of traits and for defining a common api for Rust enums based on the std::variant api in the C++ standard library
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
include-flate
A variant of include_bytes!/include_str! with compile-time deflation and runtime lazy inflation
-
structmap
Procedural macro library for converting between Rust structs and associative containers
-
apparat
A lightweight event-driven behavioral state machine
-
rsb_derive
An opinionated macros implementation for Rust struct builder pattern
-
tabled_derive
Derive macros which is used by tabled crate
-
join
Macros which provide useful shortcut combinators, combine sync/async chains, support single and multi thread (sync/async) step by step execution of branches, transform tuple of results in result of tuple
-
round
This crate provides utilities to round your floats with precision from 1 to 10
-
shaku
Compile Time Dependency Injection for Rust
-
validator_types
Basic type for validator and validator_derive
-
tracerr
Custom compile-time captured error tracing
-
cast_trait_object
Cast between trait objects using only safe Rust
-
messages
Runtime-agnostic actor library
-
fixnum
Fixed-point numbers with explicit rounding
-
rand_derive2
Generate customizable random types with the rand crate
-
bitmask-enum
A bitmask enum attribute macro
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
dynamize
trait objects with variable associated types
-
funty
Trait generalization over the primitive types
-
xladd-derive
A simple macro that helps write Excel UDF functions in Rust
-
iter-comprehensions
A library for iterator comprehensions
-
lens-rs
lens implemented in rust
-
stackalloc
Safely allocate and manipulate arbitrarily-sized slices on the stack at runtime
-
tuple_list
Crate for macro-free variadic tuple metaprogramming
-
pre-proc-macro
Procedural marco implementations for pre
-
dyn-context
Non-owning service provider pattern implementation
-
shrinkwraprs
Auto-derive for Rust conversion traits – make working with newtypes a breeze
-
assume
Macro for stating unsafe assumptions in Rust
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
exec-rs
Library that provides utility traits for task execution and, if the sync feature is enabled, the ability to synchronise tasks based on the value of a key
-
derived
Derive macros for automating the boring stuff
-
predicates-core
An API for boolean-valued predicate functions
-
by_address
Wrapper for comparing and hashing pointers by address
-
staticinit
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
anymap
A safe and convenient store for one value of each type
-
simple-error
A simple error type backed by a string
-
impls
Determine if a type implements a logical trait expression
-
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
frunk_proc_macro_helpers
Common internal functions for frunk’s proc macros
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
lazycell
A library providing a lazily filled Cell struct
-
serbia
No-fuss big arrays for Serde
-
fnichol-cime
A demonstration of a Rust CI build/test/release workflow supporting multi-platform testing, binary builds, Docker image building, and Crates.io publishing
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
validated
The cumulative sibling of
ResultandEither -
warnalyzer
Show unused code from multi-crate Rust projects
-
macro-attr-2018
This crate provides the
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
tuirealm_derive
Derive macro which automatically implements the MockComponent trait
-
derive_deref
Adds
#[derive(Deref)]and#[derive(DerefMut)] -
yui
An attribute reader generator for Rust
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
lset
Data types describing linear sets
-
macro_rules_attribute
Use declarative macros as proc_macro attributes or derives
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
unroll
An attribute-like procedural macro for unrolling for loops
-
grouping_by
A simple library which allows the user to group an iterator by various ways
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
tia
tia; trait, impl, accessors | automatic
-
enumx
Ad-hoc enum extension
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
assert2-macros
procedural macros for assert2
-
roopert_macro_root
Another object-oriented toolkit for Rust (macro)
-
iter_fixed
Iterator of fixed length
-
abi_stable_shared
Implementation detail of abi_stable
-
nshare
Conversion between n-dimensional types in different Rust crates
-
manifest-dir-macros
This crate provides function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
safecast
Traits to define safe casting between types
-
str-macro
The str!() macro, similar to vec![] but for strings
-
tuples
Provides many useful tools related to tuples
-
mbox
malloc-based box. Supports wrapping pointers or null-terminated strings returned from malloc as a Rust type, which will be free’d on drop
-
boomphf
Scalable and Efficient Minimal Perfect Hash Functions
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
chainerror
Make chaining errors easy
-
big_mac
A metamacro toolkit for writing complex macros
-
gumdrop
Option parser with custom derive support
-
treeflection_derive
#[derive(Node)] macro for the Treeflection library
-
direction
Representations of directions
-
dynomite-derive
Derives AWS DynamoDB dynomite types from native Rust struct types
-
ts-rs-macros
derive macro for ts-rs
-
sanitizer_macros
Derive macro for the sanitizer crate
-
derive-try-from-primitive
Custom derive a try_from method for primitive to enum conversions
-
clone_cell
A Cell that works with a restrictive form of Clone
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_partsandVec::into_raw_parts -
toy-arms_derive
A derive macro crate for toy-arms
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
dynerr
Macros for dynamic error handling
-
tor-checkable
Types to ensure that signed or time-bound data is validated before use
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
snafu-derive
An ergonomic error handling library
-
shoulda
derive macro for test assertions
-
hado
Monadic do notation using a macro
-
num_enum_derive
Internal implementation details for ::num_enum (Procedural macros to make inter-operation between primitives and enums easier)
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
chassis
Compile-time dependency injection framework
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
tc-error
TinyChain’s generic error struct
-
gtmpl_derive
Derive for gtmpl_value
-
error_def
A Rust syntax extension for generating error-handling boilerplate code
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
fn_meta
Returns metadata about a function at runtime
-
tokio-pg-mapper
Proc-macro library used to map a tokio-postgres row to a Rust type (struct)
-
tide-tera
Use tera templates on tide
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
lifelink
Erase covariant lifetime parameters from anything, with generic associated types
-
market
Infrastructure for producers and consumers
-
gazebo_derive
Derive macros for the Gazebo library
-
geo-postgis
Conversion between
geo-typesandpostgistypes -
percolate
Yet another async utility library
-
devx-cmd
Convenience wrapper over std::process::Command for xtask crates
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the relative difference
-
snailquote
Escape and unescape strings with shell-inspired quoting
-
tupleops
Utility library to work with tuples
-
problem
Error handling for command line applications or prototypes
-
fehler
A library for error-handling syntax in Rust
-
ff_derive_ce
Procedural macro library used to build custom prime field implementations
-
ebacktrace
A simple error wrapper which captures a backtrace and can carry an optional textual description
-
parquet_derive
Derive macros for the Rust implementation of Apache Parquet
-
entwine
Generic slice-like interface for operating on multiple slices at the same time
-
retry-error
An error type for an operation that can fail more than once
-
generics
Provides macros for parsing generics (with optional where clause) in
macro_rules! -
strong
Strongly typed String
-
ambassador
Trait implementation delegation via procedural macros
-
progress-streams
Progress callbacks for types which implement Read/Write
-
wrapped-vec
Macro for generating wrapped Vec types and associated boilerplate
-
dispose
A simple wrapper for values that must be consumed on drop
-
format
A utility crate to make it easier to work with the formatter
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
agpu-macro
agpu derive macros
-
maybe-single
A singleton. Maybe.
-
pin-init
Safe pinned-initialization in Rust
-
mox
Mockery Of X(ML): a JSX-alike syntax for the builder pattern
-
enum_derive
This crate provides macros for deriving additional functionality for enums
-
clonesure
A helper macro to create closures which will clone its environment
-
restcrab
Procedural macro to automatically generate a REST client from a trait definition
-
optargs
Easily create macros for functions with optional arguments
-
enum-repr-derive
Simple trait for converting enum to and from its primitive repr type
-
collate
Traits and a data structure to support collation and bisection
-
stidgen
Strongly Typed ID types macro
-
near-safe-cell
A more ergonomic ‘UnsafeCell’ wrapper/replacement
-
fstrings-rust
Python3 fstring interpolation in Rust
-
doc_item
Attributes for item-level documentation customization
-
runestr
User-perceived characters related types and data structures
-
inner
The inner! macro descends into an enum variant. It’s more flexible than try!() and unwrap(), and it works with your enum, too!
-
pin-project-internal
Implementation detail of the
pin-projectcrate -
spectral
Fluent test assertions
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
borked
Simple and convienient error handling library for rust
-
mac
A collection of great and ubiqutitous macros
-
assure
Assure: macros for Rust runtime checks and error handling
-
cute
A macro for Python-esque comprehensions
-
rovv
provide the anonymous row type (poor-man’s row polymorphism) in rust
-
metainfo
Transmissing metainfo across components
-
rsexp-derive
Derive macro for S-expression conversion
-
turbonone
Simple macro for calling functions with Option arguments
-
select_indices
Iterators for taking multiple shared/exclusive references from a slice
-
loop_chain
Macro for writing nested Loop expressions
-
dipa-derive
The derive macro for the dipa crate
-
collected
Summation, product, maximum and more special collectors for Rust iterators
-
current
A library for setting current values for stack scope, such as application structure
-
struple
Convert structures from and to tuples
-
indoc-impl
Indented document literals
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
ad-hoc-iter
Ad-hoc exact size owning iterator macro and other optional utils
-
copy_from_str
An extension trait to copy a string into another string
-
enum-display-derive
Display trait’s custom derive for simple enums
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
derive_setters
Rust macro to automatically generates setter methods for a struct’s fields
-
refl
Provides a
reflencoding which you can use to provide a proof witness that one type is equivalent (identical) to another type. You can use this to encode a subset of what GADTs allow you to in Haskell -
embed-doc-image
Embed images in Rust documentation
-
illicit
An implicit thread-local environment which is indexed by type
-
ees
Simple error-handling library
-
iter-read
A Read implementation for iterators over u8 and related types
-
magic_static
Safe, global singletons initialized at program start
-
degeneric-macros
Hides struct generics into trait associated types
-
enum_variant_type
Generates types for each enum variant and conversion trait impls
-
cell-map
Many-layered 2D cellular generic map
-
aspect
An Aspect Toolkit for Rust
-
ff_derive
Procedural macro library used to build custom prime field implementations
-
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
once
This crate provides an assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
io-extras
File/socket handle/descriptor utilities
-
cex
Checked exception simulation
-
variant_access_derive
Prodedural macros for deriving the VariantAccess traits
-
partial_application
partial function application via the partial! macro
-
en
The easiest numeric traits!
-
shorten
A collection of convenience functions, macros and traits to shorten repetitive code
-
bachue-auto_impl
Automatically implement traits for common smart pointers and closures
-
enhanced_enum
Enhanced Fieldless Enumerations and Associated Array Types
-
fn-error-context
An attribute macro to add context to errors from a function
-
thisisplural
#[derive(Plural)] for creating frictionless new types with a Vec, HashMap, etc
-
cynic-proc-macros
Procedural macro crate for cynic - a GraphQL query builder & data mapper for Rust
-
dep-obj
Dependency object: effective reactive heterogeneous container
-
cccp
The Clippy Code Correctness Project
-
machine
State machine utilities
-
throw
Efficiently add statically-calculated stack traces to errors
-
haz
A thin abstraction over polymorphic environments
-
unzip-n
Procedural macro to generate
unzipfor iterators over n-sized tuples -
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
negate
Attribute macro that generates negated versions of functions that return booleans
-
rocket_sync_db_pools_codegen
Procedural macros for rocket_sync_db_pools
-
enum-iterator
Tools to iterate over the variants of a field-less enum
-
awred
A convenient derive macro for actix_web::ResponseError trait
-
static_assert_macro
Library implementation of so-called
static_assert -
repeated
Allows you to repeat a block of code a number of times
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
enum_macro
Useful macro for enum
-
trackable_derive
Custom derive for
trackablecrate -
enum_index
Trait and macros for extracting Enum variant index
-
timed
Macros to time function execution
-
with-api
Simple macro for shrinking scope
-
build-features
A simple proc macro to create a vector that a list of enabled features in a root package
-
try-catch
A simple proc-macro that enables try-catch for Rust with automatic downcasting of error types
-
multindex
Index slices with multiple const indices/ranges
-
log_err
Log error messages from Unwrap and Expect with log crate
-
ref-map
Helper trait for Option and Result to map references
-
named-block
Macro implementing early-exit-from-any-block
-
itermore
More iterator adaptors
-
bytecheck_derive
Derive macro for bytecheck
-
noneifempty
Convert T to None if empty
-
spez
Macro to specialize on the type of an expression
-
polymorphic-constant
A macro to define a numerical constant in multiple types at once
-
struct-variant
Minimal helper macro to generate an enum out of a list of structs
-
py-comp
A macro implementing a Python-like generator expression
-
structview
Viewing binary data as high-level data structures, safely
-
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
extension-trait
Macro to declare extension traits
-
tealr_derive
The derive macro for tealr
-
quick_from
A derive macro for quickly implementing From on on enum variants that wrap other types
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
displaythis
derive(Display)
-
destruct-drop-derive
Actual derive macro for destruct-drop
-
thread-scoped-ref
A library that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
ratelimit_rs
The ratelimit package provides an efficient token bucket implementation
-
jsonway
JSON building DSL and configurable serializers for Rust
-
lambda_runtime_errors_derive
Rust runtime errors derive for AWS Lambda
-
morphism
A structure for suspended closure composition in Rust
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
merge
Merge multiple values into one
-
throttle_my_fn
Throttle your functions
-
incomplete
Provides incomplete!(), a compile-time checked version of unimplemented!()
-
parity-send-wrapper
This Rust library implements a wrapper type called SendWrapper which allows you to move around non-Send types between threads, as long as you access the contained value only from within the original thread…
-
unseemly
A typed macro language
-
breakable-block
A shim library for a stable implementation of what is proposed in RFC 2046
-
clover
A scripting language
-
boar
Flexible clone on write smart pointers with Borrowed, Owned, Arc, Rc and Static variants. Like std’s Cow without the ToOwned requirement and additional Rc, Arc or Static variants
-
overload
Provides a macro to simplify operator overloading
-
string-eyre
Convenience traits for dealing with errors that don’t want to eyre
-
auto_ops
Macros for easy operator overloading
-
single
Provides the Single trait for extracting the element from a single-element iterator
-
closure
A macro for capturing variables on a per variable basis
-
arrutil
Functions for manipulating arrays from slices
-
package_info_derive
Derive macro for exposing Cargo Package Information to Rust code
-
null-terminated
Library of null-terminated slices and UTF-8-encoded strings with thin references
-
seam
Symbolic Expressions As Markup
-
simple-logging
A simple logger for the log facade
-
init_with
Helper trait to initilize an array with a function
-
hash-db
Trait for hash-keyed databases
-
eventually
Crate for using Event Sourcing in Rust applications
-
sub-array
Extract a sub-array out of an array
-
derive-debug-extras
More customisable #[derive(Debug)]
-
enum-unitary
Trait and macro for unitary enums
-
fuzzypath
Quick & dirty fuzzy path comparison
-
precisej-printable-errno
Printable system call errors for nix
-
bounded_types
Provides a type representing bounded integers, implemented using const generics
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
serializable_enum
Two macros for implementing serialization / deserialization for enums containing no data variants
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
displaydoc-lite
Implement the Display trait using your standard doc comments
-
autowired
Rust dependency injection
-
build-deps
Rust build-script dependencies generator for data/IDL files
-
project-uninit
Macros for safe references to and initialization of fields in MaybeUninit structs
-
range-split
Utilities for splitting sequences with range parameters
-
ward
Provides a ward! macro which returns the contents of an Option and otherwise returns early, and a guard! macro, which does the same, but with a syntax more similar to Swift’s guard syntax
-
ketos_derive
Derive traits for Ketos scripting language
-
kinder
Kinder is a small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
cdrs-tokio-helpers-derive
Derive CDRS helper traits
-
flag-mast
Ergonomic Rust bit flags
-
aerosol
Dependency injection with compile-time guarantees
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
mpesa_derive
MpesaSecuritytrait derive macro crate -
valid
Validate custom types by composing primitive validation functions. Use one common API for validating all kind of business rules including aspects of the application state. One common error type for all…
-
miniserde-enum
Derive macros for miniserde on enums
-
impl-enum
Macro for generating methods on an enum that match on the enum and call the same method on each variant
-
soft_assert
Non-panicking assertions
-
public
A attribute macro used to mark struct/union and its fields as public
-
match_any
Provides a declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
polymorph
A set of utilities to better enable polymorphic behavior in Rust
-
failure_without_backtrace
Experimental error handling abstraction
-
kaguya_rs
Functional Programming tools and ADTs
-
tch-tensor-like-derive
Derive macro implemenations used by tch-tensor-like crate
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
status
Error container
-
defer-lite
A lightweight high-performance implementation of Go’s defer statement
-
dmv_derive
Defines the
Dmvderive macro -
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
rvs-c-api
C-API for Rvs - A library for defining and evaluating random variables using a simple DSL
-
rustils
Utilities for rust
-
quick-error2
A macro which makes error types pleasant to write
-
pfn
Provide fn_trait’s
call,call_mut, andcall_onceon Stable Rust -
cargo-verify
Prettier error messages for the verified crate
-
never
A stable version of the unstable never type (!)
-
edisp
Dispatch-on-collect for Rust enums
-
symm_impl
Attribute macro that automatically implements a symmetric trait
-
roopert
Another object-oriented toolkit for Rust
-
interruptor
Collection of functions generating Unix process signal receivers for use in the Crossbeam Channel select! macro
-
tinytest
Write more compact unit tests with a small macro
-
oxford_join
Join string slices with Oxford Commas!
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
zisvalidator_derive
Derive macro for zisvalidator
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
chain_linq
An implementation of .NET’s LINQ in rust as a declarative macro
-
reax
A reactivity system for Rust that infers dependencies between functions
-
mutview
Derive macro for zordon crate
-
read-restrict
Restrict the number of bytes read from a reader
-
lens-rs_derive
macro to derive lens for data type
-
dyn_partial_eq
PartialEq macros for trait objects
-
postgres-mapper
Struct mapping for postgres
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
ferrite-session
Session Types DSL for Rust
-
typesets-macro
The derive macros for typesets
-
ptr_meta_derive
Macros for ptr_meta
-
constany_blank
Convert any function to constant
-
moveslice
A one-function crate to move chunks in a slice around
-
mdo
Monadic do notation for rust using macro and duck typing
-
fff_derive
Procedural macro library used to build custom prime field implementations
-
singleton-manager
A programatical singleton manager
-
partial_ref_derive
Derives for partial_ref
-
kwarg_macros
Keyword argument plugin
-
lup
A custom indexed loop macro library for Rust
-
as-result
Traits for converting types which may be interpreted as or into a result
-
into_ext
Extension trait for the “Into” trait, offering a method “.into_::()” to specify the target type of conversion
-
pre
Compile-time assistance for working with unsafe code
-
u16cstr
A macro for creating c-style u16 wide strings at compile time
-
annotation-rs
Compile-time annotation parser for rust
-
collect_array
Allows for collecting an Iterator into an exactly sized array
-
relational_types_procmacro
Procmacro to help create relations between objects
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
derive_builder_macro
Rust macro to automatically implement the builder pattern for arbitrary structs
-
socketpair
Cross-platform socketpair functionality
-
swiss-army-knife
Common utility code to support linux-support and other projects
-
struct_field_names
Derive macros for generating the name of each field in a struct and each variant name in an enum as
&'static str -
captures
Provides macros to express more powerful closure captures
-
thiserror_core2
derive(Error) (no_std-enabled using core2)
-
coercible_errors
Zero-cost error handling for generic traits
-
elain
Set a type’s minimum alignment with const generics
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
memory-size-type
A data type for dealing with memory sizes
-
fragile
Provides wrapper types for sending non-send values to other threads
-
itermap
Iterator tools for maps (
HashMap,BTreeMap, etc.) -
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
bingen
Procedure macro for bringing a compile-time compiled assembly code as a binary slice
-
emoji-commit-type
The different commit types used in the emoji committer
-
inline_dyn
A container type for storing dynamically-sized types inline
-
checked_array
A checked API for array types
-
lifted
Higher-kinded types in Rust
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
rust-cef-derive
Macros to derive the ToCef trait implementation for any struct as well as macros to annotate members to map to various CEF headers or key-value pairs. This enables having a structured…
-
high_mem_utils
This crate provides a bunch of mem safe abstractions,some involving transmute
-
seymour-protocol
Client protocol for the seymour gemini feed aggregator
-
bind_match
Convenience macro similar to
matches!but binds to variables in the pattern and returns anOptionof the result -
sum_error
Derive macros for fast summing of error types into error enum
-
whiteout
Provides macros that erase the type of any value into an impl Trait for a given trait
-
simple_parse_derive
A derive macro that implements the simple_parse traits
-
destruct
Destruct structs and enums for simpler combinator implementation
-
ferrum-plugin
Lazily evaluated, order-independent plugins for extensible types
-
derive-into-owned
Custom derives to help with types containing Cow fields
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
derive_di
This crate is realized the dependency injection pattern
-
oauth1-request-derive
A derive macro for
oauth1_request::Requesttrait -
desugar-impl
Sugar for less explicit generics in structs, enums, and union declarations
-
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
vptr-macros
Procedural macros for the
vptrcrate -
rustc-hex
rustc-serialize compatible hex conversion traits
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
cenum-derive
A rust derive macro for C-style primitive enums
-
giftwrap
Wrap and unwrap your types the stylish way
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
frunk_proc_macros
Proc macros for Frunk
-
const_fn_assert
Assertions for const functions
-
custom_derive
(Note: superseded by
macro-attr) This crate provides a macro that enables the use of custom derive attributes -
prometheus-metric-storage
Derive macro to instantiate and register prometheus metrics without having to write tons of boilerplate code
-
zkp-macros-lib
Library of procedural macros implemented using
proc_macro2 -
docgen
Rust library made for dynamically documenting Rust items created by a macro
-
serde_str_helpers
Helpers for using serde with strings
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
mic
Facilitates answering to competitive programming problems
-
normalize_interval
Normalizing interval library
-
plutonium
Tools to avoid unnecessary use of safe code
-
arr_macro
Initialize arrays with ease!
-
zkp-macros-impl
Implementation crate for
proc_macro_hack -
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
similar-asserts
provides assert_eq! like macros with colorized diff output
-
lang_extension
Rust Lang Extension
-
err-derive
Derive macro for
std::error::Error -
aether_primitives
Helpers for common SDR and signal generation operations
-
if_debug
A handy rust macro to exclude debugging code from your release builds
-
quack
Duck typing traits
-
singleton-trait
Singleton trait for types with unique values and Erased type for zero-sized ownership proofs
-
impl_ops
Macros for easy operator overloading
-
rtlola-macros
Procedural macros for more convenient handling of HirModes in the rtlola_hir crate
-
with_locals-proc_macros
TODO!
-
compile_msg
A plugin for emitting errors, warnings and notes to the developer at compile time
-
char_combinator
An iterator to create all combination of a given char range
-
tapir
Adding tapping functionality to rust
-
convertable-errors
This crate defines an ergonomic macro for deriving From conversions for variants of Rust enums
-
error-chain-mini
error-chain for minimalist
-
adrop
Simple and fast dedicated thread drop
-
shoulda_macro
derive macro for test assertions
-
concurrency_traits
Traits for concurrent primitives
-
iderive
Drop-in replacement for derive that doesn’t directly depend on generic bounds
-
control-flow
A hack to control control-flow outside closures
-
gaclen_shader
Tweaked re-export of vulkano_shader! procedural macro
-
autd3-traits
Wav Modulation for AUTD
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
trace-error
Extensions to Rust’s error system to automatically include backtraces
-
type-variance
Marker traits for subtype variance
-
validaten
Common validators for cryptocurrency, creditcards, domain, url, etc that can be used across projects
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
tap-trait
Inspect and mutate values without leaving the method chain
-
separator
Formats numbers into strings with thousands separators for readability
-
typemap-meta-derive
A simple compile-time macro to create type-to-valup maps, derive macro crate
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
defmac
A macro to define lambda-like macros inline
-
read-byte-slice
An iterator over chunks of bytes as slices from an underlying reader
-
structdoc
Extract structure and documentation from structs
-
aspect-weave
An Aspect Toolkit for Rust
-
concat-string
Provides macros for concatenating string slices into owned strings
-
spidermeme
Traits to test for type equality and type inequality
-
smart_access
A minimalistic “lazy bidirectional pointer” framework
-
dcc-lsystem-derive
Macro implementation of #[derive(TurtleContainer)]
-
enum_properties
A macro for declaring static properties on enum variants
-
extrude
A macro for unwrapping an enum value into an Option
-
optional-fields-serde-macro
Macro for optional-field crate serde integration
-
existential
Existential quantification over lifetimes
-
typename
Stable alternative to Rust’s type_name intrinsic
-
err_tools
Helper traits and functions for building errors in rust
-
thisctx
Easily create error with contexts
-
mapcomp
Python-like list comprehensions for standard containers
-
default-test
A default trait that can be used in tests
-
tagged-pointer-as-enum
A set of structs, traits and macros to implement tagged pointers
-
macro_lisp
Lisp-like DSL for Rust language
-
cstr-argument
A trait for converting function arguments to null terminated strings
-
slugify
Macro for flexible slug generation
-
toql_enum_derive
Library with enum derive for toql
-
swahili-dsl
A Swahili-based DSL made for educational purposes
-
enum-utils-from-str
Code generation for mapping from strings to arbitrary values
-
ops-derive
Derive macros for std::ops
-
better_any
Type id and Any for non static types
-
codespan-derive
derive(IntoDiagnostic) for easy codespan integration
-
deferrer
defer! macro for deferring functions
-
iter_vals
On the fly iterator creation
-
openapi_type
OpenAPI type information for Rust structs and enums
-
cor_iter
Correlate of two iterators
-
is-same
A trait for comparing object equality
-
qadapt-spin
Synchronization primitives based on spinning. They may contain data, are usable without
std, and static initializers are available -
either_trait_macro
An attribute-like macro to implement traits for Either
-
trait-set
Support for trait alias feature on stable Rust
-
autowired-derive
Autowired project derive macro support
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
inherent-pub
Mark methods in
impl Trait for Typeblocks inherent to the type -
cartesian
QOL macro that creates the cartesian product of multiple iterators
-
splop
Helper functions to determine the first/last repetition of something
-
rusty_v8_helper_derive
A rust derive macro for rusty_v8_helper
-
xkcd_unreachable
A Rust macro xkcd_unreachable!() inspired by https://xkcd.com/2200/
-
macro_macro
Macro templating library for DRYer structs
-
remote-trait-object-macro
Macro that expands a Rust trait to a remote-trait-object service
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
entity_rust
Event driven CES framework for Rust with a macro DSL
-
col_macros
A collection of general purporse macros for construct distinct types of collections
-
market_types
Common implementations of a market
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
overflower_support
A bunch of specialized traits + impls to allow automated overflow handling without type inference. Nightly only
-
new_type
Improve the semantics and correctness of your code by embracing newtypes
-
zkp-error-utils
Assertion like macros for returning
Result::Err -
structype_derive
A derive macro crate that lets you view an allowed type’s fields and will let you over-ride it
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
peppi-derive
Support crate for peppi
-
yade
Yet Another Derive Error
-
arcmutex
A convenience library for working with
Arc<Mutex<T>>s -
thin-slice
An owned slice that packs the slice storage into a single word when possible
-
soft
Provides soft, non-panicking assertions
-
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
grange
create range numbers macro
-
yui_internal
Internal functions, struct for derive in Yui
-
nom-fields
Provides a single function-like macro that removes some boilerplate from a common pattern when using nom
-
asserter-macros
New assertion library for rust
-
shoggoth
Generic and type-level programming for Rust
-
sorted
Provides compile time guarantees for sorted sequences
-
helper_fn
A macro to create closure-like helper functions
-
text-block-macros
Create a multiline string literal
-
show
A
show!debugging macro to print expressions with the Show formatting trait, without writing out"{}",in theprintln!macro -
throws
A macro for easy creation per-function errors
-
ff-derive-num
Procedural macro library to add the Num trait to Field implementations for ff
-
stackpin
Crate for data that should be pinned to the stack at the point of declaration
-
bitbag_derive
Derive macros for the bitbag crate
-
tokio-pg-mapper-derive
Proc-macro library used to map a tokio-postgres row to a Rust type (struct)
-
pinpoint
Crate for pinned references
-
process-results
process-results is a crate that provides the same functionality provided by Itertools::process_results. It helps you process an iterator of results, with a more ergonomic and composable interface.
-
array_iter_tools
Modify simple arrays
-
funfun
Macros for working with closures
-
regecs-codegen
Code generation macros for REGECS
-
type_hash
Generate a hash for a Rust type. The primary use-case for this crate is for detecting differences in message types between versions of a crate. The
TypeHashtrait is implemented… -
endian_trait
A trait for Endianness conversions that can be implemented on most types
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
typed-sql-derive
Macro implementation for typed-sql
-
optfield
A macro that generates structs with optional fields
-
errer
Flexible error management for Rust. An middle-ground between failure and SNAFU
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
conform
Macro to transform struct string fields in place
-
cpp_map
A simple C++ std::map emulator
-
generator_extensions
Basic extensions to Generator types to bring parity with Iterators
-
lifetime
Traits and derive macros to change the lifetime of a type, allowing efficient reuse of your stucts or enums with any lifetime requirement
-
serde-versions-derive
An attribute macro for adding a version byte when serializing a struct via Serde. Also allows deseraializing while removing version byte.
-
enum-derive-2018
This crate provides macros for deriving additional functionality for enums
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
prange2
Parse numeric ranges for indexing
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
left-pad
Provides left-padding for strings
-
os-thread-local
OS-backed thread-local storage. This crate provides a
ThreadLocaltype as an alternative tostd::thread_local!that allows per-object thread-local storage, while providing a similar API… -
wchar-impl
Internal implementation of wchar
-
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
clone_all
clone_all!(my,variables,with,long,names);
-
same-types
Ensure that two types are the same
-
podio
Additional trait for Read and Write to read and write Plain Old Data
-
stronghold-runtime
Runtime and allocation primitives for stronghold
-
tuple
Element-wise operations on tuples
-
envsubst
Variables substitution
-
unite
A helper macro to compose existing types into an enum
-
forward_ref
Rust’s forward_ref_* macros for easier implementation of operator overloading
-
xplane_plugin
Provides types and a macro for creating X-Plane plugins
-
diesel_derives_traits
Traits for diesel_derives_extra
-
cast_trait_object_macros
Cast between trait objects using only safe Rust
-
tagged_cell
Fast, initializable, and thread safe static variables
-
delegatemethod
Delegate method calls to a field
-
list_builder
Python-like list comprehensions in Rust
-
smart_buffer
A hybrid stack/heap buffer
-
bitwise_reduce
Multiple arity bitwise functions
-
dont_panic
panic!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won’t panic.
-
unwrap_all
Unpack multiple levels of
Result<T, E>andOption<T>at once -
scanio
Simple console input macros with the goal of being implemented in the standard library
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
dto_derive
Derive for automatic mapping DTOs to Entities and vice versa
-
ambience
Lightweight library for passing ambient parameters
-
write-only
References/slices that provide write-access, but no read-access
-
winwrap
Rust-friendly Windows API wrappers
-
zhi_enum
derive macros to easily use enum
-
rocket_failure
Failure like error handling for rocket
-
num_alias
simple macros to declare ‘type checked’ aliases for integers and floats
-
spans
Split an iterator into contiguous spans
-
float
Lightweight wrappers around primitive floating point types
-
array-lit
Macros for array and
Vecliterals with superpowers -
type_at_derive
Provides the #[derive(TypeAt)] proc. macro.
-
sugar
Rust syntax sugar collections
-
peek-poke-derive
Derive macro for peek-poke
-
rev_slice
A newtype for operating on a reversed view of a slice
-
repr-trait
Traits to represent Rust reprs
-
fix_fn
Macro to create recursive closures (similar to the Y combinator)
-
tor-units
Provides macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
unique-type-id-derive
A unique id proc-macro generator for types
-
nonmax
Numeric types that cannot hold maximum values
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
iter-opt-filter
Adds an optional filter to iterators
-
mods
Simpler module declaration
-
path_semantics_std
A Rust type checked implementation of the standard dictionary of path semantics using constrained functions
-
structural
Field accessor traits,and emulation of structural types
-
eager
Crate for eager macro expansion
-
kg-diag-derive
Macro implementation for #[derive(Detail)]
-
new_flattened
Macro to flatten nested calls of
news -
endian-type
Type safe wrappers for types with a defined byte order
-
bail-out
Macros to help keep code clean for validations and error handling
-
tlayuda
A derive procedural macro for structs that adds a static method that generates instances of the struct with minimal configuration
-
mcurry
Macros for creating curried functions
-
compiler_error
Triggerable compiler error
-
stringreader
Provides a wrapper for strings so that they can be consumed via the std::io::Read trait
-
cryiorust_derive
Derive macro for cryiorust
-
transformable_channels
Rust channels are a convenient abstraction, but for many uses cases, they miss high-level transformations such as
map,filter, … . This crate introduces them. -
aoc-main
A macro which defines a handful main for the Advent of Code
-
transitive_from
Helper macros for creating hierarchies of transitive
Fromimplementations -
struct_field
Derive macros for generating each field in a struct
-
reexport-proc-macro
Re-export a procedural macro
-
enum_variants
Deriving traits for C-like enums using macro 1.1
-
azul-peek-poke-derive
Derive macro for peek-poke
-
dsl_macros
Convenience macros that rewrites method calls inside a builder closure
-
variants-struct
A derive macro to convert enums into a struct where the variants are members
-
into-owned
Provides a trait for associating a type with its owned variant
-
transaction
transaction abstraction library (a.k.a. transaction monad)
-
lovm2_std
a lightweight virtual machine with a focus on simplicity and extendability
-
ref-cast-impl
Derive implementation for ref_cast::RefCast
-
structx
Simulating anonymous struct and named arguments in Rust
-
switch_statement
A simple switch statement macro
-
near-client-primitives
This crate hosts NEAR client-related error types
-
notosans
A simple crate providing several of Google’s Noto Sans true type fonts as slices of bytes
-
ext-trait
Annotation to easily define ad-hoc / one-shot extension traits
-
list-any
Type erased slices and Vecs
-
plague
Parametrized tests tools
-
deuterium
Deuterium is a fancy SQL builder for Rust. It’s designed to provide a DSL to easily build SQL queries in safe and typed way.
-
iterator-ext
An extension to Rust’s Iterator
-
cute_custom_default
Derive macro for
Defaulttrait with customization -
sentry-error-chain
Sentry integration that allows capturing error-chain errors
-
typic
Type-safe transmutations between layout-compatible types
-
rust-iteratorcomprehensions
A comprehension syntax for iterators implemented as macros
-
nova
Macro to derive newtypes with support for serde and sqlx
-
conventus
Traits for assembling and disassembling items
-
byo-graphql
simple bring-your-own graphql client
-
yolo-block
Like a
tryblock, but automatically unwraps the result -
try_from
TryFrom and TryInto traits for failable conversions that return a Result
-
ufcs
Helper trait to call free functions using method call syntax
-
errloc_macros
Error location utility macros
-
variant_access
A set of traits and macros for defining a common api for Rust enums based on the std::variant api in the C++ standard library
-
const-if
This crate adds if-else expression into your constant functions
-
conditional
Provides a conditional! macro which lets you use the syntax of the conditional operator (also known as the ternary operator) in Rust
-
byte-slice
Byte slice manipulation macros
-
enum_cycling_derive
Small macro for working with enums
-
with-macro
Syntactic sugar for calling methods
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
partialdebug-derive
macros for partialdebug
-
parameterized_test
A macro to support providing arguments to test functions
-
dependent_ghost
An implementation of Matt Noonan’s ‘Ghosts of Departed Proofs’
-
enumflags2
Enum-based bit flags
-
expect_macro
The expect! macro
-
mononym
Type-level named values with partial dependent type support in Rust
-
take-until
A take until extension for iterators
-
summon
A logic engine designed to magically give you what you ask for
-
frunk_laws
frunk_laws contains laws for algebras declared in Frunk
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
tiny_fail
Provides simple Fail type
-
rubbl_core
Core types and traits for Rubbl, a Rust package for astrophysics
-
singleton-stepanov
It isn’t meant to be used by itself, but as template for your our types. Attempt to do Efficient Programming with Components: Lecture 2 Part 1, Efficient Programming with Components:…
-
vec_box
A single macro to create a vec of boxed elements, for trait objects
-
inherent
Make trait methods callable without the trait in scope
-
atomic_refcell_try
Threadsafe RefCell
-
koute/nes
An NES emulator written in Rust
-
lambek
Type-Level Programming in Rust
-
dioptre-derive
Custom derive macro for #[derive(Fields)]
-
vesta-macro
Procedural macros used by and exported from the Vesta crate
-
purpurea
Attribute based accessor/updater/mutator/constructor generation
-
result-inspect
Adds the missing Result::inspect() function
-
likely_stable
likely and unlikely compiler hints in stable rust
-
comprehension
Iterator comprehension in Rust
-
ffishim_derive
Procedural macros for generating ffi-compatible stubs
-
block_effects
A macro to chain block effects
-
srcerr
User friendly errors from source data
-
rhs_first_assign
An attribute macro to hack compound assignment
-
exclusive
Place code into an exclusive context that won’t collide with another context
-
uavcan-derive
Makes it possible to derive Uavcan related types
-
flow_impl_derive
Definition of a derive macro for FlowImpl
-
actix-multipart-derive-impl
Procedural derive macro implementation for actix-multipart-derive
-
single_executor
Traits for concurrent primitives
-
trigram
Trigram-based string similarity for fuzzy matching
-
eliza_error
“Times are bad. Children no longer obey their parents, and everyone is writing an error handling library.” — Cicero
-
coalesce
Combine disjoint types that share common traits
-
duplex
The Duplex trait: interactive streams
-
enum-methods
Generates methods for each enum variant
-
handler_map
Map from types to functions that receive them
-
boolinator
Provides the Boolinator trait, which lets you use Option and Result-style combinators with bools
-
sortby
adds convenient sort functions for Iterators
-
map_for
A Rust macro that implements for comprehensions similar to Scala’s
-
aliri_braid_examples
Examples demonstrating usage of the
aliri_braidcrate -
hirpdag_derive
Procedural macro for generating hirpdag boilerplate. See hirpdag crate.
-
cutlass
Macro based library to take the boilerplate out of configuration handling
-
proc_use
Semi-dynamic mod and use
-
diesel-derive-newtype
Automatically connect newtypes to Diesel using their wrapped type
-
dev_bestia_url_utf8
Library for url utf8 encode/decode
-
zkp-criterion-utils
Criterion helpers to benchmark over size and number of processors
-
event_feed
Event systems implemented using event feeds
-
unique
ptr::Unique for stable Rust
-
flexpiler_derive
Derive macro project for main crate ‘flexpiler’
-
enum_from_str
Enable deriving FromStr for enums
-
altbitflags
Macros to implement a struct which behave similar to bitflags
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
printf-rs
printf c language like
-
structview_derive
Custom derive for structview’s View trait
-
higher
Higher kinded types, in a way
-
overflow-error
Common overflow error types
-
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
format-macro
Format procedural macro
-
objc-macros
Handy macros for interacting with Objective-C from Rust
-
diverge
Extension injection site specification through a simple macro
-
rlua-builders-derive
Derive helpers for struct/enum for rlua
-
fn_ops
Temporary traits for function operator overloading, pending the stabilization of
Fn,FnMut, andFnOnce -
structscan_derive
Macro implementation of #[derive(UserSubmittable)]
-
match-downcast
A set of downcasting matching Rust macros
-
try_or_wrap
Macro for simplified handling of multiple error conditions in a single function. Like try!, but can aggregate more than one enum into a wrapper
-
almost
A crate for comparing floating point numbers
-
abscissa_generator
Template-based generator for creating new Abscissa applications
-
pub-iterator-type
Abstract an iterator implementation behind a struct tuple
-
as-dyn-trait
An attribute macro that generates methods for retrieving supertraits from trait-objects (upcasting)
-
angular
Angular types and common helper methods
-
ord_by_key
Provides a convenient macro for implementing Ord trait with logic specified in an inline expression
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
colorskill
Some useful color manipulation functions
-
derive-aktor
Create actors in rust with a derive macro
-
qmetaobject_impl
Custom derive for the qmetaobject crate
-
enumx_derive
Macros for ad-hoc enum extension
-
rustorm-derive
procedural macro code generator for rustorm
-
cassandra_macro
Create Cassandra tables and CRUD CQL prepared statements from Rust structs. (custom derive: cassandra_macro_derive)
-
mockers_derive
Macro 1.1 implementation for ‘mockers’ mocking library
-
every_variant_macro
To be used with all variant, contains the derive macro
-
diff_derive
A derive macro for implementing Diff on the diff-struct crate
-
nes
New Error System for rust
-
split_preserve
An iterator that splits on whitespace but doesn’t throw it away
-
error_derive
Macros for deriving Error implementations through custom_derive!
-
ndless-static-vars
Rust library for storing static, program-wide parameters for Ndless
-
derive_asref
derive AsRef in variety way
-
fn_chain
Helper macro/function to create function chaining
-
enum_to_enum
Derives possibly effectful conversions between enums
-
bumpalo-herd
Support for bumpalo in scoped threads & rayon
-
byte_conv
Simple conversion traits to bytes
-
io-error
Simple and convenient macro for creating I/O errors
-
disjoint-borrow
Disjoint mutable borrows of slices
-
dispose-derive
Derive macro for the dispose crate
-
std_prelude
prelude that the rust stdlib should have always had
-
eraserhead
erase the lifetimes from types
-
asn1-cereal
ASN.1 and BER serialization
-
apply_attr
A syntax extension providing higher-order attributes to Rust
-
casper_types_derive
Use struct types in Casper contracts without boilerplate
-
discriminant_hash_derive
Derive macro to implement Hash trait based on enum’s discriminants only and ignore variant’s fields
-
he_di_internals
Common code for he_di crates
-
multi-eq
Macros for creating custom equality trait derives
-
duck
Like
Iterator::peekable, but can be stacked an arbitrary number of times -
snaptest
Dead simple snapshot testing
-
variantly
Derive helper methods for enum variants that are familiar from
std::option::Option&std::result::Resultsuch asunwrap_ororand_then -
async-anyhow-logger
An easy crate for catching anyhow errors from an asynchronous function, and passing them to your logger
-
placeholder_closure
Scala’s Placeholder Syntax for Rust
-
tilde
Using ~ to provide syntax sugar for Rust
-
respector
An extension to add inspect method to Option and Result types
-
extprim_literals_macros
Internal crate to support
extprim_literals. You typically don’t need this crate directly. -
tagged_ptr
A safe tagged union pointer datastructure for x64
-
scroll_derive
A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate
-
tch-tensor-like
Derive convenient methods for struct or enum of tch tensors
-
destruct-drop
Macro for dropping the fields of a struct or enum without dropping the container
-
phantom-enum
A simple macro library for creating phantom enums
-
rt-format
Fully-runtime equivalent of the format! macro
-
roopert_macro_common
Another object-oriented toolkit for Rust (common data)
-
named_constants
Procedural macro makes enums behave like named constants in languages like C/C++ or C#
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
capture
A macro for adding explicit capture clauses to a (closure-) expression
-
drop_ok
.drop_oksyntax sugar forResult. It’s instead of.map(|_|()). -
annotation-rs-beta
Compile-time annotation parser for rust
-
count_tts
A simple macro for counting tokens
-
startup
Tiny (no dependency, no proc macro) way to run some code before main
-
named
Procedural macro which allows you to produce functions which can be called with named arguments, optionally with default values
-
nan-preserving-float
(Mostly) drop-in replacement for floats that preserves the signalling bit in NaNs under conversions and unary operations
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
overloadf_derive
unlock function overloading for rust
-
collect_slice
Collect an iterator into a slice
-
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
path-ext
Provide convenient methods for path operations
-
pad-adapter
A utility crate that provides pad adapter
-
vizz_derive
Derive macro for the Visualize trait
-
monad
Stackless monads in Rust
-
clone-into-box
A library for cloning trait objects
-
apply_method
Allows you to apply any function given as a parameter to the object
-
fast_new_type
A proc_macro attribute to implement common traits for a custom type wrapping other
-
to_vec
convenient to_vec, to_set and to_map methods on iterators
-
extract_macro
A macro to extract a value from a pattern
-
frunk_proc_macros_impl
Proc macros inernal implementations for Frunk
-
as-any
provide the AsAny trait
-
enum-primitive-derive-nostd
enum_primitive implementation using procedural macros to have a custom derive
-
taken
Macros for taking ownership, staring Liam Neeson
-
transaction-stm
transaction abstraction of stm
-
bos
Flexible Borrowed, Owned or Shared (B.O.S.) smart pointers. Like std’s Cow but with Rc/Arc and without the ToOwned requirement
-
cbox
C pointer boxing, for when working with ffi
-
newtype-enum
Traits to convert between enums and their variant types
-
rvs_derive
A helper macros implementation for Value Classes in Rust
-
whaterror
Customizable handling for fallible main
-
mox-impl
Implementation for the mox! macro
-
rubber_duck
Enables building functions that can be called with named arg syntax
-
rvs-parser
Parser for Rvs - A library for defining and evaluating random variables using a simple DSL
-
default-boxed-derive
Custom derive for default-boxed
-
error-context
Methods and types that help with adding additional context information to error types
-
ternary-rs
A Rust library for emulating the ternary operator from C/C++ (among other languages)
-
embedded-error-chain-macros
Procedural macros of the
embedded-error-chaincrate -
append
Trait for adding to collections
-
frust
Functional Programming in Rust
-
peek-nth
An iterator adapter that allows you to efficiently peek the nth item of an iterator
-
generic
Higher level serialization of rust values to rust values
-
enum_traits_macros
Procedural macros that adds functionality to enums by deriving traits from the crate
enum_traits -
wrap
Generic function wrapping
-
detach
helper type for being able to detach/reatach a member item
-
varianteq
Derive the equality of enum variants ignoring fields
-
ff_derive-zeroize
Procedural macro library used to build custom prime field implementations
-
constduck
Compile-time ducktyping and reflection using const generics
-
stable-pattern
Stable port of std::str::Pattern and friends
-
traitcast_core
Cast between dynamic trait objects
-
slist-derive
Deriving traits for the slist crate
-
rjdebounce
Debouncing function utility
-
typemap-meta
A simple compile-time macro to create type-to-valup maps
-
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
from_iter
Initialize arrays from iterators
-
string_to_expr
Compile-time expression evaluation for strings
-
async-once-cell
Async single assignment cells and lazy values
-
random-number-macro-impl
Generate random numbers quickly
-
mysql_enum
Convert between Rust enum and MySQL enum
-
builder_macro
A macro to generate structs and a corresponding builder
-
default-ext
This library provides extension methods for the
Defaulttrait -
rustollens
A small and experimental library with a type-level representation of booleans with companion connectives for compile-time sort-of fun with logic
-
lovm2_internals
a lightweight virtual machine with a focus on simplicity and extendability
-
anon
Anonymous struct macro
-
ro_cell
A (mostly) readonly cell
-
rotate-enum
A simple macro that implements prev() and next() methods to an enum
-
arraytools
A variety of helpful methods for working with fixed-size arrays
-
arc-io-error
A version of std::io::Error implemented on top of Arc instead of Box, making it cloneable
-
tynm
Returns type names in shorter form
-
magic_static_macro
Proc macro for magic_static
-
tramp
Trampoline for recursive functions, with support for mutual recursion
-
c2rust-bitfields-derive
C-compatible struct bitfield derive implementation used in the C2Rust project
-
inline-python
Inline Python code directly in your Rust code
-
reduce
Fold an iterator without an initial value
-
simpledi-rs
simpledi-rs, a simple and thread-safe dependency injection library
-
assert-cmp
Convenient assertion macros that print the failed expressions and their evaluated values
-
amplify_derive
Amplifying Rust language capabilities: derive macros for the ‘amplify’ library
-
drop_some
.drop_somesyntax sugar forOption. It’s instead of.map(|_|()). -
general_tools
This crate offers many functions for many different types of operations, such as operations with strings, numbers, files, and more!
-
type-uuid
Safe, stable IDs for Rust types
-
erroneous
Minimalistic helper for using errors
-
common_failures
Helpers for ‘failure’, including io::Error wrappers with paths, quick_main!, display_causes_and_backtrace
-
iroha
A tokenization Library for Rust
-
bounded
Bounded numeric types
-
rlua-builders
Derive helpers for struct/enum for rlua
-
dynamic
A dyanmically typed value with fast downcasting
-
functionate
Automatically implement Fn* traits for structs and enums
-
join_impl
Implementation of the
join!macro -
displaydoc-watt
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
once_self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
chained_iter
Provides a small helper macro for creating iterators out of values without allocation
-
underscore_args
Macro for underscore named argument syntax, aka Dyon
-
kvfmt
A helper macro for stringifying variables into a key=value style string
-
recap-derive
Derives FromStr impl for types which are then deserialized using recap
-
tuple-arity
Get the arity (number of elements) of tuple types with 0-12 elements
-
fn-compose
A small macro for function composition
-
scrapmetal
Scrap Your Rust Boilerplate
-
dync-derive
Attribute macros for producing
dynccompatible traits -
fixed_len_str
A procedural macro for create a smart pointer to str backed by a fixed size array,with the size given by the tokens
-
tyenum
Attribute macro for type enums
-
derive_constructor
Construct enums without naming them
-
rawpointer
Extra methods for raw pointers and
NonNull<T>. For example.post_inc()and.pre_dec()(c.f.ptr++and--ptr),offsetandaddforNonNull<T>, and the functionptrdistance. -
iter_from_closure
Iterator<Item = Item> from FnMut() -> Option
-
openapi_type_derive
Implementation detail of the openapi_type crate
-
try_enum
match enum
-
powerset-enum
A poor man’s anonymous enum
-
zkp-mmap-vec
Replacement for
Vecthat uses file-backed storage -
unify
Trait-based equality constraint for Rust
-
newtype_derive
This crate provides macros for deriving common traits for newtype structures
-
is-same-derive
Derive proc macro for the is-same crate
-
autoproto
Replacement derive macros for
prost::Message, and supporting traits and types to make implementing this trait easier -
input-stream
IO streams similar to C++’s streams
-
assert_into
For when writing .try_into().unwrap() feels too long
-
const_fn
An attribute for easy generation of const functions with conditional compilations
-
scoped-callback
Register scoped functions with local references to ’static lifetime callbacks in a safe manner
-
take-if
A tiny utility for conditionally taking the contents of an option
-
shoulda_core
derive macro for test assertions
-
enum_index_derive
Macros for extracting Enum variant index
-
ref-portals
Safely use (stack) references outside their original scope
-
byteorder_slice
Byteorder like crate for &[u8]
-
scopefunc
A trait defining kotlin-like scope functions
-
escher-derive
Self-referencial structs using the async/await transformation
-
deep_safe_drop
Safe dropping of deep trees that otherwise could cause stack overflow
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
syn_squash
Proc attribute macro helper to capture many Syn types and define shared behaviour
-
multizip
Zip 3, 4, 5 or more Rust iterators
-
dev_bestia_string_utils
Library for string manipulation
-
dioptre
Struct field projection tools
-
verify_macro
An attribute that automatically instruments code with logical type bounds
-
fat_type
A structure type which permits thin references to arrays and dynamic types
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
io-read-line-prototype
Prototype for io::read_line
-
filters
Build filters/predicates with the builder pattern
-
rg3d-core-derive
Proc-macro for Visit trait
-
safe
A
#[safe]attribute for explaining whyunsafe { ... }is OK. -
once-cell-regex
This crate just gives you the
regexmacro from theonce_celldocs! -
quixutils
Common helpers and utils
-
fast_fmt
This crate provides faster, more flexible and more correct alternative to core::fmt
-
transfer
Crate that exposes a Transfer trait, that is to move what Clone is to copy
-
stable_borrow
A marker trait indicating that borrows are address-stable
-
generic-bytes-derive
A macro for derivation of SizedBytes, a trait for conversion to and from an array of bytes with a type-level size
-
outcome
A Success/Failure type for rust
-
borrow-owned
Simple helper for temporary object moving
-
typic-derive
Type-safe transmutations between layout-compatible types
-
tuple-map
map methods for tuple
-
displaythis-impl
Implementation detail of the
displaythiscrate -
autoerror
Automatically generate error handling traits
-
assert_that
Helper macros for use with boolean-valued predicate functions
-
string_map
Create a record to store any type of value
-
type_at
Utility trait to index type of Rust tuples
-
enum_primitive
Macro to generate num::FromPrimitive instances for enum that works in Rust 1.0
-
nonzero
Statically checked non-zero integers
-
unborrow
Macro for calling a &mut self method with transient &-borrows of self in the parameters
-
bassert
A Better Assert macro This macro will print out the values of each side of an expression and also the values of function arguments
-
into_inner_drop
A helper library for implementing into_inner method for drop types safely
-
error-chain-mini-derive
derives for error-chain-mini
-
serde_mtproto_derive
Procedural macro helper for serde_mtproto
-
on_demand
A macro to generate aux macros for on-demand usage
-
slice-ext
Useful extensions to slices and iterable types
-
enum_cycling
Small macro for working with enums
-
string_morph
string_morph is a library of string case transformations with an emphasis on accuracy and performance. The case conversions are available as functions as well as traits on String types.
-
better-as
Explicit type casting
-
macro_const
A macro for creating corresponding macro definitions for constants which evaluate to the same values
-
scale_impl_generator
a proc macro to generate a large percentage of all impls on SCALE crypto primitives
-
error-type
Provides a macro for constructing unifying error types
-
dyn_struct_derive
Derive macros for the
dyn_structcrate -
opt_reduce
reducefunction forOption<_> -
newtype_array
A macro to help implementing the standard derived traits on newtype arrays
-
appro-eq
Approximately equal traits and assertion
-
captur
Macro to capture whole structs from disjoint fields in a closure
-
eieio
Error Implementing
Eq + Clonereplacingstd::io::Error -
rchunks
Iterator for slices similar to .chunks() but starting from the back of the slice and moving towards the front. Differs from .chunks().rev() in handling cases where the slice is not a multiple of chunk size.
-
threadbound
Make any value Sync but only available on its original thread
-
derive_display_from_debug
A trivial Rust macro to derive the Display trait for any type with the Debug trait
-
check_keyword
A trait for String-like types to check if it is a reserved keyword and convert it to a safe non-keyword if so
-
multi-structs
Macro for generating a merged struct from multiple sub-structs
-
endian_trait_derive
A custom derive for the Endian trait
-
actix-handler-macro
Helper macros for using Actix. Generates handlers, actors and address traits.
-
expand
Macro to expand byte string and string literals
-
repr-trait-derive
Derive macros for working with repr-trait
-
hoist_temporaries
Procedural macro to extend the lifetimes of temporary variables
-
if_empty_derive
Proc macro to generate if_empty for types that have is_empty implemented
-
container_literals
vec! like macros for creating maps and sets
-
merge_derive
Derive macro for the merge::Merge trait
-
cell-map-macro
Macros for the cell-map crate
-
layered-io
I/O traits extending Read and Write
-
is_not
A procedural macro much like #[cfg(…)] that can be re-exported from a library based on enabled features
-
hoax
Simple procedural macro crate that “hides” any string literal in a plain sight
-
clone_cell_derive
Proc macro for clone_cell
-
try_clone_derive
a crate wich add a derive TryClone macro for the TryClone Trait of the fallible_allocation crate
-
take_ref
TakeRef, TakeSlice, and TakeString traits enable treating references/slices and values interchangeably. They can be treated as references/slices. And you can take ownership of the value…
-
serde_type_name
lookup name of type for any struct or enum that derives serde Serialize
-
hmap
Adds hmap! macro for easily generate HashMap
-
drop_struct_macro_derive
A derive macro to free (drop) memory for structs that are used in the FFI
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
tylar
Type-Level Arithmetic in Rust
-
dmutil
A collection of utility macros to ease the creation of other macros
-
cex_derive
Macros for checked exception simulation
-
enum_to_enum_derive
Derive macro implementation for enum_to_enum. enum_to_enum derives possibly effectful conversions between enums.
-
fmt_adapter
Provides newtype adaptors to and from any formatting trait
-
enum_default
enum_default provides an EnumDefault derive macro that provides a std::Default implementation for Enums by using the first value or specifying a #[default] attribute
-
loosen_map
Calls a function with self
-
curry-macro
Have fun currying using Rust’s native closure syntax
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
pipe_macro
A macro to pipe function calls like in functional programming languages
-
hazard
Hazard pointers
-
structural_derive
Implementation detail of the structural crate
-
dtd-macro
A DTD file parser
-
frunk-enum-derive
Derive macros to implement the frunk::LabelledGeneric trait on enums
-
nova-macro
Implementation for nova crate
-
from_as
Traits and derive macros to Read and write types that implement serde Serialize and deserialize to files
-
hlist
Heterogeneous list with type-directed search
-
closet
CLOSure-Enhancing Toolbox (CLOSET) provides some questionably-useful macro utilities for closures, including clone_army!, which reduces boilerplate for clone-capturing closures, and vindaloo…
-
func_wrap
Helper crate for procedural macro authors that wish to duplicate some received function inside its body, so as to be able to wrap with some prologue, epilogue, cache-ing, etc
-
derive_from
A simple derive(From) macro
-
cenum
A rust derive macro for C-style primitive enums
-
tearor
Easily turn data races into data corruption!
-
structype
This crate contains the exported types used in https://github.com/nohupped/structype_derive
-
fool
Traits for interoperation of Boolean and sum types
-
internship
Interned string and more
-
jane-eyre
By Currer Bell
-
withers_derive
A macro to implement wither methods for properties of a struct
-
bstringify
stringify! that yields byte string literals instead
-
uncheck-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
pointer
A simple crate to make it easier to iterate on pointers
-
forever
-
rust-cef
Trait to serialize/convert/map a Rust item into an ArcSight Common Event Format string. This trait enables logging libraries and frameworks that may wish to integrate with standardized…
-
partialdebug
Derive Debug partially
-
subset
Various subsets of slice’s items that are able to iterate over references to selected items
-
format-core
Core format types
-
typed_index_derive
Custom derive to easily create newtype index types
-
newtype-derive-2018
This crate provides macros for deriving common traits for newtype structures
-
parse-display-derive
Procedural macro to implement Display and FromStr using common settings
-
rovv_derive
provide the anonymous row type (poor-man’s row polymorphism) in rust
-
boow
Borrow Or oWnedsmart pointer. Alternative to Cow. -
as-is
An abstraction over ownership
-
dangerous_option
This crate provides DangerousOption - a type similar to ! in Swift language. It’s basically an Option which panics if dereferenced while containing None. no_std compatible.
-
arr_macro_impl
Private impl crate for arr_macro
-
random_stuff
A pile of random helpers, macros, extension traits… that I didn’t care to write a separate crate for. Probably nothing to do with
randcrate. -
enum-tryfrom
Error types and traits for use with enum-tryfrom-derive
-
lens-rs_generator
generating optics for source files
-
function_group
A macro to hack in function overloading to rust
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
quantified
Specify the universe: None, Some, Excluding, and All
-
bitpattern
bitwise pattern matching and extracting
-
box_shorthand
Rust derive macro to create shorthand functions for initializing boxed enum variant values
-
loosen
Derives a wrapper function which loosen the arguments into a tuple
-
read-from
Supplies the ReadFrom and WriteTo traits
-
zkp-macros-decl
Procedural macros
-
mem_macros
align_of and size_of as a macro, to avoid turbofish notation
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
tuple-conv
Allows converting tuples of one element to vectors
-
utils-plugs-proc
proc macro for crate
utils-plugs -
one-of
Macro to represent a type that can be converted either
FromorTryIntothe given types -
wrapped_enum
Useful macro to wrap existing types in an enum (common use for quick error handling)
-
sconcat
String concatenation
-
identity
A stable Rust implementation of an identity (a.k.a., “equality witness”) type
-
io-streams
Unbuffered and unlocked I/O streams
-
join_to_string
Join a list of items to string/buffer
-
enumn
Convert number to enum
-
iroha-derive
Internal derive for Iroha
-
conform-derive
Macros 1.1 implementation of #[derive(Conform)]
-
parse-generics-poc
A proof-of-concept implementation of the proposed RFC #1583; provides macros for parsing generics and where clauses. Note: requires a compatible nightly compiler. For a stable alternative…
-
stack-vec
Ad-hoc compile-time sized
Vec<T>like types on the stack -
same
Traits for testing identity of objects
-
eso
Type machinery to build Cow-like containers
-
into-result
A simple convenience trait for converting something into a
ResultorOption -
idealist
A library of non-empty wrappers for standard list types
-
units
Units of Measure for Rust. Easy to use, type-safe and customizable.
-
serde_int_map
Crate to derive serde traits for integer-indexed structs
-
rvs
A library for defining and evaluating random variables using a simple DSL
-
as_tuple
View any struct as a tuple! ✨
-
w_result
A result type that carries warnings
-
from_tuple
Derive structs from tuples
-
cstr
Macro for building static CStr reference
-
rsor
Reusable slice of references
-
struct-pad
Padding types to enable memory layout optimizations
-
default-conversion
A derive macro to automatic implement conversions between similar structs
-
mines
Unchecked assertions of unreachability which panics on debug builds
-
derive_pod
Implement the Pod trait safely with a derive macro
-
iter-python
Python generator expressions and ‘list’ comprehensions
-
wrap_result
easy to wrap Ok(value) , Err(value) or Some(value)
-
from_map
A crate that exposes the
FromMaptrait -
libsugar
libsugar provides syntactic sugar in the form of a library
-
shoggoth_macros
Generic and type-level programming for Rust
-
iterr
Combinators for dealing with iterators of
Results -
specialize
Type specialization macros and helpers
-
lazyonce
Store “immutable” cell that computes its value once, when it’s first accessed. Allows lazy initialization as an implementation detail, without need to expose any mutable methods.
-
static-events
A library for creating zero-cost event systems
-
zhi_enum_derive
derive macros to easily use enum
-
negative-impl
Negative trait implementations on stable Rust
-
handle-error
An error handling helper macro to avoid the constant if let Err(e) pattern
-
vesta
Extensible pattern matching
-
tyname
Retrieve type names during program execution on stable Rust
-
structbuilder_derive
Super simple macro to derive a builder trait for your struct
-
stringer
An easy way to turn an Unsafe *const c_char into a Rust String type and return a pointer
-
typesets
Enables generating subtypes and supertypes of a given type via derive macros
-
try-traits
Alternatives to std lib traits that can fail
-
rusteval-derive
macros for rusteval
-
function_name
macro that expands to the name of the annotated function
-
verified
A library of types to facilitate the development of verifiable rust
-
stringly_conversions
A crate helping to convert to/from various representations of strings
-
validated-slice
Helper macros to implement std traits for custom validated slice types
-
reuse
Traits and derive macros for efficiently reusing your stucts or enums with any lifetime requirement
-
char-device
Character Device I/O
-
sixarm_assert
Assert macros for Rust tests. By SixArm.com.
-
adhocerr
A library for the construction of efficient single use static/dynamic error types per callsite
-
passert
Pretty/Power assertion macros for rust
-
static_slice
Macro for creating static slices of arbitrary types
-
dyn_safe
Take control of the Semver hazard of the
dynsafety of your traits! -
ref-ops
An escape hatch for implementing
opstraits for references to newtypes -
map-trait
Generic Map trait
-
is-impl
Rust macro to check that a type conforms to an impl
-
extdot-impl
Please see
extdotcrate for actual usage -
structx_derive
Macros for anonymous struct and named arguments
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
fast_escape
Simple, fast escaping of characters
-
value
Type-level constants for generic contexts
-
dyner
Procedural macro support for ergonomic dynamic dispatch
-
nifpga-type-macro
helper macro for nifpga datatype
-
from_variants_impl
Internal helper crate for from_variants crate
-
lifetime_proc_macros_impl
Traits and derive macros to change the lifetime of a type, allowing efficient reuse of your stucts or enums with any lifetime requirement
-
boolenum
Derive From and Into for your boolean enums
-
integer-result
Convert primitive and non-zero integer types to a Result
-
rawslice
Reimplementation of the slice iterators, with extra features. For example creation from raw pointers and start, end pointer accessors.
-
hashmap_derive
A proc_macro to derive the FromMap trait
-
debug_stub_derive
A drop-in replacement for
#[derive(Debug)]that supports replacement values for members which do not implementfmt::Debug. -
dylink_macro
Dynamic function loading macro
-
polling-async-trait
A proc macro that creates async methods based on polling methods for your trait
-
asprim
Cast any primitive numeric type to any other using
aswith the AsPrim trait -
static-cond
Macro for performing comparisons during macro expansion
-
unwrap_return
A set of macros for returns and breaks in the None and Err cases
-
lazing
A macro like lazy_static can initialize static variables
-
stringlit
A macro to convert from str to String
-
tilde_derive
Using ~ to provide syntax sugar for Rust
-
concat_strs
Macro for quickly building a String from components