-
thiserror
derive(Error)
-
float-cmp
Floating point approximate comparison traits
-
synstructure
Helper methods and macros for custom derives
-
ordered-float
Wrappers for total ordering on floats
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
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… -
snafu
An ergonomic error handling library
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
indoc
Indented document literals
-
once_cell
Single assignment cells and lazy values
-
frunk
Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
pin-project
A crate for safe and ergonomic pin-projection
-
rental
A macro to generate safe self-referential structs, plus premade types for common use cases
-
annotate-snippets
Library for building code annotations
-
anyhow
Flexible concrete Error type built on std::error::Error
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
owning_ref
A library for creating references that carry their owner with them
-
enumflags2
Enum-based bit flags
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
geo-types
Geospatial primitive data types
-
derivative
A set of alternative
deriveattributes for Rust -
educe
This crate provides procedural macros to help you implement Rust-built-in traits quickly
-
quick-error
A macro which makes error types pleasant to write
-
typed-builder
Compile-time type-checked builder derive
-
err-derive
Derive macro for
std::error::Error -
lazycell
A library providing a lazily filled Cell struct
-
noisy_float
Contains floating point types that panic if they are set to an illegal value, such as NaN
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
auto_enums
A library for to allow multiple return types by automatically generated enum
-
approx
Approximate floating point equality comparisons and assertions
-
scroll_derive
A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
rust_info
Extracts the current rust compiler information
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
simple-error
A simple error type backed by a string
-
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…
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
pin-utils
Utilities for pinning
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
if_chain
Macro for writing nested
if letexpressions -
mode
A behavioral state machine library written in Rust
-
exitfailure
A basic newtype wrappers for use with ? in main
-
shrinkwraprs
Auto-derive for Rust conversion traits – make working with newtypes a breeze
-
buffered-reader
A super-powered Reader
-
safe-transmute
A safeguarded transmute() for Rust
-
semval
Semantic validation
-
conv
This crate provides a number of conversion traits with more specific semantics than those provided by ‘as’ or ‘From’/‘Into’
-
unchecked_unwrap
Adds an unchecked version of
unwrap()andexpect()to Option and Result -
palette_derive
Automatically implement traits from the palette crate
-
sugars
A collection of macros in Rust to make some tasks easier to use or less verbose
-
evcxr_repl
A REPL for Rust
-
tt-call
Token tree calling convention
-
autodiff
An automatic differentiation library
-
impls
Determine if a type implements a logical trait expression
-
displaydoc
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
chalk-macros
Macros for Chalk
-
enum-iterator
Tools to iterate over the variants of a field-less enum
-
problem
Error handling for command line applications or prototypes
-
cast
Ergonomic, checked cast functions for primitive types
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
cex
Combinators of EnumX, for error-handling
-
uninit
A collection of tools for a safer usage of uninitialized memory
-
take_mut
Take a T from a &mut T temporarily
-
structview
Viewing binary data as high-level data structures, safely
-
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
-
detach
helper type for being able to detach/reatach a member item
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
anomaly
Error context library with support for type-erased sources and backtraces
-
resiter
Helper crate for handling iterators over result
-
lazy-static-include
This crate provides
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
ambassador
Trait implementation delegation via procedural macros
-
iter-read
A Read implementation for iterators over u8 and related types
-
assert_matches
Asserts that a value matches a pattern
-
chainerror
Make chaining errors easy
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
enumx
Structural enum implemented in enum exchange
-
rusty-money
Money type for Rust
-
tokenlock
Send-able cell type whose contents can be accessed only via an inforgeable token
-
float-ord
A total ordering for floating-point numbers
-
illicit
An implicit thread-local environment which is indexed by type
-
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 -
enum_derive
This crate provides macros for deriving additional functionality for enums
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
require_unsafe_in_body
Make
unsafe fnstill requireunsafeblocks in the function’s body -
common_failures
Helpers for ‘failure’, including io::Error wrappers with paths, quick_main!, display_causes_and_backtrace
-
frunk_proc_macros
Proc macros for Frunk
-
quick-error2
A macro which makes error types pleasant to write
-
try_match
An expression macro that does pattern matching and returns the result in
Result -
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
yui_internal
Internal functions, struct for derive in Yui
-
derive-try-from-primitive
Custom derive a try_from method for primitive to enum conversions
-
fragile
Provides wrapper types for sending non-send values to other threads
-
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…
-
typename
Stable alternative to Rust’s type_name intrinsic
-
fstrings
Python3 fstring interpolation in Rust
-
extend
Create extensions for types you don’t own with extension traits but without the boilerplate
-
const-random
Provides compile time random number generation
-
ffi_helpers
A crate to help make working with FFI easier
-
v_escape_derive
Procedural macro package for v_escape
-
appro-eq
Approximately equal traits and assertion
-
intertrait
Allow for inter-trait casting
-
reduce
Fold an iterator without an initial value
-
lazy_format
A utility crate for lazily formatting values for later
-
unroll
An attribute-like procedural macro for unrolling for loops
-
thread-scoped-ref
A library that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
xladd-derive
A simple macro that helps write Excel UDF functions in Rust
-
reax
A reactivity system for Rust that infers dependencies between functions
-
direction
Representations of directions
-
tylift
Lift enum variants to the type-level
-
spez
Macro to specialize on the type of an expression
-
concat-with
Extend the function of the
concat!macro instd -
simple-logging
A simple logger for the log facade
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
aerosol
Dependency injection with compile-time guarantees
-
structural
Field accessor traits,and emulation of structural types
-
enum-kinds
Generate enums with matching variants but without any of the associated data
-
error-rules
Error handling without pain
-
static_assert_macro
Library implementation of so-called
static_assert -
enum-repr
Derive enum repr conversions compatible with type aliases
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
cargo-verify
Prettier error messages for the verified crate
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
result-like
Option/Result-like monad interface for your own enum
-
mox
Mockery Of X(ML): a JSX-alike syntax for the builder pattern
-
error_def
A Rust syntax extension for generating error-handling boilerplate code
-
rustils
Utilities for rust
-
closure
A macro for capturing variables on a per variable basis
-
tap
Generic extensions for tapping values in Rust
-
current
A library for setting current values for stack scope, such as application structure
-
easy-error
Simple error utilities
-
iter-progress
Calculate progress of your iterators
-
array-lit
Macros for array and
Vecliterals with superpowers -
ketos_derive
Derive traits for Ketos scripting language
-
throw
Efficiently add statically-calculated stack traces to errors
-
reexport-proc-macro
Re-export a procedural macro
-
edisp
Dispatch-on-collect for Rust enums
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
retain_mut
Provide retain_mut method that has the same functionality as retain but gives mutable borrow to the predicate
-
progress-streams
Progress callbacks for types which implement Read/Write
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
stdext
Extensions for the Rust standard library structures
-
str-macro
The str!() macro, similar to vec![] but for strings
-
high_mem_utils
This crate provides a bunch of mem safe abstractions,some involving transmute
-
unique-type-id-derive
A unique id proc-macro generator for types
-
woe
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
rsb_derive
An opinionated macros implementation for Rust struct builder pattern
-
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
-
ref-portals
Safely use (stack) references outside their original scope
-
bool_ext
A crate which defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
py-comp
A macro implementing a Python-like generator expression
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
into-owned
Provides a trait for associating a type with its owned variant
-
ndless-static-vars
Rust library for storing static, program-wide parameters for Ndless
-
iterslide
A “sliding window” iterator
-
funty
Trait generalization over the primitive types
-
moveslice
A one-function crate to move chunks in a slice around
-
opaque_typedef_macros
Supports defining opaque typedefs
-
tupletools
Utility functions for tuples
-
mac
A collection of great and ubiqutitous macros
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
const_fn_assert
Assertions for const functions
-
try_from
TryFrom and TryInto traits for failable conversions that return a Result
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
lang_extension
Rust Lang Extension
-
eventmill_derive
Derive macros for convient implementation of some traits of the
eventmillcrate -
newtype-enum
Traits to convert between enums and their variant types
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
bitwrap_derive
derive for bitwrap
-
cute
A macro for Python-esque comprehensions
-
eventually
Crate for using Event Sourcing in Rust applications
-
mapcomp
Python-like list comprehensions for standard containers
-
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… -
grouping_by
A simple library which allows the user to group an iterator by various ways
-
bidir_iter
Bidirectional iterators
-
format
A utility crate to make it easier to work with the formatter
-
ngram
Iterator adaptors for n-grams and k-skip-n-grams
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
morphism
A structure for suspended closure composition in Rust
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
filters
Build filters/predicates with the builder pattern
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
status
Error container
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
failsafe
A circuit breaker implementation
-
tapir
Adding tapping functionality to rust
-
summon
A logic engine designed to magically give you what you ask for
-
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
-
fool
Traits for interoperation of Boolean and sum types
-
type-uuid
Safe, stable IDs for Rust types
-
quixutils
Common helpers and utils
-
miniserde-enum
Derive macros for miniserde on enums
-
by_address
Wrapper for comparing and hashing pointers by address
-
arraygen
Derive macro for generating arrays from struct fields
-
inner
The inner! macro descends into an enum variant. It’s more flexible than try!() and unwrap(), and it works with your enum, too!
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
read-restrict
Restrict the number of bytes read from a reader
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
named-block
Macro implementing early-exit-from-any-block
-
enum_set2
A bit-set indexed by enum variants
-
structview_derive
Custom derive for structview’s View trait
-
mitochondria
Mitochondria is the powerhouse of the
Cell -
fn_chain
Helper macro/function to create function chaining
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
lambda_runtime_errors_derive
Rust runtime errors derive for AWS Lambda
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
whiteout
Provides macros that erase the type of any value into an impl Trait for a given trait
-
incomplete
Provides incomplete!(), a compile-time checked version of unimplemented!()
-
failchain
Ergonomic companion library for failure
-
frunk_laws
frunk_laws contains laws for algebras declared in Frunk
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
enumflags
Bitflags
-
defmac
A macro to define lambda-like macros inline
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
into-result
A simple convenience trait for converting something into a
ResultorOption -
is-same
A trait for comparing object equality
-
try_clone_derive
a crate wich add a derive TryClone macro for the TryClone Trait of the fallible_allocation crate
-
k8-client
Core Kubernetes metadata traits
-
kinder
Kinder is a small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
gen-iter
temporary util for creating iterators using generators
-
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…
-
downcast
Trait for downcasting trait objects back to their original types
-
as-result
Traits for converting types which may be interpreted as or into a result
-
concat_strs
Macro for quickly building a String from components
-
frunk_proc_macro_helpers
Common internal functions for frunk’s proc macros
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
cenum-derive
A rust derive macro for C-style primitive enums
-
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
never
A stable version of the unstable never type (!)
-
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
init_with
Helper trait to initilize an array with a function
-
iter-comprehensions
A library for iterator comprehensions
-
kaguya_rs
Functional Programming tools and ADTs
-
butcher
An easy way to interact with structs and enums wrapped in Cows
-
take-if
A tiny utility for conditionally taking the contents of an option
-
enum_variant_type
Generates types for each enum variant and conversion trait impls
-
predicates-core
An API for boolean-valued predicate functions
-
file
For Rust 1.25 and older. 1-liner convenience functions for reading and writing files
-
ffishim_derive
Procedural macros for generating ffi-compatible stubs
-
rjdebounce
Debouncing function utility
-
newtype_array
A macro to help implementing the standard derived traits on newtype arrays
-
impl_ops
Macros for easy operator overloading
-
cell-project
Safe interface for cell projection
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
extension-trait
Macro to declare extension traits
-
coercible_errors
Zero-cost error handling for generic traits
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
join_to_string
Join a list of items to string/buffer
-
aspect
An Aspect Toolkit for Rust
-
shaku_derive
Code generation for the shaku dependency injection framework
-
sum_error
Derive macros for fast summing of error types into error enum
-
enum_properties
A macro for declaring static properties on enum variants
-
parse-display-derive
Procedural macro to implement Display and FromStr using common settings
-
ambience
Lightweight library for passing ambient parameters
-
single
Provides the Single trait for extracting the element from a single-element iterator
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
gaclen_shader
Tweaked re-export of vulkano_shader! procedural macro
-
assert_that
Helper macros for use with boolean-valued predicate functions
-
trace-error
Extensions to Rust’s error system to automatically include backtraces
-
anysafe
any safe
-
tuple_list
Crate for macro-free variadic tuple metaprogramming
-
partial-application-rs
A macro to transform functions into partially applicable structs
-
precog_iter
An iterator adapter that returns the equivalent of
(iter.next(), iter.peek()) -
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
multi-eq
Macros for creating custom equality trait derives
-
failure_without_backtrace
Experimental error handling abstraction
-
event_feed
Event systems implemented using event feeds
-
eieio
Error Implementing
Eq + Clonereplacingstd::io::Error -
const-if
This crate adds if-else expression into your constant functions
-
range-split
Utilities for splitting sequences with range parameters
-
chained_iter
Provides a small helper macro for creating iterators out of values without allocation
-
nshare
Conversion between n-dimensional types in different Rust crates
-
as-any
provide the AsAny trait
-
macro_macro
Macro templating library for DRYer structs
-
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
-
typic
Type-safe transmutations between layout-compatible types
-
hash-db
Trait for hash-keyed databases
-
auto_ops
Macros for easy operator overloading
-
di
Dependency injection container
-
yolo-block
Like a
tryblock, but automatically unwraps the result -
stackpin
Crate for data that should be pinned to the stack at the point of declaration
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
error-chain-mini
error-chain for minimalist
-
abi_stable_derive
Implementation detail of abi_stable
-
mods
Simpler module declaration
-
into_inner_drop
A helper library for implementing into_inner method for drop types safely
-
concat-string
Provides macros for concatenating string slices into owned strings
-
hypospray
Lightweight dependency injection library
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
overload
Provides a macro to simplify operator overloading
-
overloadf_derive
unlock function overloading for rust
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
curry-macro
Have fun currying using Rust’s native closure syntax
-
rusty_v8_helper_derive
A rust derive macro for rusty_v8_helper
-
derive-error
Derive macro for Error using macros 1.1
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
boow
Borrow Or oWnedsmart pointer. Alternative to Cow. -
dispose
A simple wrapper for values that must be consumed on drop
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
snaptest
Dead simple snapshot testing
-
delegatemethod
Delegate method calls to a field
-
ufcs
Helper trait to call free functions using method call syntax
-
drop_bomb
A runtime guard for implementing linear types
-
fmt_adapter
Provides newtype adaptors to and from any formatting trait
-
mcurry
Macros for creating curried functions
-
tiny_fail
Provides simple Fail type
-
enum-methods
Generates methods for each enum variant
-
compile_msg
A plugin for emitting errors, warnings and notes to the developer at compile time
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
validated-slice
Helper macros to implement std traits for custom validated slice types
-
splop
Helper functions to determine the first/last repetition of something
-
tyenum
Attribute macro for type enums
-
hexfloat
Syntax extension to create floating point literals from hexadecimal strings
-
deep_safe_drop
Safe dropping of deep trees that otherwise could cause stack overflow
-
round
This crate provides utilities to round your floats with precision from 1 to 10
-
boolenum
Derive From and Into for your boolean enums
-
read-byte-slice
An iterator over chunks of bytes as slices from an underlying reader
-
enum-iterator-derive
Procedural macro to iterate over the variants of a field-less enum
-
tyname
Retrieve type names during program execution on stable Rust
-
slugify
Macro for flexible slug generation
-
macro_lisp
Lisp-like DSL for Rust language
-
nes
New Error System for rust
-
arc-io-error
A version of std::io::Error implemented on top of Arc instead of Box, making it cloneable
-
tuple-conv
Allows converting tuples of one element to vectors
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
sugar
Rust syntax sugar collections
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
split_by
Split anything implementing Read trait by multiple sequences of bytes
-
dsl_macros
Convenience macros that rewrites method calls inside a builder closure
-
geo-postgis
Conversion between
geo-typesandpostgistypes -
tuple-map
map methods for tuple
-
pluralize
A generic trait across single and multiple elements
-
dync-derive
Attribute macros for producing
dynccompatible traits -
cbox
C pointer boxing, for when working with ffi
-
indoc-impl
Indented document literals
-
map_for
A Rust macro that implements for comprehensions similar to Scala’s
-
eliza_error
“Times are bad. Children no longer obey their parents, and everyone is writing an error handling library.” — Cicero
-
iter_vals
On the fly iterator creation
-
random-number-macro-impl
Generate random numbers quickly
-
cutlass
Macro based library to take the boilerplate out of configuration handling
-
size_hint
A very simple library to provide a size_hint for an iterator which does not provide it’s own
-
float
Lightweight wrappers around primitive floating point types
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
pipe_macro
A macro to pipe function calls like in functional programming languages
-
throws
A macro for easy creation per-function errors
-
interleave
An arbitrary iterator interleaver for exhaustive consumption of iterators. Each iterator is guaranteed to be no more than a single next call behind any other iterator.
-
errors_rust
Just a simple library for error mapping
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
track-macro
A macro to track data changes
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
specialize
Type specialization macros and helpers
-
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:…
-
as-dyn-trait
An attribute macro that generates methods for retrieving supertraits from trait-objects (upcasting)
-
rhs_first_assign
An attribute macro to hack compound assignment
-
primitive-from
Provides a trait PrimitiveFrom that is what From is to Into for num_traits::AsPrimitive
-
list_builder
Python-like list comprehensions in Rust
-
market
Infrastructure built around producers and consumers
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
clone_all
clone_all!(my,variables,with,long,names);
-
newtype_derive
This crate provides macros for deriving common traits for newtype structures
-
to_vec
convenient to_vec, to_set and to_map methods on iterators
-
io-error
Simple and convenient macro for creating I/O errors
-
pinpoint
Crate for pinned references
-
bounded
Bounded numeric types
-
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
dont_panic
panic!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won’t panic.
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
pretty-sure
Like
.unwrap()or.or_else()for arbitrary patterns -
optfield
A macro that generates structs with optional fields
-
take-cell-option
Utility for taking the value from a cell of a option without cloning
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
sorted
Provides compile time guarantees for sorted sequences
-
eager
Crate for eager macro expansion
-
jane-eyre
By Currer Bell
-
validator_derive
Macros 1.1 implementation of #[derive(Validate)]
-
match-downcast
A set of downcasting matching Rust macros
-
rev_slice
A newtype for operating on a reversed view of a slice
-
blunder
Dumb crate to make error handling easy
-
underscore_args
Macro for underscore named argument syntax, aka Dyon
-
conditional
Provides a conditional! macro which lets you use the syntax of the conditional operator (also known as the ternary operator) in Rust
-
fast_new_type
A proc_macro attribute to implement common traits for a custom type wrapping other
-
ama
Quasi-quotation system for designing procedural macros mixed with Rust code
-
geopattern
Beautiful generative geometric background images from a string, a Rust implementation of geo_pattern from @jasonlong
-
bitwise_reduce
Multiple arity bitwise functions
-
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
builder_macro
A macro to generate structs and a corresponding builder
-
outcome
A Success/Failure type for rust
-
assert-impl
Macro for static assert types implement a trait or not
-
yade
Yet Another Derive Error
-
traitcast_core
Cast between dynamic trait objects
-
unify
Trait-based equality constraint for Rust
-
errer
Flexible error management for Rust. An middle-ground between failure and SNAFU
-
disjoint-borrow
Disjoint mutable borrows of slices
-
checked_ops
Automatic checked arithmetic operations in Rust
-
num_alias
simple macros to declare ‘type checked’ aliases for integers and floats
-
pub-iterator-type
Abstract an iterator implementation behind a struct tuple
-
enum_index
Trait and macros for extracting Enum variant index
-
peek-nth
An iterator adapter that allows you to efficiently peek the nth item of an iterator
-
tagged_ptr
A safe tagged union pointer datastructure for x64
-
threadbound
Make any value Sync but only available on its original thread
-
cenum
A rust derive macro for C-style primitive enums
-
zkp-macros-lib
Library of procedural macros implemented using
proc_macro2 -
dto_derive
Derive for automatic mapping DTOs to Entities and vice versa
-
funfun
Macros for working with closures
-
beau_collector
Collect up all errors into a single error
-
try_into_opt
A macro like try!, but turns a Result into an Option, mainly for use in a filter_map
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
enum_dispatch
Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed
-
compiler_error
Triggerable compiler error
-
anon
Anonymous struct macro
-
transaction
transaction abstraction library (a.k.a. transaction monad)
-
bitpat
Bit-level matching against values
-
subset
Various subsets of slice’s items that are able to iterate over references to selected items
-
derive_deref
Adds
#[derive(Deref)]and#[derive(DerefMut)] -
tearor
Easily turn data races into data corruption!
-
koute/nes
An NES emulator written in Rust
-
powerset-enum
A poor man’s anonymous enum
-
enum_variants
Deriving traits for C-like enums using macro 1.1
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
altbitflags
Macros to implement a struct which behave similar to bitflags
-
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
abscissa_generator
Template-based generator for creating new Abscissa applications
-
wrap
Generic function wrapping
-
zkp-error-utils
Assertion like macros for returning
Result::Err -
error-chain
Yet another error boilerplate library
-
clone-into-box
A library for cloning trait objects
-
splits_iter
Iterator over all 2-splits
-
error-type
Provides a macro for constructing unifying error types
-
error-context
Methods and types that help with adding additional context information to error types
-
taken
Macros for taking ownership, staring Liam Neeson
-
sconcat
String concatenation
-
d2_iterators_smc
Demo : Dummy upload for checking
-
bidule
Ultra simple Functional Reactive Programming, made with stuff, things, device, thingumajig, etc
-
scoped
Run deferred closures at success, failure, or exit of a scope. Also supports cancelling them
-
tilde
Using ~ to provide syntax sugar for Rust
-
wrapped-vec
Macro for generating wrapped Vec types and associated boilerplate
-
almost
A crate for comparing floating point numbers
-
enum_macro
Useful macro for enum
-
breaktarget
Implementation of nonlocal breaks in Rust
-
gtmpl_derive
Derive for gtmpl_value
-
either_n
An Either enum with N variants
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
error_derive
Macros for deriving Error implementations through custom_derive!
-
enum_from_str
Enable deriving FromStr for enums
-
overflow-error
Common overflow error types
-
iter_from_closure
Iterator<Item = Item> from FnMut() -> Option
-
errloc_macros
Error location utility macros
-
iflet
Provides a macro to chain multiple patterns in an
if letrather than nesting them -
type_eq
Tiny utils for type-level constraints and inference
-
hex-literal
Procedural macro for converting hexadecimal string to byte array at compile time
-
dedup_iter
Deduplicating iterator adapters
-
take-until
A take until extension for iterators
-
limit_read
A companion to std::io::Take and an extension to std::io::BufRead to put a cap on methods that could potentionally read infinitely
-
function_group
A macro to hack in function overloading to rust
-
internship
Interned string and more
-
aspect-weave
An Aspect Toolkit for Rust
-
err_prop
Super simple ( and stupid ) floating point error propagation calculating type
-
rust-fsm-dsl
Macros for rust-fsm DSL
-
lfa_derive
Macros for LFA
-
he_di_internals
Common code for he_di crates
-
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
-
eraserhead
erase the lifetimes from types
-
capture
A macro for adding explicit capture clauses to a (closure-) expression
-
maybe-owned
provides a
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
lift-fail
A library to handle
failurein an iterable collection -
amplify_derive
Amplifying Rust language capabilities: derive macros for the ‘amplify’ library
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
slice-copy
Go style copying for slices
-
rustup-find
Use rustup to automatically find and/or install the latest Rust version that supports all the currently installed components
-
build_epoch
Macro for calculating the epoch at compile time
-
enum_extract
Helper macros for extracting single enum variants of an enum
-
convute
Conversion between types with overlapping valid bit patterns and arrays, vecs and slices of those values
-
adjacent-pair-iterator
An iterator over adjacent pairs in another iterator
-
ref-map
Helper trait for Option and Result to map references
-
hash-of
A typesafe wrapper for hashes
-
verified
A library of types to facilitate the development of verifiable rust
-
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.
-
extdot-impl
Please see
extdotcrate for actual usage -
dioptre-derive
Custom derive macro for #[derive(Fields)]
-
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
-
lazy-init
Lazy initialization
-
seek-ext
Extension trait to add convenience methods to
io::Seektypes -
option-filter
Option::filter polyfill for Rust 1.26 and older
-
dioptre
Struct field projection tools
-
progressive
A rust library for showing progress of iterators and loops
-
mox-impl
Implementation for the mox! macro
-
hmap
Adds hmap! macro for easily generate HashMap
-
zkp-criterion-utils
Criterion helpers to benchmark over size and number of processors
-
iter-python
Python generator expressions and ‘list’ comprehensions
-
traitlit
This crate exposes an atribute for implementing traits for integer and float types
-
enumx_derive
Structural enum implemented in enum exchange
-
copy_from_str
An extension trait to copy a string into another string
-
boxing-day
Unwrap a Box in festive fashion, only on boxing day!
-
derivate
A set of alternative
deriveattributes for Rust -
typed-generational-arena
A safe arena allocator that supports deletion without suffering from the ABA problem by using generational indices. Now with typed indices and custom integer types for generations!
-
unborrow
Macro for calling a &mut self method with transient &-borrows of self in the parameters
-
split_preserve
An iterator that splits on whitespace but doesn’t throw it away
-
once
This crate provides an assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
unwrap_return
A set of macros for returns and breaks in the None and Err cases
-
withers_derive
A macro to implement wither methods for properties of a struct
-
transaction-stm
transaction abstraction of stm
-
shippai
failure in other languages
-
trait_enum_macro
A macro that allows creating an enum that acts similar to a trait object, but without using the heap
-
riker-patterns
A collection of common actor patterns for Riker
-
char-iter
A performant iterator over a linear range of characters (
chars), correctly handling the surrogate range -
exclusive
Place code into an exclusive context that won’t collide with another context
-
try_enum
match enum
-
transfer
Crate that exposes a Transfer trait, that is to move what Clone is to copy
-
zkp-mmap-vec
Replacement for
Vecthat uses file-backed storage -
ps
A safe wrapper around
std::mem::transmute -
effect-monad
A native-rust implementation of an Effect monad, inspired by PureScript’s EFF Monad
-
named_return
Derives a wrapper function which insert the named return variables
-
cex_derive
Combinators of EnumX, for error-handling
-
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
clierr
Non-panicking error handling for small CLI scripts
-
hado
Monadic do notation using a macro
-
varianteq
Derive the equality of enum variants ignoring fields
-
loosen
Derives a wrapper function which loosen the arguments into a tuple
-
dynamic
A dyanmically typed value with fast downcasting
-
duck
Like
Iterator::peekable, but can be stacked an arbitrary number of times -
field_types
Some derive macros for deriving enums, corresponding to the fields of structs
-
fehler
A library for error-handling syntax in Rust
-
any-error
When you just want to use
?in peace -
enum-error-derive
Derive Error traits
-
static-events
A library for creating zero-cost event systems
-
byteorder-pod
Endian-backed storage and memory mapping types
-
scrapmetal
Scrap Your Rust Boilerplate
-
slice-cast
Support for casting between slice types
-
unhygienic
A library for stripping the hygiene out of macro parameters
-
enum-unitary
Trait and macro for unitary enums
-
efficient_enum
Space-efficient enum values
-
default-env
The
env!macro but with a default value -
monad
Stackless monads in Rust
-
enum_traits_macros
Procedural macros that adds functionality to enums by deriving traits from the crate
enum_traits -
flt2dec2flt
Low-level functions to convert floating point numbers to strings and vice versa
-
boxfnonce
safe FnOnce boxing for rust stable
-
unzip-n
Procedural macro to generate
unzipfor iterators over n-sized tuples -
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
-
tramp
Trampoline for recursive functions, with support for mutual recursion
-
easy_adds
A package to make rust simple for starters
-
ref_eq
Determine if two borrowed pointers point to the same thing
-
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…
-
smart-default
Rust custom-derive macro for Default with more control on the fields
-
rbtag_derive
A procedural macro impl to add git and build datetime info
-
uwuizer
Rust Macro to UwUize your text. UwU.
-
chalk-derive
A helper crate for use by chalk crates for
derivemacros -
trackable_derive
Custom derive for
trackablecrate -
rusted
Simple tool to highlight rustc –explain output
-
hdf5-derive
Derive macro for HDF5 structs and enums
-
dispose-derive
Derive macro for the dispose crate
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
typebool
Type-level booleans meant for compile-time hackery
-
nan-preserving-float
(Mostly) drop-in replacement for floats that preserves the signalling bit in NaNs under conversions and unary operations
-
value
Type-level constants for generic contexts
-
also
A collection of Kotlin-esque blanket impl helper functions, enabling easier function chaining patterns
-
enumiter
An iterator through the variants in an enum
-
displaydoc-watt
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
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.
-
tynm
Returns type names in shorter form
-
include-flate
A variant of include_bytes!/include_str! with compile-time deflation and runtime lazy inflation
-
zkp-macros-impl
Implementation crate for
proc_macro_hack -
envsubst
Variables substitution
-
format-core
Core format types
-
abi_stable_derive_lib
Implementation detail of abi_stable
-
proc-macro-error-attr
Attribute macro for proc-macro-error crate
-
lain_derive
Derive macros for usage with lain
-
bit_manager_derive
Derive macro for bit_manager crate
-
pure_decimal
A decimal type with no NaN and Infinity
-
rlua-table-derive
This crate provides a procedural macro to turn lua tables into rust types via rlua
-
enumer_derive
enum helper
-
stringlit
A macro to convert from str to String
-
either_trait_macro
An attribute-like macro to implement traits for Either
-
env_proc
env vars
-
invariant
A library for creating wrapper types that enforce invariants
-
arsert_failure
Traits used by the
arsertcrate -
pl-hlist-derive
Provides the HListSupport derive macro used in conjuction with the
pl-hlistcrate -
interpolate_idents
Useable macro identifier concatenation plugin
-
machine
State machine utilities
-
pathsep
a small macro to enable easy path construction in other macro calls
-
derive-new
#[derive(new)]implements simple constructor functions for structs and enums -
err-context
Lightweight context layers for stdandard library errors
-
overloadable
Overloadable functions done easy in rust
-
type-level-logic
Primitive types and operations for type-level logic
-
w_result
A result type that carries warnings
-
identity
A stable Rust implementation of an identity (a.k.a., “equality witness”) type
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
rvs_derive
A helper macros implementation for Value Classes in Rust
-
tense
n-rank tensor calculus
-
gpg-error
Libgpg-error bindings for Rust
-
xkcd_unreachable
A Rust macro xkcd_unreachable!() inspired by https://xkcd.com/2200/
-
resultit
Iterator adapters for iterators over results
-
reflike
Meta-traits for reference look-alikes
-
same
Traits for testing identity of objects
-
blair_mountain
Union types in release mode with debug assertions in debug mode
-
asserter-macros
New assertion library for rust
-
rust-enum-derive
A simple library (and program) for generating rust enums and associated traits from text files
-
forever
-
autoimpl-derive
The proc-macro part of the autoimpl macro. Should not be depended on directly.
-
never-type
This library is an alternative implementation of never type for stable rust
-
fn_ops
Temporary traits for function operator overloading, pending the stabilization of
Fn,FnMut, andFnOnce -
yui
An attribute reader generator for Rust
-
structural_derive
Implementation detail of the structural crate
-
comprehension
Iterator comprehension in Rust
-
conform
Macro to transform struct string fields in place
-
plain_enum
Mimicing Java’s enum::values() and EnumMap
-
error-chain-mini-derive
derives for error-chain-mini
-
control-flow
A hack to control control-flow outside closures
-
join-lazy-fmt
Lazy
separator.join(iterable)method andlazy_format!for Rust -
mopa
My Own Personal Any: get your own Any with additional functionality
-
he_di
Dependency Inversion / Dependency Injection / Inversion of control container for Rust
-
arraygen-docfix
Derive macro for generating arrays from struct fields
-
enumflags_derive
Bitflags
-
karabiner-thunk
lazy evaluation for rust
-
enum_str
Creates a unitary enum and conversions from enum variants to string and vice versa
-
accel-derive
Procedual macro for writing GPGPU kernel
-
tyenum_attribute
Attribute macro for type enums
-
transaction-diesel
transaction abstraction of diesel
-
variant_count
Derive macro for enum which adds to it the count of variants
-
enum_like
A trait to treat any type as an enum. If a type has a reasonably small number of variants, for example a
struct A(bool, bool)which has 4 variants, this trait provides a 1-to-1 mapping from type value to a… -
soa_derive
Automatic Struct of Array generation
-
gumdrop
Option parser with custom derive support
-
num_enum_derive
Internal implementation details for ::num_enum (Procedural macros to make inter-operation between primitives and enums easier)
-
vptr-macros
Procedural macros for the
vptrcrate -
define_error
A library for easily defining an error type
-
kwarg_macros
Keyword argument plugin
-
serde-enum-derive
Serde enum primitive derive
-
dmutil
A collection of utility macros to ease the creation of other macros
-
human-panic
Panic messages for humans
-
const_fn
An attribute for easy generation of a const function with conditional compilations
-
throttled-reader
An io::Read proxy that limits calls to read()
-
safe-builder-derive
Derive a safe builder pattern
-
fma
Tiny crate to use FMA(Fused Multiply-Add) instruction easily
-
arrayref
Macros to take array references of slices
-
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…
-
bijection
A library for producing bijective functions in Rust
-
newtype-enum-macro
Procedural macro to generate newtype enums
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
exact-float
Do your calculations with exact floating point numbers
-
assert_approx_eq
assert approximately equal
-
getters-by-type
Derive macro for adding a getter method for each type in the struct
-
typed_index_derive
Custom derive to easily create newtype index types
-
int-enum
A procedural macro for conversion between integer and enum types
-
as_tuple_derive
Don’t use this crate directly. It’s re-exported by as_tuple!
-
coalesce
Combine disjoint types that share common traits
-
with-macro
Syntactic sugar for calling methods
-
derive_setters
Rust macro to automatically generates setter methods for a struct’s fields
-
handle-error
An error handling helper macro to avoid the constant if let Err(e) pattern
-
enum_to_u8_slice_derive
A simple fork of enum_to_str_derive (by @DCjanus), convert enum to u8 slice ref
-
build_timestamp
Simple proc-macro to generate a build timestamp string as a const
-
scoped-callback
Register scoped functions with local references to ’static lifetime callbacks in a safe manner
-
mem_macros
align_of and size_of as a macro, to avoid turbofish notation
-
inherent-pub
Mark methods in
impl Trait for Typeblocks inherent to the type -
enum_primitive
Macro to generate num::FromPrimitive instances for enum that works in Rust 1.0
-
libgpg-error-sys
Raw bindings for libgpg-error
-
frunk_proc_macros_impl
Proc macros inernal implementations for Frunk
-
enum_index_derive
Macros for extracting Enum variant index
-
function_name-proc-macro
macro that expands to the name of the annotated function
-
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
c2rust-bitfields-derive
C-compatible struct bitfield derive implementation used in the C2Rust project
-
primitive_enum
Little utility for dealing with enums no extra data in variants
-
xplane_plugin
Provides types and a macro for creating X-Plane plugins
-
iterr
Combinators for dealing with iterators of
Results -
erroneous
Minimalistic helper for using errors
-
ccl_owning_ref
A library for creating references that carry their owner with them
-
tuple-transpose
Transpose tuple of results and options to result and option of tuple
-
flow_impl
Definition of an Implementation trait for flow functions, and a derive macro
-
idata
Small tools to reduce mutability
-
scopefunc
A trait defining kotlin-like scope functions
-
as_derive_utils
private derive utilities used by abi_stable and structural
-
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
u9
Unsigned 9-bit integer type
-
lazy_mut
This crate provides a structure that can be used to lazily initialized values as well as a macro for creating lazy variables
-
or-iterator
Rust iterator which takes two iterators and returns non-empty one
-
iroha-internal
Internal functions, struct for Iroha
-
zkp-macros-decl
Procedural macros
-
apply_pub
A Rust syntax extension for applying the
pubvisibility modifer to many items at once -
static-cond
Macro for performing comparisons during macro expansion
-
indenter
A formatter wrapper that indents the text, designed for error display impls
-
verify_macro
An attribute that automatically instruments code with logical type bounds