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