-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
error-chain
Yet another error boilerplate library
-
synstructure
Helper methods and macros for custom derives
-
quick-error
A macro which makes error types pleasant to write
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
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!,defer_on_success!as shorthands for guards with one of the implemented strategies -
ordered-float
Wrappers for total ordering on floats
-
frunk
Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
lazycell
A library providing a lazily filled Cell struct
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
approx
Approximate floating point equality comparisons and assertions
-
owning_ref
A library for creating references that carry their owner with them
-
once_cell
Single assignment cells and lazy static values without macros
-
nodrop
A wrapper type to inhibit drop (destructor). Use std::mem::ManuallyDrop instead!
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
rental
A macro to generate safe self-referential structs, plus premade types for common use cases
-
trackable
This library provides a way to track objects manually as an alternative to mechanisms like backtracing
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
derivative
A set of alternative
deriveattributes for Rust -
indoc
Indented document literals
-
derive_builder_core
Internal helper library for the derive_builder crate
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
lazy-static-include
This crate provides
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
rust_info
Extracts the current rust compiler information
-
static_assertions
Compile-time assertions to ensure that invariants are met
-
interpolate_idents
Useable macro identifier concatenation plugin
-
assert_matches
Asserts that a value matches a pattern
-
simple-error
A simple error type backed by a string
-
hex-literal
Procedural macro for converting hexadecimal string to byte array at compile time
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
bitfield
This crate provides macros to generate bitfield-like struct
-
annotate-snippets
Library for building code annotations
-
frunk_proc_macro_helpers
Common internal functions for frunk’s proc macros
-
noisy_float
Contains floating point types that panic if they are set to an illegal value, such as NaN
-
frunk_proc_macros
Proc macros for Frunk
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
opaque_typedef
Supports defining opaque typedefs
-
reexport-proc-macro
Re-export a procedural macro
-
cast
Ergonomic, checked cast functions for primitive types
-
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
-
auto_enums
A library for to allow multiple return types by automatically generated enum
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
elastic_types_derive_internals
Codegen internals for elastic_types
-
abscissa
Application microframework with support for command-line option parsing, configuration, error handling, logging, and shell interactions
-
downcast
Trait for downcasting trait objects back to their original types
-
scroll_derive
A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate
-
derive_utils
A procedural macro helper for easily writing custom derives for enums
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
chainerror
Make chaining errors easy
-
take_mut
Take a T from a &mut T temporarily
-
file
For Rust 1.25 and older. 1-liner convenience functions for reading and writing files
-
throw
Efficiently add statically-calculated stack traces to errors
-
cex
Combinators of EnumX, for error-handling
-
lambda_runtime_errors
Rust runtime errors for AWS Lambda
-
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 -
auto_enums_core
This library provides an attribute macro for to allow multiple return types by automatically generated enum
-
enum_derive
This crate provides macros for deriving additional functionality for enums
-
auto_enums_derive
This library provides an attribute macro like a wrapper of
#[derive], implementing the supported traits and passing unsupported traits to#[derive] -
if_chain
Macro for writing nested
if letexpressions -
cstr
Macro for building static CStr reference
-
coercible_errors
Zero-cost error handling for generic traits
-
spaces
Set/space primitives for defining machine learning problems
-
iterslide
A “sliding window” iterator
-
simple-logging
A simple logger for the log facade
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
enumx
Structural enum implemented in enum exchange
-
mode
A behavioral state machine library written in Rust
-
custom_derive
(Note: superseded by
macro-attr) This crate provides a macro that enables the use of custom derive attributes -
err-derive
Derive macro for
std::error::Error -
quick-error2
A macro which makes error types pleasant to write
-
incomplete
Provides incomplete!(), a compile-time checked version of unimplemented!()
-
current
A library for setting current values for stack scope, such as application structure
-
newtype_derive
This crate provides macros for deriving common traits for newtype structures
-
lambda_runtime_errors_derive
Rust runtime errors derive for AWS Lambda
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
filters
Build filters/predicates with the builder pattern
-
safe-transmute
A safeguarded transmute() for Rust
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
problem
Error handling for command line applications or prototypes
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
error_def
A Rust syntax extension for generating error-handling boilerplate code
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
enum_kind
Easily manage values related to enum
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
py-comp
A macro implementing a Python-like generator expression
-
kaguya_rs
Functional Programming tools and ADTs
-
abi_stable_derive_lib
Implementation detail of abi_stable
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
structview
Viewing binary data as high-level data structures, safely
-
libffi-sys
Raw Rust bindings for libffi
-
single
Provides the Single trait for extracting the element from a single-element iterator
-
gumdrop
Option parser with custom derive support
-
failchain
Ergonomic companion library for failure
-
string_enum
String based enum
-
proc_macro_roids
Traits and functions to make writing proc macros more ergonomic
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
enumflags
Bitflags
-
autodiff
An automatic differentiation library
-
morphism
A structure for suspended closure composition in Rust
-
predicates-core
An API for boolean-valued predicate functions
-
diff-enum
A macro library to help defining enum variants by their differences
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
defmac
A macro to define lambda-like macros inline
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
gpg-error
Libgpg-error bindings for Rust
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
static_assert_macro
Library implementation of so-called
static_assert -
build-deps
Rust build-script dependencies generator for data/IDL files
-
iter-python
Python generator expressions and ‘list’ comprehensions
-
resiter
Helper crate for handling iterators over result
-
bitmask
A bitmask generator for enum scoped bit flags
-
pin-project
An attribute that creates a projection struct covering all the fields
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
join_to_string
Join a list of items to string/buffer
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
vlog
Macros to do stdout / stderr logs based on verbosity level
-
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 for which thetake_whilepredicate returned false after dropping theby_ref. -
field_types
Some derive macros for deriving enums, corresponding to the fields of structs
-
parse_cfg
Parse Rust’s
cfg(not(any(target)))attribute syntax -
commandspec
Rust macro to build std::process::Command objects with shell syntax. Uses macro_rules! and works on stable.
-
shrinkwraprs
Auto-derive for Rust conversion traits – make working with newtypes a breeze
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
lazy_format
A utility crate for lazily formatting values for later
-
snafu
An ergonomic error handling library
-
macro-attr
This crate provides the
macro_attr!macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derivecrate. -
join-lazy-fmt
Lazy
separator.join(iterable)method andlazy_format!for Rust -
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
structview_derive
Custom derive for structview’s View trait
-
iter-read
A Read implementation for iterators over u8 and related types
-
iter-comprehensions
A library for iterator comprehensions
-
cute
A macro for Python-esque comprehensions
-
newtype_array
A macro to help implementing the standard derived traits on newtype arrays
-
enum-iterator-derive
Procedural macro to iterate over the variants of a field-less enum
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
enum-iterator
Tools to iterate over the variants of a field-less enum
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
getters-by-type
Derive macro for adding a getter method for each type in the struct
-
copy_from_str
An extension trait to copy a string into another string
-
vectorize_struct
vectorize_struct adds an procedural macro attribute that makes it possible to iterate over Trait Objects of every field of a Struct that implements a specific trait
-
extension-trait
Macro to declare extension traits
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
enumset_derive
An internal helper crate for enumset
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
named-block
Macro implementing early-exit-from-any-block
-
phantom-enum
A simple macro library for creating phantom enums
-
proc-macro-rules
Emulate macro-rules pattern matching in procedural macros
-
tylift
Lift enum variants to the type-level
-
parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
macro_machine
State machine generator using macros
-
fragile
Provides wrapper types for sending non-send values to other threads
-
threadbound
Make any value Sync but only available on its original thread
-
cryo
Extend the lifetime of a reference. Safely.
-
const_fn
An attribute for easy generation of a const function with conditional compilations
-
mdo
Monadic do notation for rust using macro and duck typing
-
boolinator
Provides the Boolinator trait, which lets you use Option and Result-style combinators with bools
-
kinder
Kinder is a small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
float
Lightweight wrappers around primitive floating point types
-
unborrow
Macro for calling a &mut self method with transient &-borrows of self in the parameters
-
trace-error
Extensions to Rust’s error system to automatically include backtraces
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
shippai
failure in other languages
-
cfor
A macro that gives Rust a C-style for loop, with initialisation, condition and step. This correctly handles control-flow like continue and break.
-
error-type
Provides a macro for constructing unifying error types
-
enumflags2
Enum-based bit flags
-
tilde
Using ~ to provide syntax sugar for Rust
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
unchecked_unwrap
Adds an unchecked version of
unwrap()andexpect()to Option and Result -
init_with
Helper trait to initilize an array with a function
-
lazy-pool
Experimental lazy object pool
-
str-macro
The str!() macro, similar to vec![] but for strings
-
const-random
Provides compile time random number generation
-
iota-rs
A rust macro for other Go refuges who miss const blocks and iota
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
type-uuid
Safe, stable IDs for Rust types
-
function_group
A macro to hack in function overloading to rust
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
enumflags2_derive
Enum-based bitflags - the macros
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
concat-string
Provides macros for concatenating string slices into owned strings
-
boow
Borrow Or oWnedsmart pointer. Alternative to Cow. -
with-macro
Syntactic sugar for calling methods
-
tyname
Retrieve type names during program execution on stable Rust
-
vector2math
Traits for doing 2D vector geometry operations using standard types
-
iterator-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, FusedIterator, Extend)] for enums
-
derive-error
Derive macro for Error using macros 1.1
-
ngram
Iterator adaptors for n-grams and k-skip-n-grams
-
assert-impl
Macro for static assert types implement a trait or not
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
kwarg_macros
Keyword argument plugin
-
drop_bomb
A runtime guard for implementing linear types
-
pathsep
a small macro to enable easy path construction in other macro calls
-
mitochondria
Mitochondria is the powerhouse of the
Cell -
progress-streams
Progress callbacks for types which implement Read/Write
-
io-enum
#[derive(Read, BufRead, Write, Seek)] for enums
-
nes
New Error System for rust
-
bidir_iter
Bidirectional iterators
-
inner
The inner! macro descends into an enum variant. It’s more flexible than try!() and unwrap(), and it works with your enum, too!
-
pinpoint
Crate for pinned references
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
enum_traits_macros
Procedural macros that adds functionality to enums by deriving traits from the crate
enum_traits -
rev_slice
A newtype for operating on a reversed view of a slice
-
error-chain-mini
error-chain for minimalist
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
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.
-
cbox
C pointer boxing, for when working with ffi
-
str-concat
Concatenate two adjacent string slices
-
num_alias
simple macros to declare ‘type checked’ aliases for integers and floats
-
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
-
error-context
Methods and types that help with adding additional context information to error types
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
compile_msg
A plugin for emitting errors, warnings and notes to the developer at compile time
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
tilde_derive
Using ~ to provide syntax sugar for Rust
-
splop
Helper functions to determine the first/last repetition of something
-
aspect-weave
An Aspect Toolkit for Rust
-
mem_macros
align_of and size_of as a macro, to avoid turbofish notation
-
resize-slice
Shrink slice references
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
scoped
Run deferred closures at success, failure, or exit of a scope. Also supports cancelling them
-
sconcat
String concatenation
-
shawshank
An efficient, generic internment structure
-
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!, which does automatic currying
-
varianteq
Derive the equality of enum variants ignoring fields
-
split_by
Split anything implementing Read trait by multiple sequences of bytes
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
snaptest
Dead simple snapshot testing
-
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. You also have to make sure that the wrapper is dropped from within the original thread. If any of these constraints is violated, a panic occurs.
-
convute
Conversion between types with overlapping valid bit patterns and arrays, vecs and slices of those values
-
tyenum
Attribute macro for type enums
-
closure
A macro for capturing variables on a per variable basis
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
enumx_derive
Structural enum implemented in enum exchange
-
internship
Interned string and more
-
enum-kinds
Generate enums with matching variants but without any of the associated data
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
aspect
An Aspect Toolkit for Rust
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
cast_trait
cast trait
-
as_tuple
View any struct as a tuple! ✨
-
cex_derive
Combinators of EnumX, for error-handling
-
impl_ops
Macros for easy operator overloading
-
enum-methods
Generates methods for each enum variant