-
failure
Experimental error handling abstraction
-
quick-error
A macro which makes error types pleasant to write
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
synstructure
Helper methods and macros for custom derives
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
anyhow
Flexible concrete Error type built on std::error::Error
-
snafu
An ergonomic error handling library
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
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… -
ordered-float
Wrappers for total ordering on floats
-
once_cell
Single assignment cells and lazy values
-
derivative
A set of alternative
deriveattributes for Rust -
rental
A macro to generate safe self-referential structs, plus premade types for common use cases
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
float-cmp
Floating point approximate comparison traits
-
indoc
Indented document literals
-
frunk
Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
pin-project
A crate for safe and ergonomic pin-projection
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
err-derive
Derive macro for
std::error::Error -
geo-types
Geospatial primitive data types
-
lazycell
A library providing a lazily filled Cell struct
-
thiserror
derive(Error)
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
annotate-snippets
Library for building code annotations
-
cast
Ergonomic, checked cast functions for primitive types
-
error-chain
Yet another error boilerplate library
-
approx
Approximate floating point equality comparisons and assertions
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
enumflags2
Enum-based bit flags
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
lazy-static-include
This crate provides
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
try_from
TryFrom and TryInto traits for failable conversions that return a Result
-
shrinkwraprs
Auto-derive for Rust conversion traits – make working with newtypes a breeze
-
noisy_float
Contains floating point types that panic if they are set to an illegal value, such as NaN
-
auto_enums
A library for to allow multiple return types by automatically generated enum
-
simple-error
A simple error type backed by a string
-
chainerror
Make chaining errors easy
-
eyre
Flexible concrete Error Handling and Reporting type built on std::error::Error
-
fragile
Provides wrapper types for sending non-send values to other threads
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
typed-builder
Compile-time type-checked builder derive
-
if_chain
Macro for writing nested
if letexpressions -
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
-
palette_derive
Automatically implement traits from the palette crate
-
mode
A behavioral state machine library written in Rust
-
rust_info
Extracts the current rust compiler information
-
problem
Error handling for command line applications or prototypes
-
buffered-reader
A super-powered Reader
-
tt-call
Token tree calling convention
-
scroll_derive
A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate
-
sugars
A collection of macros in Rust to make some tasks easier to use or less verbose
-
typename
Stable alternative to Rust’s type_name intrinsic
-
take_mut
Take a T from a &mut T temporarily
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
evcxr_repl
A REPL for Rust
-
impls
Determine if a type implements a logical trait expression
-
semval
Semantic validation
-
detach
helper type for being able to detach/reatach a member item
-
assert_matches
Asserts that a value matches a pattern
-
uninit
A collection of tools for a safer usage of uninitialized memory
-
resiter
Helper crate for handling iterators over result
-
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
-
enum-iterator
Tools to iterate over the variants of a field-less enum
-
structview
Viewing binary data as high-level data structures, safely
-
educe
This crate provides procedural macros to help you implement Rust-built-in traits quickly
-
quick-error2
A macro which makes error types pleasant to write
-
autodiff
An automatic differentiation library
-
owning_ref
A library for creating references that carry their owner with them
-
ffi_helpers
A crate to help make working with FFI easier
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
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 -
v_escape_derive
Procedural macro package for v_escape
-
anomaly
Error context library with support for type-erased sources and backtraces
-
float-ord
A total ordering for floating-point numbers
-
enum_derive
This crate provides macros for deriving additional functionality for enums
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
rusty-money
Money type for Rust
-
frunk_proc_macros
Proc macros for Frunk
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
safe-transmute
A safeguarded transmute() for Rust
-
direction
Representations of directions
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
displaydoc
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
lazy_format
A utility crate for lazily formatting values for later
-
derive-try-from-primitive
Custom derive a try_from method for primitive to enum conversions
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
const-random
Provides compile time random number generation
-
ambassador
Trait implementation delegation via procedural macros
-
spez
Macro to specialize on the type of an expression
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
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
-
downcast
Trait for downcasting trait objects back to their original types
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
error-rules
Error handling without pain
-
tylift
Lift enum variants to the type-level
-
reexport-proc-macro
Re-export a procedural macro
-
throw
Efficiently add statically-calculated stack traces to errors
-
progress-streams
Progress callbacks for types which implement Read/Write
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
error_def
A Rust syntax extension for generating error-handling boilerplate code
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
simple-logging
A simple logger for the log facade
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
structural
Field accessor traits,and emulation of structural types
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
ketos_derive
Derive traits for Ketos scripting language
-
str-macro
The str!() macro, similar to vec![] but for strings
-
current
A library for setting current values for stack scope, such as application structure
-
easy-error
Simple error utilities
-
iterslide
A “sliding window” iterator
-
mac
A collection of great and ubiqutitous macros
-
rustils
Utilities for rust
-
iter-progress
Calculate progress of your iterators
-
py-comp
A macro implementing a Python-like generator expression
-
moveslice
A one-function crate to move chunks in a slice around
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
arraygen
Derive macro for generating arrays from struct fields
-
opaque_typedef_macros
Supports defining opaque typedefs
-
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
try_match
An expression macro that does pattern matching and returns the result in
Result -
morphism
A structure for suspended closure composition in Rust
-
closure
A macro for capturing variables on a per variable basis
-
require_unsafe_in_body
Make
unsafe fnstill requireunsafeblocks in the function’s body -
frunk_laws
frunk_laws contains laws for algebras declared in Frunk
-
derive-error
Derive macro for Error using macros 1.1
-
file
For Rust 1.25 and older. 1-liner convenience functions for reading and writing files
-
lang_extension
Rust Lang Extension
-
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
-
by_address
Wrapper for comparing and hashing pointers by address
-
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
iter-read
A Read implementation for iterators over u8 and related types
-
coercible_errors
Zero-cost error handling for generic traits
-
funty
Trait generalization over the primitive types
-
retain_mut
Provide retain_mut method that has the same functionality as retain but gives mutable borrow to the predicate
-
extend
Create extensions for types you don’t own with extension traits but without the boilerplate
-
const_fn_assert
Assertions for const functions
-
intertrait
Allow for inter-trait casting
-
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
-
cex
Combinators of EnumX, for error-handling
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
reax
A reactivity system for Rust that infers dependencies between functions
-
xladd-derive
A simple macro that helps write Excel UDF functions in Rust
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
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
-
ndless-static-vars
Rust library for storing static, program-wide parameters for Ndless
-
ngram
Iterator adaptors for n-grams and k-skip-n-grams
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
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…
-
typic
Type-safe transmutations between layout-compatible types
-
whiteout
Provides macros that erase the type of any value into an impl Trait for a given trait
-
quixutils
Common helpers and utils
-
bidir_iter
Bidirectional iterators
-
fstrings
Python3 fstring interpolation in Rust
-
cute
A macro for Python-esque comprehensions
-
mapcomp
Python-like list comprehensions for standard containers
-
bitwrap_derive
derive for bitwrap
-
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… -
unchecked_unwrap
Adds an unchecked version of
unwrap()andexpect()to Option and Result -
k8-client
Core Kubernetes metadata traits
-
enumflags
Bitflags
-
format
A utility crate to make it easier to work with the formatter
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
filters
Build filters/predicates with the builder pattern
-
tupletools
Utility functions for tuples
-
r-rust
Useful tools and macros for research (WIP). Currently, a microbench probe is implemented
-
cenum
A rust derive macro for C-style primitive enums
-
miniserde-enum
Derive macros for miniserde on enums
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
type-uuid
Safe, stable IDs for Rust types
-
enumx
Structural enum implemented in enum exchange
-
into-result
A simple convenience trait for converting something into a
ResultorOption -
defmac
A macro to define lambda-like macros inline
-
iter-comprehensions
A library for iterator comprehensions
-
enum_variant_type
Generates types for each enum variant and conversion trait impls
-
named-block
Macro implementing early-exit-from-any-block
-
status
Error container
-
enum_set2
A bit-set indexed by enum variants
-
incomplete
Provides incomplete!(), a compile-time checked version of unimplemented!()
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
lambda_runtime_errors_derive
Rust runtime errors derive for AWS Lambda
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
validated-slice
Helper macros to implement std traits for custom validated slice types
-
as-result
Traits for converting types which may be interpreted as or into a result
-
newtype_array
A macro to help implementing the standard derived traits on newtype arrays
-
failchain
Ergonomic companion library for failure
-
join_to_string
Join a list of items to string/buffer
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
never
A stable version of the unstable never type (!)
-
structview_derive
Custom derive for structview’s View trait
-
sum_error
Derive macros for fast summing of error types into error enum
-
aspect-weave
An Aspect Toolkit for Rust
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
single
Provides the Single trait for extracting the element from a single-element iterator
-
kinder
Kinder is a small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
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…
-
trace-error
Extensions to Rust’s error system to automatically include backtraces
-
range-split
Utilities for splitting sequences with range parameters
-
kaguya_rs
Functional Programming tools and ADTs
-
precog_iter
An iterator adapter that returns the equivalent of
(iter.next(), iter.peek()) -
result-like
Option/Result-like monad interface for your own enum
-
enum_properties
A macro for declaring static properties on enum variants
-
newtype_derive
This crate provides macros for deriving common traits for newtype structures
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
const-if
This crate adds if-else expression into your constant functions
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
indoc-impl
Indented document literals
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
predicates-core
An API for boolean-valued predicate functions
-
into_inner_drop
A helper library for implementing into_inner method for drop types safely
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
fmt_adapter
Provides newtype adaptors to and from any formatting trait
-
inner
The inner! macro descends into an enum variant. It’s more flexible than try!() and unwrap(), and it works with your enum, too!
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
error-chain-mini
error-chain for minimalist
-
overload
Provides a macro to simplify operator overloading
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
concat-string
Provides macros for concatenating string slices into owned strings
-
stackpin
Crate for data that should be pinned to the stack at the point of declaration
-
eliza_error
“Times are bad. Children no longer obey their parents, and everyone is writing an error handling library.” — Cicero
-
pluralize
A generic trait across single and multiple elements
-
static_assert_macro
Library implementation of so-called
static_assert -
auto_ops
Macros for easy operator overloading
-
mods
Simpler module declaration
-
nshare
Conversion between n-dimensional types in different Rust crates
-
mcurry
Macros for creating curried functions
-
ufcs
Helper trait to call free functions using method call syntax
-
reduce
Fold an iterator without an initial value
-
multi-eq
Macros for creating custom equality trait derives
-
error-type
Provides a macro for constructing unifying error types
-
fast_new_type
A proc_macro attribute to implement common traits for a custom type wrapping other
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
option-filter
Option::filter polyfill for Rust 1.26 and older
-
hash-db
Trait for hash-keyed databases
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
lazy-init
Lazy initialization
-
curry-macro
Have fun currying using Rust’s native closure syntax
-
rusty_v8_helper_derive
A rust derive macro for rusty_v8_helper
-
init_with
Helper trait to initilize an array with a function
-
extension-trait
Macro to declare extension traits
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
gaclen_shader
Tweaked re-export of vulkano_shader! procedural macro
-
nes
New Error System for rust
-
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
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
tiny_fail
Provides simple Fail type
-
di
Dependency injection container
-
scoped_threads
Lightweight, safe and idiomatic scoped threads
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
boow
Borrow Or oWnedsmart pointer. Alternative to Cow. -
tuple-conv
Allows converting tuples of one element to vectors
-
abi_stable_derive
Implementation detail of abi_stable
-
enum-methods
Generates methods for each enum variant
-
hypospray
Lightweight dependency injection library
-
compile_msg
A plugin for emitting errors, warnings and notes to the developer at compile time
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
casual
Simple crate for parsing user input
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
primitive-from
Provides a trait PrimitiveFrom that is what From is to Into for num_traits::AsPrimitive
-
sconcat
String concatenation
-
internship
Interned string and more
-
tapir
Adding tapping functionality to rust
-
size_hint
A very simple library to provide a size_hint for an iterator which does not provide it’s own
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
snaptest
Dead simple snapshot testing
-
unborrow
Macro for calling a &mut self method with transient &-borrows of self in the parameters
-
splop
Helper functions to determine the first/last repetition of something
-
tyenum
Attribute macro for type enums
-
d2_iterators_smc
Demo : Dummy upload for checking
-
hexfloat
Syntax extension to create floating point literals from hexadecimal strings
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
rhs_first_assign
An attribute macro to hack compound assignment
-
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:…
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
round
This crate provides utilities to round your floats with precision from 1 to 10
-
impl_ops
Macros for easy operator overloading
-
arc-io-error
A version of std::io::Error implemented on top of Arc instead of Box, making it cloneable
-
delegatemethod
Delegate method calls to a field
-
disjoint-borrow
Disjoint mutable borrows of slices
-
herbie-lint
A rustc plugin to check for numerical instability
-
lfa_derive
Macros for LFA
-
unroll
An attribute-like procedural macro for unrolling for loops
-
pretty-sure
Like
.unwrap()or.or_else()for arbitrary patterns -
tyname
Retrieve type names during program execution on stable Rust
-
macro_lisp
Lisp-like DSL for Rust language
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
track-macro
A macro to track data changes
-
to_vec
convenient to_vec, to_set and to_map methods on iterators
-
grange
create range numbers macro
-
split_by
Split anything implementing Read trait by multiple sequences of bytes
-
read-byte-slice
An iterator over chunks of bytes as slices from an underlying reader
-
errors_rust
Just a simple library for error mapping
-
conditional
Provides a conditional! macro which lets you use the syntax of the conditional operator (also known as the ternary operator) in Rust
-
zkp-macros-decl
Procedural macros
-
sugar
Rust syntax sugar collections
-
enum-iterator-derive
Procedural macro to iterate over the variants of a field-less enum
-
dsl_macros
Convenience macros that rewrites method calls inside a builder closure
-
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
traitcast_core
Cast between dynamic trait objects
-
rev_slice
A newtype for operating on a reversed view of a slice
-
zkp-macros-lib
Library of procedural macros implemented using
proc_macro2 -
tilde
Using ~ to provide syntax sugar for Rust
-
map_for
A Rust macro that implements for comprehensions similar to Scala’s
-
flt2dec2flt
Low-level functions to convert floating point numbers to strings and vice versa
-
function_group
A macro to hack in function overloading to rust
-
drop_bomb
A runtime guard for implementing linear types
-
iter_vals
On the fly iterator creation
-
unify
Trait-based equality constraint for Rust
-
control-flow
A hack to control control-flow outside closures
-
ref-map
Helper trait for Option and Result to map references
-
try_into_opt
A macro like try!, but turns a Result into an Option, mainly for use in a filter_map
-
checked_ops
Automatic checked arithmetic operations in Rust
-
yade
Yet Another Derive Error
-
multizip
Zip 3, 4, 5 or more Rust iterators
-
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.
-
slugify
Macro for flexible slug generation
-
frunk_proc_macro_helpers
Common internal functions for frunk’s proc macros
-
as-dyn-trait
An attribute macro that generates methods for retrieving supertraits from trait-objects (upcasting)
-
try_clone_derive
a crate wich add a derive TryClone macro for the TryClone Trait of the fallible_allocation crate
-
cbox
C pointer boxing, for when working with ffi
-
ama
Quasi-quotation system for designing procedural macros mixed with Rust code
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
specialize
Type specialization macros and helpers
-
builder_macro
A macro to generate structs and a corresponding builder
-
zkp-criterion-utils
Criterion helpers to benchmark over size and number of processors
-
list_builder
Python-like list comprehensions in Rust
-
dont_panic
panic!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won’t panic.
-
num_alias
simple macros to declare ‘type checked’ aliases for integers and floats
-
float
Lightweight wrappers around primitive floating point types
-
io-error
Simple and convenient macro for creating I/O errors
-
pinpoint
Crate for pinned references
-
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
adjacent-pair-iterator
An iterator over adjacent pairs in another iterator
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
kvfmt
A helper macro for stringifying variables into a key=value style string
-
geopattern
Beautiful generative geometric background images from a string, a Rust implementation of geo_pattern from @jasonlong
-
transaction
transaction abstraction library (a.k.a. transaction monad)
-
with-macro
Syntactic sugar for calling methods
-
sorted
Provides compile time guarantees for sorted sequences
-
enum_str
Creates a unitary enum and conversions from enum variants to string and vice versa
-
match-downcast
A set of downcasting matching Rust macros
-
wrap
Generic function wrapping
-
abscissa_generator
Template-based generator for creating new Abscissa applications
-
underscore_args
Macro for underscore named argument syntax, aka Dyon
-
clone_all
clone_all!(my,variables,with,long,names);
-
lift-fail
A library to handle
failurein an iterable collection -
id-derive
Derive-based newtype pattern for integral IDs in Rust
-
almost
A crate for comparing floating point numbers
-
error-context
Methods and types that help with adding additional context information to error types
-
aspect
An Aspect Toolkit for Rust
-
subset
Various subsets of slice’s items that are able to iterate over references to selected items
-
parse-display-derive
Procedural macro to implement Display and FromStr using common settings
-
progressive
A rust library for showing progress of iterators and loops
-
validator_derive
Macros 1.1 implementation of #[derive(Validate)]
-
bitpat
Bit-level matching against values
-
jane-eyre
An Eyre derivative error type with support for tracing-error and help text for error messages
-
bounded-integer
Bounded integers
-
clone-into-box
A library for cloning trait objects
-
slice-cast
Support for casting between slice types
-
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
tagged_ptr
A safe tagged union pointer datastructure for x64
-
dto_derive
Derive for automatic mapping DTOs to Entities and vice versa
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
pub-iterator-type
Abstract an iterator implementation behind a struct tuple
-
taken
Macros for taking ownership, staring Liam Neeson
-
stringlit
A macro to convert from str to String
-
enum_index
Trait and macros for extracting Enum variant index
-
enum-kinds
Generate enums with matching variants but without any of the associated data
-
compiler_error
Triggerable compiler error
-
take-until
A take until extension for iterators
-
either_n
An Either enum with N variants
-
anon
Anonymous struct macro
-
iflet
Provides a macro to chain multiple patterns in an
if letrather than nesting them -
enum_from_str
Enable deriving FromStr for enums
-
peek-nth
An iterator adapter that allows you to efficiently peek the nth item of an iterator
-
wrapped-vec
Macro for generating wrapped Vec types and associated boilerplate
-
koute/nes
An NES emulator written in Rust
-
eager
Crate for eager macro expansion
-
market
Infrastructure built around producers and consumers
-
powerset-enum
A poor man’s anonymous enum
-
enum_variants
Deriving traits for C-like enums using macro 1.1
-
dioptre
Struct field projection tools
-
altbitflags
Macros to implement a struct which behave similar to bitflags
-
gtmpl_derive
Derive for gtmpl_value
-
splits_iter
Iterator over all 2-splits
-
eraserhead
erase the lifetimes from types
-
errloc_macros
Error location utility macros
-
type_eq
Tiny utils for type-level constraints and inference
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
enum_macro
Useful macro for enum
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
hash-of
A typesafe wrapper for hashes
-
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.
-
efficient_enum
Space-efficient enum values
-
gen-iter
temporary util for creating iterators using generators
-
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
-
scoped
Run deferred closures at success, failure, or exit of a scope. Also supports cancelling them
-
breaktarget
Implementation of nonlocal breaks in Rust
-
tramp
Trampoline for recursive functions, with support for mutual recursion
-
shippai
failure in other languages
-
he_di_internals
Common code for he_di crates
-
overflow-error
Common overflow error types
-
assert-impl
Macro for static assert types implement a trait or not
-
arraygen-docfix
Derive macro for generating arrays from struct fields
-
error_derive
Macros for deriving Error implementations through custom_derive!
-
zkp-mmap-vec
Replacement for
Vecthat uses file-backed storage -
iter_from_closure
Iterator<Item = Item> from FnMut() -> Option
-
dedup_iter
Deduplicating iterator adapters
-
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
-
pure_decimal
A decimal type with no NaN and Infinity
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
pl-hlist-derive
Provides the HListSupport derive macro used in conjuction with the
pl-hlistcrate -
rust-fsm-dsl
Macros for rust-fsm DSL
-
dioptre-derive
Custom derive macro for #[derive(Fields)]
-
err_prop
Super simple ( and stupid ) floating point error propagation calculating type
-
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
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
transfer
Crate that exposes a Transfer trait, that is to move what Clone is to copy
-
rustup-find
Use rustup to automatically find and/or install the latest Rust version that supports all the currently installed components
-
iter-python
Python generator expressions and ‘list’ comprehensions
-
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
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
monad
Stackless monads in Rust
-
extdot-impl
Please see
extdotcrate for actual usage -
identity
A stable Rust implementation of an identity (a.k.a., “equality witness”) type
-
derive_deref
Adds
#[derive(Deref)]and#[derive(DerefMut)] -
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!
-
seek-ext
Extension trait to add convenience methods to
io::Seektypes -
withers_derive
A macro to implement wither methods for properties of a struct
-
hmap
Adds hmap! macro for easily generate HashMap
-
try_enum
match enum
-
slice-copy
Go style copying for slices
-
traitlit
This crate exposes an atribute for implementing traits for integer and float types
-
def-mod
Simplifies module implementation routing and statically verifies exports
-
w_result
A result type that carries warnings
-
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
-
boxing-day
Unwrap a Box in festive fashion, only on boxing day!
-
field_types
Some derive macros for deriving enums, corresponding to the fields of structs
-
dynamic
A dyanmically typed value with fast downcasting
-
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.
-
displaydoc-watt
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
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…
-
const_fn
An attribute for easy generation of a const function with conditional compilations
-
split_preserve
An iterator that splits on whitespace but doesn’t throw it away
-
typebool
Type-level booleans meant for compile-time hackery
-
also
A collection of Kotlin-esque blanket impl helper functions, enabling easier function chaining patterns
-
transaction-stm
transaction abstraction of stm
-
varianteq
Derive the equality of enum variants ignoring fields
-
loosen
Derives a wrapper function which loosen the arguments into a tuple
-
dynomite-derive
Derives AWS DynamoDB dynomite types from native Rust struct types
-
ref_eq
Determine if two borrowed pointers point to the same thing
-
trait_enum_macro
A macro that allows creating an enum that acts similar to a trait object, but without using the heap
-
copy_from_str
An extension trait to copy a string into another string
-
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
-
derivate
A set of alternative
deriveattributes for Rust -
nan-preserving-float
(Mostly) drop-in replacement for floats that preserves the signalling bit in NaNs under conversions and unary operations
-
default-env
The
env!macro but with a default value -
tuple-transpose
Transpose tuple of results and options to result and option of tuple
-
spirv_headers
Rust definition of SPIR-V structs and enums
-
format-core
Core format types
-
ps
A safe wrapper around
std::mem::transmute -
named_return
Derives a wrapper function which insert the named return variables
-
clierr
Non-panicking error handling for small CLI scripts
-
abi_stable_derive_lib
Implementation detail of abi_stable
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
cenum-derive
A rust derive macro for C-style primitive enums
-
duck
Like
Iterator::peekable, but can be stacked an arbitrary number of times -
enum-error-derive
Derive Error traits
-
gumdrop
Option parser with custom derive support
-
unhygienic
A library for stripping the hygiene out of macro parameters
-
byteorder-pod
Endian-backed storage and memory mapping types
-
define_error
A library for easily defining an error type
-
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…
-
scrapmetal
Scrap Your Rust Boilerplate
-
iter_utils
Iterator utils
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
threadbound
Make any value Sync but only available on its original thread
-
build_timestamp
Simple proc-macro to generate a build timestamp string as a const
-
hado
Monadic do notation using a macro
-
env_proc
env vars
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
enum_traits_macros
Procedural macros that adds functionality to enums by deriving traits from the crate
enum_traits -
overloadable
Overloadable functions done easy in rust
-
accel-derive
Procedual macro for writing GPGPU kernel
-
reflike
Meta-traits for reference look-alikes
-
smart-default
Rust custom-derive macro for Default with more control on the fields
-
enumiter
An iterator through the variants in an enum
-
rbtag_derive
A procedural macro impl to add git and build datetime info
-
error-chain-mini-derive
derives for error-chain-mini
-
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
rusted
Simple tool to highlight rustc –explain output
-
type-level-logic
Primitive types and operations for type-level logic
-
value
Type-level constants for generic contexts
-
chalk-macros
Macros for Chalk
-
trackable_derive
Custom derive for
trackablecrate -
enum-unitary
Trait and macro for unitary enums
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
static-events
A library for creating zero-cost event systems
-
uwuizer
Rust Macro to UwUize your text. UwU.
-
boxfnonce
safe FnOnce boxing for rust stable
-
zkp-error-utils
Assertion like macros for returning
Result::Err -
envsubst
Variables substitution
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
bit_manager_derive
Derive macro for bit_manager crate
-
rlua-table-derive
This crate provides a procedural macro to turn lua tables into rust types via rlua
-
enumer_derive
enum helper
-
riker-patterns
A collection of common actor patterns for Riker
-
err-context
Lightweight context layers for stdandard library errors
-
tynm
Returns type names in shorter form
-
autoimpl-derive
The proc-macro part of the autoimpl macro. Should not be depended on directly.
-
lain_derive
Derive macros for usage with lain
-
tense
n-rank tensor calculus
-
hdf5-derive
Derive macro for HDF5 structs and enums
-
resultit
Iterator adapters for iterators over results
-
machine
State machine utilities
-
bitwise_reduce
Multiple arity bitwise functions
-
frounding
Rust crate to change fpu and sse rounding mode
-
safe-builder-derive
Derive a safe builder pattern
-
scat
String concatenation, replaced by sconcat
-
same
Traits for testing identity of objects
-
derive-new
#[derive(new)]implements simple constructor functions for structs and enums -
mysql_enum
Convert between Rust enum and MySQL enum
-
getters-by-type
Derive macro for adding a getter method for each type in the struct
-
throttled-reader
An io::Read proxy that limits calls to read()
-
comprehension
Iterator comprehension in Rust
-
unzip-n
Procedural macro to generate
unzipfor iterators over n-sized tuples -
asserter-macros
New assertion library for rust
-
pathsep
a small macro to enable easy path construction in other macro calls
-
either_trait_macro
An attribute-like macro to implement traits for Either
-
gpg-error
Libgpg-error bindings for Rust
-
expect_macro
The expect! macro
-
blair_mountain
Union types in release mode with debug assertions in debug mode
-
xkcd_unreachable
A Rust macro xkcd_unreachable!() inspired by https://xkcd.com/2200/
-
bijection
A library for producing bijective functions in Rust
-
proc-macro-error-attr
Attribute macro for proc-macro-error crate
-
nom-fields
Provides a single function-like macro that removes some boilerplate from a common pattern when using nom
-
never-type
This library is an alternative implementation of never type for stable rust
-
arrayref
Macros to take array references of slices
-
rust-enum-derive
A simple library (and program) for generating rust enums and associated traits from text files
-
iterr
Combinators for dealing with iterators of
Results -
forever
-
diesel-derive-newtype
Automatically connect newtypes to Diesel using their wrapped type
-
copystr
&str with
Copysemantics -
fn_ops
Temporary traits for function operator overloading, pending the stabilization of
Fn,FnMut, andFnOnce -
futures-await
Async/await syntax for Rust through a procedural macro. This crate defines the
#[async]macro for functions, theawait!macro for function bodies, and intends to be used with thefuturescrate on crates.io as well. -
conform
Macro to transform struct string fields in place
-
tyenum_attribute
Attribute macro for type enums
-
int-enum
A procedural macro for conversion between integer and enum types
-
boolinator
Provides the Boolinator trait, which lets you use Option and Result-style combinators with bools
-
he_di
Dependency Inversion / Dependency Injection / Inversion of control container for Rust
-
blunder
Dumb crate to make error handling easy
-
enum-tryfrom
Error types and traits for use with enum-tryfrom-derive
-
dcc-lsystem-derive
Macro implementation of #[derive(TurtleContainer)]
-
structural_derive
Implementation detail of the structural crate
-
plain_enum
Mimicing Java’s enum::values() and EnumMap
-
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… -
enumflags_derive
Bitflags
-
build_epoch
Macro for calculating the epoch at compile time
-
human-panic
Panic messages for humans
-
karabiner-thunk
lazy evaluation for rust
-
transaction-diesel
transaction abstraction of diesel
-
variant_count
Derive macro for enum which adds to it the count of variants
-
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
frunk_proc_macros_impl
Proc macros inernal implementations for Frunk
-
version
A very simple library who’s job is to return the version of your crate if you’re building with Cargo
-
vergen
Generate version related functions
-
ff_derive
Procedural macro library used to build custom prime field implementations
-
once
This crate provides an assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
derive_asref
derive AsRef in variety way
-
sval_derive
Custom derive for sval
-
ff_derive_ce
Procedural macro library used to build custom prime field implementations
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
kwarg_macros
Keyword argument plugin
-
rust-iteratorcomprehensions
A comprehension syntax for iterators implemented as macros
-
lark-error
Representation of an error in the Lark compiler
-
null-terminated
Library of null-terminated slices and UTF-8-encoded strings with thin references
-
derive-error-chain
A Macros 1.1 implementation of error-chain
-
serde-enum-derive
Serde enum primitive derive
-
dmutil
A collection of utility macros to ease the creation of other macros
-
read_with
Create a Read from a function
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
num_enum_derive
Internal implementation details for ::num_enum (Procedural macros to make inter-operation between primitives and enums easier)
-
zkp-macros-impl
Implementation crate for
proc_macro_hack -
any-error
When you just want to use
?in peace -
passert
Pretty/Power assertion macros for rust
-
enum_primitive
Macro to generate num::FromPrimitive instances for enum that works in Rust 1.0
-
vptr-macros
Procedural macros for the
vptrcrate -
assert_approx_eq
assert approximately equal
-
soa_derive_internal
Internal implementation crate for soa-derive
-
exact-float
Do your calculations with exact floating point numbers
-
named_type_derive
Derive support for named_type
-
evitable
Custom error types with context and derive
-
reinterpret
Low level utility functions to reinterpret arrays of data
-
tilde_derive
Using ~ to provide syntax sugar for Rust
-
typed_index_derive
Custom derive to easily create newtype index types
-
enum-display-derive
Display trait’s custom derive for simple enums
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
ommui_string_patterns
String pattern checkers for OMMUI identifiers
-
scoped-callback
Register scoped functions with local references to ’static lifetime callbacks in a safe manner
-
macro-machines
State machine macros with logging and graphviz DOT file generation
-
tylar
Type-Level Arithmetic in Rust
-
fma
Tiny crate to use FMA(Fused Multiply-Add) instruction easily
-
endian-type
Type safe wrappers for types with a defined byte order
-
join-lazy-fmt
Lazy
separator.join(iterable)method andlazy_format!for Rust -
derive_setters
Rust macro to automatically generates setter methods for a struct’s fields
-
wrapped_enum
Useful macro to wrap existing types in an enum (common use for quick error handling)
-
libgpg-error-sys
Raw bindings for libgpg-error
-
inherent-pub
Mark methods in
impl Trait for Typeblocks inherent to the type -
phantom_newtype
Lightweight newtypes without macros
-
enum_index_derive
Macros for extracting Enum variant index
-
enum-as-inner
A proc-macro for deriving inner field accessor functions on enums
-
xplane_plugin
Provides types and a macro for creating X-Plane plugins
-
cast_trait
cast trait
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
u9
Unsigned 9-bit integer type
-
primitive_enum
Little utility for dealing with enums no extra data in variants
-
rental-impl
An implementation detail of rental. Should not be used directly.
-
as_derive_utils
private derive utilities used by abi_stable and structural
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
flow_impl
Definition of an Implementation trait for flow functions, and a derive macro
-
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
capture
A macro for adding explicit capture clauses to a (closure-) expression
-
failure_ext
Convenience extension traits for the failure error-handling crate
-
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.
-
derive_builder_core
Internal helper library for the derive_builder crate
-
lazy_mut
This crate provides a structure that can be used to lazily initialized values as well as a macro for creating lazy variables
-
derivation
Deriving traits for C-like enums using macro 1.1
-
improved_slice_patterns
A tiny crate that provides macros to help matching on Vecs and iterators using the syntax of slice_patterns
-
enum_from_str_derive
Enable deriving FromStr for enums
-
c2rust-bitfields-derive
C-compatible struct bitfield derive implementation used in the C2Rust project
-
darling_macro
Internal support for a proc-macro library for reading attributes into structs when implementing custom derives. Use https://crates.io/crates/darling in your code.
-
conform-derive
Macros 1.1 implementation of #[derive(Conform)]
-
ip-macro
Macros for writing literal IP addresses
-
structbuilder_derive
Super simple macro to derive a builder trait for your struct
-
enumflags2_derive
Do not use directly, use the reexport in the
enumflags2crate. This allows for better compatibility across versions. -
ref_slice
Turn a reference into a slice of length one
-
mem_macros
align_of and size_of as a macro, to avoid turbofish notation