-
pin-project
A crate for safe and ergonomic pin-projection
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
ordered-float
Wrappers for total ordering on floats
-
synstructure
Helper methods and macros for custom derives
-
anyhow
Flexible concrete Error type built on std::error::Error
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
thiserror
derive(Error)
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
once_cell
Single assignment cells and lazy values
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive -
derivative
A set of alternative
deriveattributes for Rust -
snafu
An ergonomic error handling library
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
typed-builder
Compile-time type-checked builder derive
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
float-cmp
Floating point approximate comparison traits
-
annotate-snippets
Library for building code annotations
-
tap
Generic extensions for tapping values in Rust
-
geo-types
Geospatial primitive data types
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
uninit
A collection of tools for a safer usage of uninitialized memory
-
enum_dispatch
Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed
-
indoc
Indented document literals
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
if_chain
Macro for writing nested
if letexpressions -
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… -
maybe-owned
provides a
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
conv
This crate provides a number of conversion traits with more specific semantics than those provided by ‘as’ or ‘From’/‘Into’
-
educe
This crate provides procedural macros to help you implement Rust-built-in traits quickly
-
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… -
lazy-static-include
This crate provides
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
auto_impl
Automatically implement traits for common smart pointers and closures
-
funty
Trait generalization over the primitive types
-
sugars
An useful collection of macros to make tasks easier
-
retain_mut
Provide retain_mut method that has the same functionality as retain but gives mutable borrow to the predicate
-
safe-transmute
A safeguarded transmute() for Rust
-
float-ord
A total ordering for floating-point numbers
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
approx
Approximate floating point equality comparisons and assertions
-
k8-client
Core Kubernetes metadata traits
-
displaydoc
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
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…
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
lazy_format
A utility crate for lazily formatting values for later
-
unchecked_unwrap
Adds an unchecked version of
unwrap()andexpect()to Option and Result -
frunk
Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
quick-error
A macro which makes error types pleasant to write
-
amethyst_error
Internal error handling for Amethyst
-
cynic
A GraphQL query builder & data mapper for Rust
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
shellexpand
Shell-like expansions in strings
-
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
-
standback
New standard library, old compiler
-
buffered-reader
A super-powered Reader
-
hex-literal
Procedural macro for converting hexadecimal string to byte array at compile time
-
extend
Create extensions for types you don’t own with extension traits but without the boilerplate
-
auto_enums
A library for to allow multiple return types by automatically generated enum
-
tokenlock
Cell type whose contents can be accessed only using an unforgeable token
-
drop_bomb
A runtime guard for implementing linear types
-
lazycell
A library providing a lazily filled Cell struct
-
with_locals
Function attribute to return references to locals by using CPS
-
rust_info
Extracts the current rust compiler information
-
take_mut
Take a T from a &mut T temporarily
-
semval
Semantic validation
-
advent-of-code
Solutions to Advent of Code
-
amplify_derive
Amplifying Rust language capabilities: derive macros for the ‘amplify’ library
-
tokio-pg-mapper
Proc-macro library used to map a tokio-postgres row to a Rust type (struct)
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
tt-call
Token tree calling convention
-
pipe-trait
Make it possible to chain regular functions
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
evcxr_repl
A REPL for Rust
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
require_unsafe_in_body
Make
unsafe fnstill requireunsafeblocks in the function’s body -
cast
Ergonomic, checked cast functions for primitive types
-
arr_macro
Initialize arrays with ease!
-
gumdrop
Option parser with custom derive support
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
tia
tia; trait, impl, accessors | automatic
-
assertables
Assertables: Rust crate of macros
assert…!,assume…!,assure…!, all for runtime reliability checking. By SixArm.com. -
smart-default
Rust custom-derive macro for Default with more control on the fields
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
batch_oper
batch_oper provides some batch operation macro for some operations
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
predicates-core
An API for boolean-valued predicate functions
-
dict_derive
Derive macros for some PyO3 traits to convert python dicts into rust structs
-
unroll
An attribute-like procedural macro for unrolling for loops
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
chainerror
Make chaining errors easy
-
faux_macros
Implementations for #[create], #[methods], when!
-
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
-
anomaly
Error context library with support for type-erased sources and backtraces
-
structview
Viewing binary data as high-level data structures, safely
-
fstrings
Python3 fstring interpolation in Rust
-
failsafe
A circuit breaker implementation
-
intertrait
Allow for inter-trait casting
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
random-number
Generate random numbers quickly
-
bit_field
Simple bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust’s integral types
-
dynomite-derive
Derives AWS DynamoDB dynomite types from native Rust struct types
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
simple-error
A simple error type backed by a string
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
cast_trait_object
Cast between trait objects using only safe Rust
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
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
-
mode
A behavioral state machine library written in Rust
-
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… -
bool_ext
A crate which defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
tylift
Lift enum variants to the type-level
-
pin-utils
Utilities for pinning
-
arraygen
Derive macro for generating arrays from struct fields
-
illicit
An implicit thread-local environment which is indexed by type
-
lens-rs
lens implemented in rust
-
enum_derive
This crate provides macros for deriving additional functionality for enums
-
rsb_derive
An opinionated macros implementation for Rust struct builder pattern
-
concat-with
Extend the function of the
concat!macro instd -
concat-idents
Allows concatenating multiple identifiers and using them everywhere
-
impls
Determine if a type implements a logical trait expression
-
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
-
merge
Merge multiple values into one
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
variant_count
Derive macro for enum which adds to it the count of variants
-
build-deps
Rust build-script dependencies generator for data/IDL files
-
polymorphic-constant
A macro to define a numerical constant in multiple types at once
-
tracerr
Custom compile time captured error tracing
-
blanket
A simple macro to derive blanket implementations for your traits
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
aspect-weave
An Aspect Toolkit for Rust
-
try_match
An expression macro that does pattern matching and returns the result in
Result -
fehler
A library for error-handling syntax in Rust
-
tc-error
Tinychain’s generic error struct
-
copy_from_str
An extension trait to copy a string into another string
-
rental
A macro to generate safe self-referential structs, plus premade types for common use cases
-
wrapped-vec
Macro for generating wrapped Vec types and associated boilerplate
-
enum-iterator
Tools to iterate over the variants of a field-less enum
-
auto_ops
Macros for easy operator overloading
-
validator_types
Basic type for validator and validator_derive
-
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
-
cex
Checked exception simulation
-
build-fs-tree
Generate a filesystem tree from a macro or a YAML tree
-
direction
Representations of directions
-
bitwrap_derive
macro for bitwrap
-
format
A utility crate to make it easier to work with the formatter
-
thiserror-impl
Implementation detail of the
thiserrorcrate -
macro-attr-2018
This crate provides the
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
v_escape_derive
Procedural macro package for v_escape
-
boomphf
Scalable and Efficient Minimal Perfect Hash Functions
-
by_address
Wrapper for comparing and hashing pointers by address
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
abi_stable_derive
Implementation detail of abi_stable
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
seam
Symbolic Expressions As Markup
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
event-listener-primitives
Low-level primitive for building Node.js-like event listeners
-
tuples
Provides many useful tools related to tuples
-
hado
Monadic do notation using a macro
-
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 -
frunk_proc_macros
Proc macros for Frunk
-
static_assert_macro
Library implementation of so-called
static_assert -
compound-error
Compound errors with flat hierarchy
-
once_self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
progress-streams
Progress callbacks for types which implement Read/Write
-
error_def
A Rust syntax extension for generating error-handling boilerplate code
-
iter-read
A Read implementation for iterators over u8 and related types
-
yui_internal
Internal functions, struct for derive in Yui
-
dynerr
Macros for dynamic error handling
-
fallible_collections
a crate which adds fallible allocation api to std collections
-
displaythis
derive(Display)
-
similar-asserts
provides assert_eq! like macros with colorized diff output
-
current
A library for setting current values for stack scope, such as application structure
-
tide-tera
Use tera templates on tide
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
eventually
Crate for using Event Sourcing in Rust applications
-
unzip-n
Procedural macro to generate
unzipfor iterators over n-sized tuples -
stdext
Extensions for the Rust standard library structures
-
dyn-context
Non-owning service provider pattern implementation
-
thread-scoped-ref
A library that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
mox
Mockery Of X(ML): a JSX-alike syntax for the builder pattern
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
match_any
Provides a declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
io-streams
Unbuffered and unlocked I/O streams
-
err-derive
Derive macro for
std::error::Error -
str-macro
The str!() macro, similar to vec![] but for strings
-
xladd-derive
A simple macro that helps write Excel UDF functions in Rust
-
once
This crate provides an assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
strong
Strongly typed String
-
problem
Error handling for command line applications or prototypes
-
doc_item
Attributes for item-level documentation customization
-
flag-mast
Ergonomic Rust bit flags
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
shrinkwraprs
Auto-derive for Rust conversion traits – make working with newtypes a breeze
-
derive_deref
Adds
#[derive(Deref)]and#[derive(DerefMut)] -
enum-kinds
Generate enums with matching variants but without any of the associated data
-
serde_str_helpers
Helpers for using serde with strings
-
multindex
Index slices with multiple const indices/ranges
-
thiserror_core2
derive(Error) (no_std-enabled using core2)
-
components-arena
Simple library for creating complex domain-specific self-referential data structures
-
yui
An attribute reader generator for Rust
-
tetsy-scale-codec-derive
Serialization and deserialization derive macro for Tetsy SCALE Codec
-
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…
-
trackable_derive
Custom derive for
trackablecrate -
market
Infrastructure for producers and consumers
-
inner
The inner! macro descends into an enum variant. It’s more flexible than try!() and unwrap(), and it works with your enum, too!
-
treeflection_derive
#[derive(Node)] macro for the Treeflection library
-
serbia
No-fuss big arrays for Serde
-
simple-logging
A simple logger for the log facade
-
result-like
Option/Result-like monad interface for your own enum
-
allsorts-rental
A macro to generate safe self-referential structs, plus premade types for common use cases
-
gazebo
A collection of well-tested utilities
-
teloc
Simple, compile-time DI framework for Rust
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
tryhard
Easily retry futures
-
jsonway
JSON building DSL and configurable serializers for Rust
-
range-split
Utilities for splitting sequences with range parameters
-
repeated
Allows you to repeat a block of code a number of times
-
derive-try-from-primitive
Custom derive a try_from method for primitive to enum conversions
-
dipa-derive
The derive macro for the dipa crate
-
ff_derive_ce
Procedural macro library used to build custom prime field implementations
-
rand_derive2
Generate customizable random types with the rand crate
-
rovv
provide the anonymous row type (poor-man’s row polymorphism) in rust
-
mybench
Simple (and very primitive) benchmarking macro
-
grouping_by
A simple library which allows the user to group an iterator by various ways
-
spectral
Fluent test assertions
-
assure
Assure: macros for Rust runtime checks and error handling
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
gtmpl_derive
Derive for gtmpl_value
-
fool
Traits for interoperation of Boolean and sum types
-
ad-hoc-iter
Ad-hoc exact size owning iterator macro and other optional utils
-
throw
Efficiently add statically-calculated stack traces to errors
-
mac
A collection of great and ubiqutitous macros
-
read-restrict
Restrict the number of bytes read from a reader
-
enumx
Ad-hoc enum extension
-
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
pa
Functional Programming tools and ADTs
-
serializable_enum
Two macros for implementing serialization / deserialization for enums containing no data variants
-
trait-union
Stack-allocated trait objects
-
rustc-hex
rustc-serialize compatible hex conversion traits
-
rvs-c-api
C-API for Rvs - A library for defining and evaluating random variables using a simple DSL
-
bitmask-enum
A bitmask enum attribute macro
-
nshare
Conversion between n-dimensional types in different Rust crates
-
spez
Macro to specialize on the type of an expression
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
podio
Additional trait for Read and Write to read and write Plain Old Data
-
collate
Traits and a data structure to support collation and bisection
-
num_enum_derive
Internal implementation details for ::num_enum (Procedural macros to make inter-operation between primitives and enums easier)
-
derive_di
This crate is realized the dependency injection pattern
-
easy-error
Simple error utilities
-
morphism
A structure for suspended closure composition in Rust
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
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… -
devx-cmd
Convenience wrapper over std::process::Command for xtask crates
-
structural
Field accessor traits,and emulation of structural types
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
machine
State machine utilities
-
zkp-macros-decl
Procedural macros
-
impl-enum
Macro for generating methods on an enum that match on the enum and call the same method on each variant
-
lambda_runtime_errors_derive
Rust runtime errors derive for AWS Lambda
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
downcast
Trait for downcasting trait objects back to their original types
-
arrutil
Functions for manipulating arrays from slices
-
trigram
Trigram-based string similarity for fuzzy matching
-
cute
A macro for Python-esque comprehensions
-
error-rules
Archived! Error handling without pain
-
py-comp
A macro implementing a Python-like generator expression
-
named-block
Macro implementing early-exit-from-any-block
-
displaydoc-lite
Implement the Display trait using your standard doc comments
-
rust-fsm-dsl
Macros for rust-fsm DSL
-
annotation-rs
Compile-time annotation parser for rust
-
optargs
Easily create macros for functions with optional arguments
-
timed
Macros to time function execution
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
zkp-macros-lib
Library of procedural macros implemented using
proc_macro2 -
indoc-impl
Indented document literals
-
reax
A reactivity system for Rust that infers dependencies between functions
-
smart_buffer
A hybrid stack/heap buffer
-
derive_builder_macro
Rust macro to automatically implement the builder pattern for arbitrary structs
-
partial_application
partial function application via the partial! macro
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
ref-map
Helper trait for Option and Result to map references
-
single
Provides the Single trait for extracting the element from a single-element iterator
-
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…
-
file
For Rust 1.25 and older. 1-liner convenience functions for reading and writing files
-
char_combinator
An iterator to create all combination of a given char range
-
incomplete
Provides incomplete!(), a compile-time checked version of unimplemented!()
-
adrop
Simple and fast dedicated thread drop
-
default-test
A default trait that can be used in tests
-
simple_parse_derive
A derive macro that implements the simple_parse traits
-
validaten
Common validators for cryptocurrency, creditcards, domain, url, etc that can be used across projects
-
derive_setters
Rust macro to automatically generates setter methods for a struct’s fields
-
kinder
Kinder is a small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
lifted
Higher-kinded types in Rust
-
noship
Noship is a macro that acts similar as todo! but will throw a compilation error when compiled on release profile
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
enum-unitary
Trait and macro for unitary enums
-
constany_blank
Convert any function to constant
-
rustils
Utilities for rust
-
fragile
Provides wrapper types for sending non-send values to other threads
-
noneifempty
Convert T to None if empty
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the relative difference
-
extension-trait
Macro to declare extension traits
-
aoc-main
A macro which defines a handful main for the Advent of Code
-
assert2-macros
procedural macros for assert2
-
aerosol
Dependency injection with compile-time guarantees
-
enum-display-derive
Display trait’s custom derive for simple enums
-
elain
Set a type’s minimum alignment with const generics
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
never
A stable version of the unstable never type (!)
-
frunk_laws
frunk_laws contains laws for algebras declared in Frunk
-
checked_array
A checked API for array types
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
apply-macro
An attribute macro to apply function-like macros
-
closure
A macro for capturing variables on a per variable basis
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
smart_access
A minimalistic “lazy bidirectional pointer” framework
-
typestate
macro_rules! to build typestates
-
moveslice
A one-function crate to move chunks in a slice around
-
turbonone
Simple macro for calling functions with Option arguments
-
init_with
Helper trait to initilize an array with a function
-
generics
Provides macros for parsing generics (with optional where clause) in
macro_rules! -
edisp
Dispatch-on-collect for Rust enums
-
zkp-criterion-utils
Criterion helpers to benchmark over size and number of processors
-
cargo-verify
Prettier error messages for the verified crate
-
preflight
A macro to pipe user input through multiple validation functions and iterate over the resulting errors
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
jomini_derive
Serde macros implementation of
#[derive(JominiDeserialize)] -
aspect
An Aspect Toolkit for Rust
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
boxfnonce
safe FnOnce boxing for rust stable
-
inline_dyn
A container type for storing dynamically-sized types inline
-
ambassador
Trait implementation delegation via procedural macros
-
destruct
Destruct structs and enums for simpler combinator implementation
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
detach
helper type for being able to detach/reatach a member item
-
enum_index
Trait and macros for extracting Enum variant index
-
geo-postgis
Conversion between
geo-typesandpostgistypes -
const_fn_assert
Assertions for const functions
-
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
mdo
Monadic do notation for rust using macro and duck typing
-
one-of
Macro to represent a type that can be converted either
FromorTryIntothe given types -
separator
Formats numbers into strings with thousands separators for readability
-
ts-rs-macros
derive macro for ts-rs
-
snailquote
Escape and unescape strings with shell-inspired quoting
-
result-inspect
Adds the missing Result::inspect() function
-
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
-
tokio-pg-mapper-derive
Proc-macro library used to map a tokio-postgres row to a Rust type (struct)
-
socketpair
Cross-platform socketpair functionality
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
en
The easiest numeric traits!
-
kwarg_macros
Keyword argument plugin
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
deferrer
defer! macro for deferring functions
-
fix_fn
Macro to create recursive closures (similar to the Y combinator)
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
pin-project-internal
Implementation detail of the
pin-projectcrate -
shorten
A collection of convenience functions, macros and traits to shorten repetitive code
-
failure_without_backtrace
Experimental error handling abstraction
-
drop_ok
.drop_oksyntax sugar forResult. It’s instead of.map(|_|()). -
transitive_from
Helper macros for creating hierarchies of transitive
Fromimplementations -
conventus
Traits for assembling and disassembling items
-
normalize_interval
Normalizing interval library
-
type-variance
Marker traits for subtype variance
-
kaguya_rs
Functional Programming tools and ADTs
-
vptr-macros
Procedural macros for the
vptrcrate -
postgres-mapper
Struct mapping for postgres
-
pre-proc-macro
Procedural marco implementations for pre
-
symm_impl
Attribute macro that automatically implements a symmetric trait
-
col_macros
A collection of general purporse macros for construct distinct types of collections
-
ketos_derive
Derive traits for Ketos scripting language
-
custom_derive
(Note: superseded by
macro-attr) This crate provides a macro that enables the use of custom derive attributes -
typename
Stable alternative to Rust’s type_name intrinsic
-
slugify
Macro for flexible slug generation
-
coercible_errors
Zero-cost error handling for generic traits
-
remote-trait-object-macro
Macro that expands a Rust trait to a remote-trait-object service
-
lup
A custom indexed loop macro library for Rust
-
spans
Split an iterator into contiguous spans
-
seymour-protocol
Client protocol for the seymour gemini feed aggregator
-
ff_derive
Procedural macro library used to build custom prime field implementations
-
dispose
A simple wrapper for values that must be consumed on drop
-
dicom-dictionary-std
Standard DICOM attribute dictionary
-
collected
Summation, product, maximum and more special collectors for Rust iterators
-
control-flow
A hack to control control-flow outside closures
-
try_from
TryFrom and TryInto traits for failable conversions that return a Result
-
cassandra_macro
Create Cassandra tables and CRUD CQL prepared statements from Rust structs. (custom derive: cassandra_macro_derive)
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
cynic-proc-macros
Procedural macro crate for cynic - a GraphQL query builder & data mapper for Rust
-
ferrum-plugin
Lazily evaluated, order-independent plugins for extensible types
-
status
Error container
-
lset
Data types describing linear sets
-
apply_method
Allows you to apply any function given as a parameter to the object
-
async-anyhow-logger
An easy crate for catching anyhow errors from an asynchronous function, and passing them to your logger
-
structview_derive
Custom derive for structview’s View trait
-
bind_match
Convenience macro similar to
matches!but binds to variables in the pattern and returns anOptionof the result -
autowired
Rust dependency injection
-
emoji-commit-type
The different commit types used in the emoji committer
-
safecast
Traits to define safe casting between types
-
os-sync
Simple synchronization primitives based on OS semaphore
-
sortby
adds convenient sort functions for Iterators
-
sanitizer_macros
Derive macro for the sanitizer crate
-
log_err
Log error messages from Unwrap and Expect with log crate
-
overload
Provides a macro to simplify operator overloading
-
rjdebounce
Debouncing function utility
-
concat-string
Provides macros for concatenating string slices into owned strings
-
plutonium
Tools to avoid unnecessary use of safe code
-
structdoc
Extract structure and documentation from structs
-
once_spin
Synchronization primitives based on spinning. They may contain data, are usable without
std, and static initializers are available -
enum-utils-from-str
Code generation for mapping from strings to arbitrary values
-
cenum-derive
A rust derive macro for C-style primitive enums
-
round
This crate provides utilities to round your floats with precision from 1 to 10
-
bail-out
Macros to help keep code clean for validations and error handling
-
whiteout
Provides macros that erase the type of any value into an impl Trait for a given trait
-
oauth1-request-derive
A derive macro for
oauth1_request::Requesttrait -
partialdebug
Derive Debug partially
-
switch_statement
A simple switch statement macro
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
repr-trait
Traits to represent Rust reprs
-
chassis
Compile-time dependency injection framework
-
zkp-mmap-vec
Replacement for
Vecthat uses file-backed storage -
boolinator
Provides the Boolinator trait, which lets you use Option and Result-style combinators with bools
-
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
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
tynm
Returns type names in shorter form
-
ea
Ea is helper macro/function to create function chaining
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
match-eq
A
match-like macro that uses PartialEq to “match” each “patten” -
tuple
Element-wise operations on tuples
-
lang_extension
Rust Lang Extension
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
gazebo_derive
Derive macros for the Gazebo library
-
openapi_type
OpenAPI type information for Rust structs and enums
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
high_mem_utils
This crate provides a bunch of mem safe abstractions,some involving transmute
-
rkyv_derive
Derive macro for rkyv
-
tapir
Adding tapping functionality to rust
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
miniserde-enum
Derive macros for miniserde on enums
-
delegatemethod
Delegate method calls to a field
-
skip_error
A macro to help skip an iteration in a loop from a Result
-
proc_use
Semi-dynamic mod and use
-
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
-
sealed
Macro for sealing traits and structures
-
rtlola-macros
Procedural macros for more convenient handling of HirModes in the rtlola_hir crate
-
ternary-rs
A Rust library for emulating the ternary operator from C/C++ (among other languages)
-
new_flattened
Macro to flatten nested calls of
news -
lovm2_std
a lightweight virtual machine with a focus on simplicity and extendability
-
tealr_derive
The derive macro for tealr
-
enum_cycling
Small macro for working with enums
-
iter-comprehensions
A library for iterator comprehensions
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
ops-derive
Derive macros for std::ops
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
error-chain-mini
error-chain for minimalist
-
compile_msg
A plugin for emitting errors, warnings and notes to the developer at compile time
-
derive-aktor
Create actors in rust with a derive macro
-
as-is
An abstraction over ownership
-
as-result
Traits for converting types which may be interpreted as or into a result
-
ffi_helpers
A crate to help make working with FFI easier
-
messages
A midground between channels and actors
-
plague
Parametrized tests tools
-
tch-tensor-like
Derive convenient methods for struct or enum of tch tensors
-
macro_lisp
Lisp-like DSL for Rust language
-
structype_derive
A derive macro crate that lets you view an allowed type’s fields and will let you over-ride it
-
text-block-macros
Create a multiline string literal
-
cast_trait_object_macros
Cast between trait objects using only safe Rust
-
array-lit
Macros for array and
Vecliterals with superpowers -
read-byte-slice
An iterator over chunks of bytes as slices from an underlying reader
-
tuple-arity
Get the arity (number of elements) of tuple types with 0-12 elements
-
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
-
mapcomp
Python-like list comprehensions for standard containers
-
collect_slice
Collect an iterator into a slice
-
byo-graphql
simple bring-your-own graphql client
-
include-flate
A variant of include_bytes!/include_str! with compile-time deflation and runtime lazy inflation
-
trace-error
Extensions to Rust’s error system to automatically include backtraces
-
ndless-static-vars
Rust library for storing static, program-wide parameters for Ndless
-
summon
A logic engine designed to magically give you what you ask for
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
cartesian
QOL macro that creates the cartesian product of multiple iterators
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
structx
Simulating anonymous struct and named arguments in Rust
-
gaclen_shader
Tweaked re-export of vulkano_shader! procedural macro
-
aether_primitives
Helpers for common SDR and signal generation operations
-
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. -
sugar
Rust syntax sugar collections
-
partial_ref_derive
Derives for partial_ref
-
splop
Helper functions to determine the first/last repetition of something
-
winwrap
Rust-friendly Windows API wrappers
-
borked
Simple and convienient error handling library for rust
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
hexfloat
Syntax extension to create floating point literals from hexadecimal strings
-
dcc-lsystem-derive
Macro implementation of #[derive(TurtleContainer)]
-
rocket_failure
Failure like error handling for rocket
-
rotate-enum
A simple macro that implements prev() and next() methods to an enum
-
stringly_conversions
A crate helping to convert to/from various representations of strings
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
assert_into
For when writing .try_into().unwrap() feels too long
-
arcmutex
A convenience library for working with
Arc<Mutex<T>>s -
default-ext
This library provides extension methods for the
Defaulttrait -
startup
Tiny (no dependency, no proc macro) way to run some code before main
-
overflower_support
A bunch of specialized traits + impls to allow automated overflow handling without type inference. Nightly only
-
ffishim_derive
Procedural macros for generating ffi-compatible stubs
-
sum_error
Derive macros for fast summing of error types into error enum
-
impl_ops
Macros for easy operator overloading
-
reduce
Fold an iterator without an initial value
-
cor_iter
Correlate of two iterators
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
diesel-derive-newtype
Automatically connect newtypes to Diesel using their wrapped type
-
parameterized_test
A macro to support providing arguments to test functions
-
annotation-rs-beta
Compile-time annotation parser for rust
-
float
Lightweight wrappers around primitive floating point types
-
block_effects
A macro to chain block effects
-
byteorder_core_io
Library for reading/writing numbers in big-endian and little-endian
-
purpurea
Attribute based accessor/updater/mutator/constructor generation
-
is-same
A trait for comparing object equality
-
left-pad
Provides left-padding for strings
-
show
A
show!debugging macro to print expressions with the Show formatting trait, without writing out"{}",in theprintln!macro -
iter_vals
On the fly iterator creation
-
qadapt-spin
Synchronization primitives based on spinning. They may contain data, are usable without
std, and static initializers are available -
rlua-builders
Derive helpers for struct/enum for rlua
-
rustollens
A small and experimental library with a type-level representation of booleans with companion connectives for compile-time sort-of fun with logic
-
swahili-dsl
A Swahili-based DSL made for educational purposes
-
stackpin
Crate for data that should be pinned to the stack at the point of declaration
-
whaterror
Customizable handling for fallible main
-
enum_primitive
Macro to generate num::FromPrimitive instances for enum that works in Rust 1.0
-
conform
Macro to transform struct string fields in place
-
quick-error2
A macro which makes error types pleasant to write
-
ow
Ow calls a function with self
-
rvs-parser
Parser for Rvs - A library for defining and evaluating random variables using a simple DSL
-
null-terminated
Library of null-terminated slices and UTF-8-encoded strings with thin references
-
xkcd_unreachable
A Rust macro xkcd_unreachable!() inspired by https://xkcd.com/2200/
-
duplex
The Duplex trait: interactive streams
-
swiss-army-knife
Common utility code to support linux-support and other projects
-
entity_rust
Event driven CES framework for Rust with a macro DSL
-
grange
create range numbers macro
-
endian_trait
A trait for Endianness conversions that can be implemented on most types
-
ambience
Lightweight library for passing ambient parameters
-
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… -
list_builder
Python-like list comprehensions in Rust
-
rusty_v8_helper_derive
A rust derive macro for rusty_v8_helper
-
apply_attr
A syntax extension providing higher-order attributes to Rust
-
fff_derive
Procedural macro library used to build custom prime field implementations
-
isnt
Inverted versions of boolean-valued stdlib functions
-
join_impl
Implementation of the
join!macro -
once-cell-regex
This crate just gives you the
regexmacro from theonce_celldocs! -
simpledi-rs
simpledi-rs, a simple and thread-safe dependency injection library
-
type-uuid
Safe, stable IDs for Rust types
-
shoggoth
Generic and type-level programming for Rust
-
embedded-error-chain-macros
Procedural macros of the
embedded-error-chaincrate -
enhanced_enum
Enhanced Fieldless Enumerations and Associated Array Types
-
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
postgres-derive-macros
Deriving macro support for Postgres enum, domain, and composite types
-
generator_extensions
Basic extensions to Generator types to bring parity with Iterators
-
envsubst
Variables substitution
-
const-if
This crate adds if-else expression into your constant functions
-
dependent_ghost
An implementation of Matt Noonan’s ‘Ghosts of Departed Proofs’
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
sorted
Provides compile time guarantees for sorted sequences
-
errer
Flexible error management for Rust. An middle-ground between failure and SNAFU
-
mockers_derive
Macro 1.1 implementation for ‘mockers’ mocking library
-
nom-fields
Provides a single function-like macro that removes some boilerplate from a common pattern when using nom
-
ufcs
Helper trait to call free functions using method call syntax
-
reexport-proc-macro
Re-export a procedural 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. -
pinpoint
Crate for pinned references
-
clos
Common Lisp Object System for Rust programming
-
try-insert-ext
Extends various types with
try_insert_withmethods -
typic
Type-safe transmutations between layout-compatible types
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
zisvalidator_derive
Derive macro for zisvalidator
-
yade
Yet Another Derive Error
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
ferrite-session
Session Types DSL for Rust
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
cbox
C pointer boxing, for when working with ffi
-
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. -
lens-rs_derive
macro to derive lens for data type
-
byte-slice
Byte slice manipulation macros
-
hirpdag_derive
Procedural macro for generating hirpdag boilerplate. See hirpdag crate.
-
prange2
Parse numeric ranges for indexing
-
unique
ptr::Unique for stable Rust
-
kg-diag-derive
Macro implementation for #[derive(Detail)]
-
eager
Crate for eager macro expansion
-
inherent-pub
Mark methods in
impl Trait for Typeblocks inherent to the type -
almost
A crate for comparing floating point numbers
-
unwrap_all
Unpack multiple levels of
Result<T, E>andOption<T>at once -
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
rsor
Reusable slice of references
-
vec_box
A single macro to create a vec of boxed elements, for trait objects
-
read-from
Supplies the ReadFrom and WriteTo traits
-
dsl_macros
Convenience macros that rewrites method calls inside a builder closure
-
enum-primitive-derive-nostd
enum_primitive implementation using procedural macros to have a custom derive
-
variantly
Derive helper methods for enum variants that are familiar from
std::option::Option&std::result::Resultsuch asunwrap_ororand_then -
rust-iteratorcomprehensions
A comprehension syntax for iterators implemented as macros
-
aabb3
aabb3
-
either_trait_macro
An attribute-like macro to implement traits for Either
-
tlayuda
A derive procedural macro for structs that adds a static method that generates instances of the struct with minimal configuration
-
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:…
-
rubbl_core
Core types and traits for Rubbl, a Rust package for astrophysics
-
clone_all
clone_all!(my,variables,with,long,names);
-
io-error
Simple and convenient macro for creating I/O errors
-
disjoint-borrow
Disjoint mutable borrows of slices
-
compiler_error
Triggerable compiler error
-
rev_slice
A newtype for operating on a reversed view of a slice
-
multi-structs
Macro for generating a merged struct from multiple sub-structs
-
map_for
A Rust macro that implements for comprehensions similar to Scala’s
-
stringreader
Provides a wrapper for strings so that they can be consumed via the std::io::Read trait
-
dto_derive
Derive for automatic mapping DTOs to Entities and vice versa
-
num_alias
simple macros to declare ‘type checked’ aliases for integers and floats
-
c2rust-bitfields-derive
C-compatible struct bitfield derive implementation used in the C2Rust project
-
rubber_duck
Enables building functions that can be called with named arg syntax
-
xplane_plugin
Provides types and a macro for creating X-Plane plugins
-
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.
-
funfun
Macros for working with closures
-
unique-type-id-derive
A unique id proc-macro generator for types
-
mcurry
Macros for creating curried functions
-
peek-nth
An iterator adapter that allows you to efficiently peek the nth item of an iterator
-
printf-rs
printf c language like
-
macro_macro
Macro templating library for DRYer structs
-
string_map
Create a record to store any type of value
-
fn_chain
Helper macro/function to create function chaining
-
public
A macro used to make struct/union and its fields public
-
throws
A macro for easy creation per-function errors
-
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
ref-portals
Safely use (stack) references outside their original scope
-
with_locals-proc_macros
TODO!
-
mods
Simpler module declaration
-
actix-multipart-derive-impl
Procedural derive macro implementation for actix-multipart-derive
-
koute/nes
An NES emulator written in Rust
-
enum-iterator-derive
Procedural macro to iterate over the variants of a field-less enum
-
hash-db
Trait for hash-keyed databases
-
enum_variants
Deriving traits for C-like enums using macro 1.1
-
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
-
adante
A versatile, small options parser for use in the command line
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
container_literals
vec! like macros for creating maps and sets
-
diff_derive
A derive macro for implementing Diff on the diff-struct crate
-
ord_by_key
Provides a convenient macro for implementing Ord trait with logic specified in an inline expression
-
transaction
transaction abstraction library (a.k.a. transaction monad)
-
peek-poke-derive
Derive macro for peek-poke
-
byte_conv
Simple conversion traits to bytes
-
bitwise_reduce
Multiple arity bitwise functions
-
to_vec
convenient to_vec, to_set and to_map methods on iterators
-
better-as
Explicit type casting
-
drop_some
.drop_somesyntax sugar forOption. It’s instead of.map(|_|()). -
eliza_error
“Times are bad. Children no longer obey their parents, and everyone is writing an error handling library.” — Cicero
-
quack
Duck typing traits
-
bumpalo-herd
Support for bumpalo in scoped threads & rayon
-
colorskill
Some useful color manipulation functions
-
enumflags2
Enum-based bit flags
-
enum-tryfrom
Error types and traits for use with enum-tryfrom-derive
-
errloc_macros
Error location utility macros
-
coalesce
Combine disjoint types that share common traits
-
conditional
Provides a conditional! macro which lets you use the syntax of the conditional operator (also known as the ternary operator) in Rust
-
altbitflags
Macros to implement a struct which behave similar to bitflags
-
derive-new
#[derive(new)]implements simple constructor functions for structs and enums -
with-macro
Syntactic sugar for calling methods
-
yolo-block
Like a
tryblock, but automatically unwraps the result -
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…
-
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.
-
autowired-derive
Autowired project derive macro support
-
rustorm-derive
procedural macro code generator for rustorm
-
derive_create
Helper library for launchd
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
derive-error
Derive macro for Error using macros 1.1
-
angular
Angular types and common helper methods
-
newtype-enum
Traits to convert between enums and their variant types
-
path_semantics_std
A Rust type checked implementation of the standard dictionary of path semantics using constrained functions
-
fast_new_type
A proc_macro attribute to implement common traits for a custom type wrapping other
-
tiny_fail
Provides simple Fail type
-
comprehension
Iterator comprehension in Rust
-
cstr-enum-derive
Derive macros for the cstr-enum crate
-
slice-ext
Useful extensions to slices and iterable types
-
on_demand
A macro to generate aux macros for on-demand usage
-
enum_macro
Useful macro for enum
-
abscissa_generator
Template-based generator for creating new Abscissa applications
-
taken
Macros for taking ownership, staring Liam Neeson
-
error_derive
Macros for deriving Error implementations through custom_derive!
-
mpesa_derive
MpesaSecuritytrait derive macro crate -
enum-derive-2018
This crate provides macros for deriving additional functionality for enums
-
sexpy_derive
Derives sexpy trait definitions for types
-
jane-eyre
By Currer Bell
-
default-boxed-derive
Custom derive for default-boxed
-
take-until
A take until extension for iterators
-
const_fn
An attribute for easy generation of const functions with conditional compilations
-
tagged_ptr
A safe tagged union pointer datastructure for x64
-
defmac
A macro to define lambda-like macros inline
-
mysql_enum
Convert between Rust enum and MySQL enum
-
uavcan-derive
Makes it possible to derive Uavcan related types
-
phantom-enum
A simple macro library for creating phantom enums
-
higher
Higher kinded types, in a way
-
clipboard2
clipboard2 is an improved version of clipboard-rs with better error handling and MIME type handling on Windows
-
assert_that
Helper macros for use with boolean-valued predicate functions
-
appro-eq
Approximately equal traits and assertion
-
string_to_expr
Compile-time expression evaluation for strings
-
filters
Build filters/predicates with the builder pattern
-
expect_macro
The expect! macro
-
notosans
A simple crate providing several of Google’s Noto Sans true type fonts as slices of bytes
-
std_prelude
prelude that the rust stdlib should have always had
-
secbox
Sensitive data container
-
chained_iter
Provides a small helper macro for creating iterators out of values without allocation
-
event_feed
Event systems implemented using event feeds
-
pstr
Global String Intern Pool
-
dont_panic
panic!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won’t panic.
-
evitable
Custom error types with context and derive
-
rhs_first_assign
An attribute macro to hack compound assignment
-
rust-enum-derive
A simple library (and program) for generating rust enums and associated traits from text files
-
mox-impl
Implementation for the mox! macro
-
named_constants
Procedural macro makes enums behave like named constants in languages like C/C++ or C#
-
asn1-cereal
ASN.1 and BER serialization
-
clone-into-box
A library for cloning trait objects
-
path-ext
Provide convenient methods for path operations
-
ocl-core-vector
OpenCL-compatible vector primitive types
-
count_tts
A simple macro for counting tokens
-
cdrs_helpers_derive
Derive CDRS helper traits
-
derive_display_from_debug
A trivial Rust macro to derive the Display trait for any type with the Debug trait
-
handler_map
Map from types to functions that receive them
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
nan-preserving-float
(Mostly) drop-in replacement for floats that preserves the signalling bit in NaNs under conversions and unary operations
-
enum_from_str
Enable deriving FromStr for enums
-
tuple_list
Crate for macro-free variadic tuple metaprogramming
-
stack-vec
Ad-hoc compile-time sized
Vec<T>like types on the stack -
tense
n-rank tensor calculus
-
overflow-error
Common overflow error types
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
every_variant
To be used with all variant, contains the derive macro
-
generic
Higher level serialization of rust values to rust values
-
carboxyl_window
Functional reactive window API
-
better_any
Type id and Any for non static types
-
capture
A macro for adding explicit capture clauses to a (closure-) expression
-
frunk-enum-derive
Derive macros to implement the frunk::LabelledGeneric trait on enums
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
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
-
enumflags_derive
Bitflags
-
wrapped_enum
Useful macro to wrap existing types in an enum (common use for quick error handling)
-
enum-methods
Generates methods for each enum variant
-
he_di_internals
Common code for he_di crates
-
common_failures
Helpers for ‘failure’, including io::Error wrappers with paths, quick_main!, display_causes_and_backtrace
-
pub-iterator-type
Abstract an iterator implementation behind a struct tuple
-
vesta-macro
Procedural macros used by and exported from the Vesta crate
-
ref-cast-impl
Derive implementation for ref_cast::RefCast
-
iter_from_closure
Iterator<Item = Item> from FnMut() -> Option
-
input-stream
IO streams similar to C++’s streams
-
objc-macros
Handy macros for interacting with Objective-C from Rust
-
enum_properties
A macro for declaring static properties on enum variants
-
multi-eq
Macros for creating custom equality trait derives
-
enum_for_matches
enum_for_matchesis a procedural macro that runs a match arm for each enum variant passed into it regardless of type -
inherent
Make trait methods callable without the trait in scope
-
wrap
Generic function wrapping
-
flow_impl_derive
Definition of a derive macro for FlowImpl
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
nes
New Error System for rust
-
ay
Ay automatically implement Fn* traits for structs and enums
-
arc-io-error
A version of std::io::Error implemented on top of Arc instead of Box, making it cloneable
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
rustup-find
Use rustup to automatically find and/or install the latest Rust version that supports all the currently installed components
-
erroneous
Minimalistic helper for using errors
-
zkp-error-utils
Assertion like macros for returning
Result::Err -
exclusive
Place code into an exclusive context that won’t collide with another context
-
error-context
Methods and types that help with adding additional context information to error types
-
frunk_proc_macro_helpers
Common internal functions for frunk’s proc macros
-
scroll_derive
A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate
-
internship
Interned string and more
-
eraserhead
erase the lifetimes from types
-
boow
Borrow Or oWnedsmart pointer. Alternative to Cow. -
unstd
A little utility belt
-
derive-into-owned
Custom derives to help with types containing Cow fields
-
default-conversion
A derive macro to automatic implement conversions between similar structs
-
asserter-macros
New assertion library for rust
-
split_preserve
An iterator that splits on whitespace but doesn’t throw it away
-
clone-block
A very simple macro that clones a list of variables before calling an expression
-
fn-error-context
An attribute macro to add context to errors from a function
-
checked_ops
Automatic checked arithmetic operations in Rust
-
try-exit
Dependency free, simple error handling for small programs
-
seek-ext
Extension trait to add convenience methods to
io::Seektypes -
stable-pattern
Stable port of std::str::Pattern and friends
-
escher-derive
Self-referencial structs using the async/await transformation
-
endian-type
Type safe wrappers for types with a defined byte order
-
actix-handler-macro
Helper macros for using Actix. Generates handlers, actors and address traits.
-
into_inner_drop
A helper library for implementing into_inner method for drop types safely
-
builder_macro
A macro to generate structs and a corresponding builder
-
fn_ops
Temporary traits for function operator overloading, pending the stabilization of
Fn,FnMut, andFnOnce -
traitcast_core
Cast between dynamic trait objects
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
lovm2_internals
a lightweight virtual machine with a focus on simplicity and extendability
-
thin-slice
An owned slice that packs the slice storage into a single word when possible
-
collect_array
Allows for collecting an Iterator into an exactly sized array
-
rlua-builders-derive
Derive helpers for struct/enum for rlua
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
verified
A library of types to facilitate the development of verifiable rust
-
cutlass
Macro based library to take the boilerplate out of configuration handling
-
struct-pad
Padding types to enable memory layout optimizations
-
into-result
A simple convenience trait for converting something into a
ResultorOption -
snaptest
Dead simple snapshot testing
-
cdrs-tokio-helpers-derive
Derive CDRS helper traits
-
dync-derive
Attribute macros for producing
dynccompatible traits -
diverge
Extension injection site specification through a simple macro
-
as-dyn-trait
An attribute macro that generates methods for retrieving supertraits from trait-objects (upcasting)
-
quixutils
Common helpers and utils
-
serde_type_name
lookup name of type for any struct or enum that derives serde Serialize
-
varianteq
Derive the equality of enum variants ignoring fields
-
doublysure
Using types to make sure that you’re sure, sure, and doubly sure
-
iroha
A tokenization Library for Rust
-
transaction-stm
transaction abstraction of stm
-
respector
An extension to add inspect method to Option and Result types
-
cstr-argument
A trait for converting function arguments to null terminated strings
-
kvfmt
A helper macro for stringifying variables into a key=value style string
-
dump
A simple macro that takes one or more variables and prints the name, type, and value of each variable. The output is also prefixed with [source_file:line_no].
-
tuple-map
map methods for tuple
-
err_tools
Helper traits and functions for building errors in rust
-
dyn_safe
Take control of the Semver hazard of the
dynsafety of your traits! -
scoped-callback
Register scoped functions with local references to ’static lifetime callbacks in a safe manner
-
format-core
Core format types
-
cenum
A rust derive macro for C-style primitive enums
-
as-any
provide the AsAny trait
-
fn-compose
A small macro for function composition
-
anon
Anonymous struct macro
-
expand
Macro to expand byte string and string literals
-
underscore_args
Macro for underscore named argument syntax, aka Dyon
-
variant_access_derive
Prodedural macros for deriving the VariantAccess traits
-
match-downcast
A set of downcasting matching Rust macros
-
from_as
Traits and derive macros to Read and write types that implement serde Serialize and deserialize to files
-
unborrow
Macro for calling a &mut self method with transient &-borrows of self in the parameters
-
new_type
Improve the semantics and correctness of your code by embracing newtypes
-
extprim_literals_macros
Internal crate to support
extprim_literals. You typically don’t need this crate directly. -
frust
Functional Programming in Rust
-
duck
Like
Iterator::peekable, but can be stacked an arbitrary number of times -
error-type
Provides a macro for constructing unifying error types
-
unify
Trait-based equality constraint for Rust
-
rkyv_typename_derive
Derive macro for rkyv_typename
-
lisbeth-tuple-tools
A set of tools for tuple manipulation
-
fmt_adapter
Provides newtype adaptors to and from any formatting trait
-
structural_derive
Implementation detail of the structural crate
-
multizip
Zip 3, 4, 5 or more Rust iterators
-
enum_cycling_derive
Small macro for working with enums
-
tilde
Using ~ to provide syntax sugar for Rust
-
blunder
Dumb crate to make error handling easy
-
tyenum
Attribute macro for type enums
-
serde_int_map
Crate to derive serde traits for integer-indexed structs
-
dioptre-derive
Custom derive macro for #[derive(Fields)]
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
powerset-enum
A poor man’s anonymous enum
-
hash-of
A typesafe wrapper for hashes
-
tylar
Type-Level Arithmetic in Rust
-
sconcat
String concatenation
-
pre
Compile-time assistance for working with unsafe code
-
hoist_temporaries
Procedural macro to extend the lifetimes of temporary variables
-
take-if
A tiny utility for conditionally taking the contents of an option
-
eieio
Error Implementing
Eq + Clonereplacingstd::io::Error -
newtype_array
A macro to help implementing the standard derived traits on newtype arrays
-
dynamic
A dyanmically typed value with fast downcasting
-
zkp-macros-impl
Implementation crate for
proc_macro_hack -
char-device
Character Device I/O
-
bytecheck_derive
Derive macro for bytecheck
-
libsugar
libsugar provides syntactic sugar in the form of a library
-
lift-fail
A library to handle
failurein an iterable collection -
enum_traits_macros
Procedural macros that adds functionality to enums by deriving traits from the crate
enum_traits -
safe
A
#[safe]attribute for explaining whyunsafe { ... }is OK. -
repr-trait-derive
Derive macros for working with repr-trait
-
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
-
named
Procedural macro which allows you to produce functions which can be called with named arguments, optionally with default values
-
cute_custom_default
Derive macro for
Defaulttrait with customization -
try_clone_derive
a crate wich add a derive TryClone macro for the TryClone Trait of the fallible_allocation crate
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
ptr_meta_derive
Macros for ptr_meta
-
monad
Stackless monads in Rust
-
tramp
Trampoline for recursive functions, with support for mutual recursion
-
structype
This crate contains the exported types used in https://github.com/nohupped/structype_derive
-
hmap
Adds hmap! macro for easily generate HashMap
-
tearor
Easily turn data races into data corruption!
-
enumerate
An attribute macro that, given a trait and its implementers, generates an enum that can be used instead of a trait object, avoiding dynamic dispatch
-
boxing-day
Unwrap a Box in festive fashion, only on boxing day!
-
validated-slice
Helper macros to implement std traits for custom validated slice types
-
higher-derive
Custom derives for
higher -
deep_safe_drop
Safe dropping of deep trees that otherwise could cause stack overflow
-
scopefunc
A trait defining kotlin-like scope functions
-
scrapmetal
Scrap Your Rust Boilerplate
-
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
-
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
-
tch-tensor-like-derive
Derive macro implemenations used by tch-tensor-like crate
-
slist-derive
Deriving traits for the slist crate
-
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.
-
join_to_string
Join a list of items to string/buffer
-
hazard
Hazard pointers
-
threadbound
Make any value Sync but only available on its original thread
-
pointer
A simple crate to make it easier to iterate on pointers
-
macro_const
A macro for creating corresponding macro definitions for constants which evaluate to the same values
-
uncheck-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
rvs_derive
A helper macros implementation for Value Classes in Rust
-
rvs
A library for defining and evaluating random variables using a simple DSL
-
dispose-derive
Derive macro for the dispose crate
-
pure_decimal
A decimal type with no NaN and Infinity
-
wrap_result
easy to wrap Ok(value) , Err(value) or Some(value)
-
is-same-derive
Derive proc macro for the is-same crate
-
transfer
Crate that exposes a Transfer trait, that is to move what Clone is to copy
-
layered-io
I/O traits extending Read and Write
-
overloadf_derive
unlock function overloading for rust
-
random-number-macro-impl
Generate random numbers quickly
-
frunk_derives
frunk_derives contains the custom derivations for certain traits in Frunk
-
enumn
Convert number to enum
-
curry-macro
Have fun currying using Rust’s native closure syntax
-
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…
-
outcome
A Success/Failure type for rust
-
tuple-conv
Allows converting tuples of one element to vectors
-
polling-async-trait
A proc macro that creates async methods based on polling methods for your trait
-
enumx_derive
Macros for ad-hoc enum extension
-
stringer
An easy way to turn an Unsafe *const c_char into a Rust String type and return a pointer
-
next-gen_proc-macro
Safe generators on stable Rust
-
type-layout
Derivable trait to view the layout of a struct, useful for debugging
-
shippai
failure in other languages
-
derive_di_core
This crate give traits for the parent crate derive_di
-
hlist
Heterogeneous list with type-directed search
-
enum_index_derive
Macros for extracting Enum variant index
-
subset
Various subsets of slice’s items that are able to iterate over references to selected items
-
identity
A stable Rust implementation of an identity (a.k.a., “equality witness”) type
-
merge_derive
Derive macro for the merge::Merge trait
-
bounded
Bounded numeric types
-
typic-derive
Type-safe transmutations between layout-compatible types
-
functionate
Automatically implement Fn* traits for structs and enums
-
try_enum
match enum
-
endian_trait_derive
A custom derive for the Endian trait
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
tyname
Retrieve type names during program execution on stable Rust
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
ps
A safe wrapper around
std::mem::transmute -
loosen_map
Calls a function with self
-
error-chain-mini-derive
derives for error-chain-mini
-
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
into-owned
Provides a trait for associating a type with its owned variant
-
forever
-
unwrap_return
A set of macros for returns and breaks in the None and Err cases
-
recap-derive
Derives FromStr impl for types which are then deserialized using recap
-
serde_mtproto_derive
Procedural macro helper for serde_mtproto
-
napi-derive
N-API procedural macros
-
units
Units of Measure for Rust. Easy to use, type-safe and customizable.
-
newtype_derive
This crate provides macros for deriving common traits for newtype structures
-
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…
-
tuplex
Rust tuple extension
-
arrayref
Macros to take array references of slices
-
arr_macro_impl
Private impl crate for arr_macro
-
fma
Tiny crate to use FMA(Fused Multiply-Add) instruction easily
-
concat_strs
Macro for quickly building a String from components
-
arsert_failure
Traits used by the
arsertcrate -
lambek
Type-Level Programming in Rust
-
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…
-
type_level_examples
Examples of using type-level values and functions
-
dmutil
A collection of utility macros to ease the creation of other macros
-
same
Traits for testing identity of objects
-
rovv_derive
provide the anonymous row type (poor-man’s row polymorphism) in rust
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
sixarm_assert
Assert macros for Rust tests. By SixArm.com.
-
w_result
A result type that carries warnings
-
pipe_macro
A macro to pipe function calls like in functional programming languages
-
try-traits
Alternatives to std lib traits that can fail
-
futures-signals-structs
Derives mutable versions of structs for the futures-signals crate
-
from_file_derive
Enable #[derive(FromFile)]
-
structbuilder_derive
Super simple macro to derive a builder trait for your struct
-
bitpat
Bit-level matching against values
-
from_map
A crate that exposes the
FromMaptrait -
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.
-
mines
Unchecked assertions of unreachability which panics on debug builds
-
typed_index_derive
Custom derive to easily create newtype index types
-
scale_impl_generator
a proc macro to generate a large percentage of all impls on SCALE crypto primitives
-
displaydoc-watt
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
loosen
Derives a wrapper function which loosen the arguments into a tuple
-
owning_ref
A library for creating references that carry their owner with them
-
passert
Pretty/Power assertion macros for rust
-
is-impl
Rust macro to check that a type conforms to an impl
-
exitfailure
A basic newtype wrappers for use with ? in main
-
conform-derive
Macros 1.1 implementation of #[derive(Conform)]
-
idealist
A library of non-empty wrappers for standard list types
-
enum_variant_type
Generates types for each enum variant and conversion trait impls
-
mem_macros
align_of and size_of as a macro, to avoid turbofish notation
-
static-events
A library for creating zero-cost event systems
-
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…
-
handle-error
An error handling helper macro to avoid the constant if let Err(e) pattern
-
rusteval-derive
macros for rusteval
-
flow_impl
Definition of an Implementation trait for flow functions, and a derive macro
-
iter-python
Python generator expressions and ‘list’ comprehensions
-
bitpattern
bitwise pattern matching and extracting
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
function_name
macro that expands to the name of the annotated function
-
vesta
Extensible pattern matching
-
static_slice
Macro for creating static slices of arbitrary types
-
specialize
Type specialization macros and helpers
-
function_group
A macro to hack in function overloading to rust
-
integer-result
Convert primitive and non-zero integer types to a Result
-
parse-display-derive
Procedural macro to implement Display and FromStr using common settings
-
from_variants_impl
Internal helper crate for from_variants crate
-
fixed-macro-impl
Proc-macro implementation for the
fixed-macrocrate -
as_tuple
View any struct as a tuple! ✨
-
stringlit
A macro to convert from str to String
-
boolenum
Derive From and Into for your boolean enums
-
cex_derive
Macros for checked exception simulation
-
format-macro
Format procedural macro
-
withers_derive
A macro to implement wither methods for properties of a struct
-
union_type
A proc macro to introduce union type into rust
-
struple
Convert structures from and to tuples
-
map-trait
Generic Map trait
-
derive_from
A simple derive(From) macro
-
col_proc_macros_impl
The implementation crate of macros marked with the proc-macro-hack derive macro
-
gatherr
Helpers for collecting values and errors from result iterators
-
byte_string
Wrapper types for outputting byte strings (b”Hello”) using the Debug ({:?}) format
-
dioptre
Struct field projection tools
-
openapi_type_derive
Implementation detail of the openapi_type crate
-
value
Type-level constants for generic contexts
-
dep-obj
Dependency object: effective reactive heterogeneous container
-
bevy_fallible_derive
Proc macro crate for bevy_fallible
-
downcast-trait
Allow casting between traits
-
debug_stub_derive
A drop-in replacement for
#[derive(Debug)]that supports replacement values for members which do not implementfmt::Debug. -
verilog-arc
A rust proc macro based code generation backend for OpenVAF
-
from_as_file
Traits to Read and write types that implement serde Serialize and deserialize to files
-
substrs
A crate for substring functionality for the str type in Rust
-
pluralize
A generic trait across single and multiple elements
-
verify_macro
An attribute that automatically instruments code with logical type bounds
-
assert-impl
Macro for static assert types implement a trait or not
-
rawslice
Reimplementation of the slice iterators, with extra features. For example creation from raw pointers and start, end pointer accessors.
-
extdot-impl
Please see
extdotcrate for actual usage -
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
string-builder
A simple string builder type
-
char_fns
unicode character-indexed string manipulation
-
io-arrays
Random-access I/O
-
lens-rs_generator
generating optics for source files
-
field_types
Some derive macros for deriving enums, corresponding to the fields of structs
-
bstringify
stringify! that yields byte string literals instead
-
nifpga-type-macro
helper macro for nifpga datatype
-
abi_stable_derive_lib
Implementation detail of abi_stable
-
serde_int_map_traits
Reusable traits for serde_int_map
-
adhocerr
A library for the construction of efficient single use static/dynamic error types per callsite
-
static-cond
Macro for performing comparisons during macro expansion