-
once_cell
Single assignment cells and lazy values
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
thiserror
derive(Error)
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren’t compiler hackers
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
ordered-float
Wrappers for total ordering on floats
-
bytes
Types and traits for working with bytes
-
bitflags
A macro to generate structures which behave like bitflags
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
scroll
A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
memoffset
offset_of functionality for Rust structs
-
snafu
An ergonomic error handling library
-
float-cmp
Floating point approximate comparison traits
-
synstructure
Helper methods and macros for custom derives
-
anyhow
Flexible concrete Error type built on std::error::Error
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
tt-call
Token tree calling convention
-
beef
More compact Cow
-
typed-builder
Compile-time type-checked builder derive
-
typenum
Typenum is a Rust library for type-level numbers evaluated at compile time. It currently supports bits, unsigned integers, and signed integers. It also provides a type-level array of type-level numbers…
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
educe
This crate provides procedural macros to help you implement Rust-built-in traits quickly
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive -
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
az
Casts and checked casts
-
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… -
annotate-snippets
Library for building code annotations
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
derivative
A set of alternative
deriveattributes for Rust -
tap
Generic extensions for tapping values in Rust
-
uninit
A collection of tools for a safer usage of uninitialized memory
-
frunk
Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
macro_rules_attribute
Use declarative macros in attribute or derive position
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
anymap
A safe and convenient store for one value of each type
-
io-lifetimes
A low-level I/O ownership and borrowing library
-
conv
This crate provides a number of conversion traits with more specific semantics than those provided by ‘as’ or ‘From’/‘Into’
-
if_chain
Macro for writing nested
if letexpressions -
async-trait
Type erasure for async trait methods
-
fp_rust
Implement fp features for Rust
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
float-ord
A total ordering for floating-point numbers
-
dep-obj
Dependency object: effective reactive heterogeneous container
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
sugars
An useful collection of macros to make tasks easier
-
lazy-static-include
This crate provides
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
approx
Approximate floating point equality comparisons and assertions
-
bounded-integer
Bounded integers
-
advent-of-code
Solutions to Advent of Code
-
safe-transmute
A safeguarded transmute() for Rust
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
tokenlock
Provides cell types that decouple permissions from data
-
abi_stable_shared
Implementation detail of abi_stable
-
memoize
Attribute macro for auto-memoizing functions with somewhat-simple signatures
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
pin-project
A crate for safe and ergonomic pin-projection
-
buffered-reader
A super-powered Reader
-
static_assertions
Compile-time assertions to ensure that invariants are met
-
assertables
Assertables: Rust crate of macros
assert…!for better testing, quality assurance, and runtime reliability -
cynic
A GraphQL query builder & data mapper for Rust
-
geo-types
Geospatial primitive data types
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
standback
New standard library, old compiler
-
pact_consumer
Pact-Rust module that provides support for writing consumer pact tests
-
lazy_format
A utility crate for lazily formatting values for later
-
stdext
Extensions for the Rust standard library structures
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
semval
Semantic validation
-
cryo
Extend the lifetime of a reference. Safely.
-
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… -
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the “hidden lifetime in impl Trait” issue
-
mode
A behavioral state machine library written in Rust
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
rust_info
Extracts the current rust compiler information
-
validator_types
Basic type for validator and validator_derive
-
joinery
A small crate for generically joining iterators with a separator
-
extend
Create extensions for types you don’t own with extension traits but without the boilerplate
-
gazebo
A collection of well-tested utilities
-
auto_enums
A library for to allow multiple return types by automatically generated enum
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
quick-error
A macro which makes error types pleasant to write
-
typeables
Typeables: Rust crate of type aliases. By SixArm.com.
-
sealed
Macro for sealing traits and structures
-
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]checks -
nonzero_ext
Extensions and additional traits for non-zero integer types
-
typestate
A proc macro DSL for typestates
-
maybe-owned
provides a
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
pipe-trait
Make it possible to chain regular functions
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
buildstructor
Macro to derive a builder from a constructor function
-
prima_bridge
A library to implement the bridge pattern
-
id-arena
A simple, id-based arena
-
macro-attr-2018
This crate provides the
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
derive-where
Deriving with custom trait bounds
-
ffi_helpers
A crate to help make working with FFI easier
-
atomic
Generic Atomic wrapper type
-
copy_from_str
An extension trait to copy a string into another string
-
fatality
Fatality extension to
thiserror::Error -
components-arena
Simple library for creating complex domain-specific self-referential data structures
-
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… -
objid
Generate a random object identifier
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
void
The uninhabited void type for use in statically impossible cases
-
concat-with
Extend the function of the
concat!macro instd -
similar-asserts
provides assert_eq! like macros with colorized diff output
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator -
messages
Runtime-agnostic actor library
-
one_err
OneErr to rule them all
-
lazycell
A library providing a lazily filled Cell struct
-
with_locals
Function attribute to return references to locals by using CPS
-
try_match
An expression macro to match a pattern and return the bound variables in
Result -
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
esrs
A Prima.it-opinionated library to achieve cqrs/es
-
gumdrop
Option parser with custom derive support
-
intertrait
Allow for inter-trait casting
-
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
-
fixnum
Fixed-point numbers with explicit rounding
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
take_mut
Take a T from a &mut T temporarily
-
lset
Data types describing linear sets
-
utils-results
The easiest and most intuitive error handling solution
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
builder-pattern
A derivable macro for declaring a builder pattern
-
event-listener-primitives
Low-level primitive for building Node.js-like event listeners
-
simple_parse
A declarative converter for Rust type to and from binary
-
deltoid
A library to calculate and apply deltas to structs and enums
-
evcxr_repl
A REPL for Rust
-
k8-client
Core Kubernetes metadata traits
-
data-rw
io buffer write reader
-
result-like
Option/Result-like monad interface for your own enum
-
fstrings
Python3 fstring interpolation in Rust
-
stackalloc
Safely allocate and manipulate arbitrarily-sized slices on the stack at runtime
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
rc-box
Known unique versions of Rc and Arc
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
predicates-core
An API for boolean-valued predicate functions
-
arraygen
Derive macro for generating arrays from struct fields
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
cast
Ergonomic, checked cast functions for primitive types
-
unimock
Unimock type for working with multiple trait bounds
-
shellexpand
Shell-like expansions in strings
-
fallible_collections
a crate which adds fallible allocation api to std collections
-
drop_bomb
A runtime guard for implementing linear types
-
downcast
Trait for downcasting trait objects back to their original types
-
volatile
A simple volatile wrapper type
-
human-errors
An error library focused on providing your users with relevant advice for any problem
-
syllogism
Utilities to allow for some specialization using stable Rust
-
apparat
A lightweight event-driven behavioral state machine
-
rustdoc-types
Types for rustdoc’s json output
-
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
tia
tia; trait, impl, accessors | automatic
-
easy-error
Simple error utilities
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
include-flate
A variant of include_bytes!/include_str! with compile-time deflation and runtime lazy inflation
-
random-number
Generate random numbers quickly
-
structmap
Procedural macro library for converting between Rust structs and associative containers
-
direction
Representations of directions
-
cassandra_macro
Create Cassandra tables and CRUD CQL prepared statements from Rust structs. (custom derive: cassandra_macro_derive)
-
by_address
Wrapper for comparing and hashing pointers by address
-
enum-assoc
Procedural macro to associate constants with enum variants
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
flowync
A simple utility for multithreading a/synchronization
-
metered
Fast, ergonomic metrics for Rust!
-
gazebo_derive
Derive macros for the Gazebo library
-
async-once-cell
Async single assignment cells and lazy values
-
compound-error
Compound errors with flat hierarchy
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
shoulda
derive macro for test assertions
-
retry-error
An error type for an operation that can fail more than once
-
boomphf
Scalable and Efficient Minimal Perfect Hash Functions
-
abi_stable_derive
Implementation detail of abi_stable
-
cronjob
cronjob library for scheduling your methods
-
derive_builder_core
Internal helper library for the derive_builder crate
-
rsb_derive
An opinionated macros implementation for Rust struct builder pattern
-
openapi_type
OpenAPI type information for Rust structs and enums
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
tc-error
TinyChain’s generic error struct
-
round
This crate provides utilities to round your floats with precision from 1 to 10
-
ees
Simple error-handling library
-
kv-derive
Derive struct conversions from and to key-value vectors
-
exponential-backoff
A small and flexible backoff function
-
fn_meta
Returns metadata about a function at runtime
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
format
A utility crate to make it easier to work with the formatter
-
failsafe
A circuit breaker implementation
-
lens-rs
lens implemented in rust
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
iter_fixed
Iterator of fixed length
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
batch_oper
batch_oper provides some batch operation macro for some operations
-
bool_ext
A crate which defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
macrofied-toolbox
This library provides an ergonomic experience of adding debugging messages to rust’s Result<T,E> and Option patterns
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
collate
Traits and a data structure to support collation and bisection
-
fomat-macros
Alternative syntax for print/write/format-like macros with a small templating language
-
problem
Error handling for command line applications or prototypes
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
dyn-context
Non-owning service provider pattern implementation
-
nshare
Conversion between n-dimensional types in different Rust crates
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
grouping_by
A simple library which allows the user to group an iterator by various ways
-
clone_cell
A Cell that works with a restrictive form of Clone
-
impls
Determine if a type implements a logical trait expression
-
tuple_list
Crate for macro-free variadic tuple metaprogramming
-
fortify
A simple and convenient way to bundle owned data with a borrowing type
-
variant_count
Derive macro for enum which adds to it the count of variants
-
iter-comprehensions
A library for iterator comprehensions
-
aligners
Utilities for alignment guarantees for data
-
derive_builder_macro
Rust macro to automatically implement the builder pattern for arbitrary structs
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
try-drop
Batteries included error handling mechanisms for drops which can fail
-
manifest-dir-macros
This crate provides function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
cursor
A more free Rust-Iterator
-
io-extras
File/socket handle/descriptor utilities
-
ebacktrace
A simple error wrapper which captures a backtrace and can carry an optional textual description
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
near-safe-cell
A more ergonomic ‘UnsafeCell’ wrapper/replacement
-
runestr
User-perceived characters related types and data structures
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_partsandVec::into_raw_parts -
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
function_name
macro that expands to the name of the annotated function
-
snailquote
Escape and unescape strings with shell-inspired quoting
-
structview
Viewing binary data as high-level data structures, safely
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
hado
Monadic do notation using a macro
-
ez-err
A simple error handling library with support for ergonomic and fast error handling
-
teloc
Simple, compile-time DI framework for Rust
-
tryhard
Easily retry futures
-
podio
Additional trait for Read and Write to read and write Plain Old Data
-
cex
Checked exception simulation
-
mixed-num
A trait for generic implementations of numerical methods
-
extension-trait
Macro to declare extension traits
-
generics
Provides macros for parsing generics (with optional where clause) in
macro_rules! -
restcrab
Procedural macro to automatically generate a REST client from a trait definition
-
maybe-single
A singleton. Maybe.
-
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…
-
error_def
A Rust syntax extension for generating error-handling boilerplate code
-
tokio-pg-mapper
Proc-macro library used to map a tokio-postgres row to a Rust type (struct)
-
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
-
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
frunk_proc_macro_helpers
Common internal functions for frunk’s proc macros
-
rust-fsm-dsl
Macros for rust-fsm DSL
-
arr_macro
Initialize arrays with ease!
-
yui
An attribute reader generator for Rust
-
rvs-c-api
C-API for Rvs - A library for defining and evaluating random variables using a simple DSL
-
grep-matcher
A trait for regular expressions, with a focus on line oriented search
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
amplify_syn
Amplifying syn capabilities: helper functions for creating proc macro libraries
-
const_fn
An attribute for easy generation of const functions with conditional compilations
-
shaku
Compile Time Dependency Injection for Rust
-
select_indices
Iterators for taking multiple shared/exclusive references from a slice
-
slugify-rs
A rust library to generate slugs from strings
-
thiserror-impl
Implementation detail of the
thiserrorcrate -
delegate-attr
Attribute proc-macro to delegate method to a field
-
disuse
The way to notify the implementation which return value is disuse
-
pre
Compile-time assistance for working with unsafe code
-
mac
A collection of great and ubiqutitous macros
-
haz
A thin abstraction over polymorphic environments
-
into_variant
Easily convert your types into the corresponding enum variant
-
degeneric-macros
Hides struct generics into trait associated types
-
metainfo
Transmissing metainfo across components
-
dynerr
Macros for dynamic error handling
-
str-macro
The str!() macro, similar to vec![] but for strings
-
assert_unordered
A direct replacement for
assert_eqfor unordered collections -
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
tracerr
Custom compile-time captured error tracing
-
beaver
A library for setting up Rust objects inspired by factory_bot
-
blanket
A simple macro to derive blanket implementations for your traits
-
cantor
A general toolkit for working with types that have a small number of values
-
merge
Merge multiple values into one
-
heterob
Library for conversion between bytes/bits and heterogeneous lists (tuples)
-
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
-
chainerror
Make chaining errors easy
-
crossdylib
Cross-platform shared state across shared libraries/modules
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
simple-error
A simple error type backed by a string
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
big_mac
A metamacro toolkit for writing complex macros
-
derive_destructure2
Destructure structs that implement Drop
-
roopert
Another object-oriented toolkit for Rust
-
strong
Strongly typed String
-
tide-tera
Use tera templates on tide
-
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
-
swiss-army-knife
Common utility code to support linux-support and other projects
-
threadbound
Make any value Sync but only available on its original thread
-
cast_trait_object
Cast between trait objects using only safe Rust
-
flow-control
Declarative macros for common flow-control use cases such as break, continue, and return
-
enum_cycling
Small macro for working with enums
-
bit_field
Simple bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust’s integral types
-
cute
A macro for Python-esque comprehensions
-
munge
Macro for easily initializing
MaybeUninits -
apodize
simple iterators that yield generalized cosine, hanning, hamming, blackman, nuttall and triangular windows
-
chainer
A cursed crate that allows for global call chaining with access to chained function results
-
as-any
provide the AsAny trait
-
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. -
velcro_core
Core dependencies used by the
velcrocrate. Seevelcrofor documentation. It is not advised to depend on this crate directly; it is an internal dependency ofvelcroand may be subject to breaking changes. -
virtue
A sinless derive macro helper
-
memory-size-type
A data type for dealing with memory sizes
-
typemap_rev
A hashmap, but stores types as keys
-
tuples
Provides many useful tools related to tuples
-
current
A library for setting current values for stack scope, such as application structure
-
fold-license
Folding licenses from multiple dirs with
cargo/Cargo.toml andyarn/package.json -
thiserror_core2-impl
Implementation detail of the
thiserror_core2crate -
warnalyzer
Show unused code from multi-crate Rust projects
-
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging …
-
tor-units
Provides macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
en
The easiest numeric traits!
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
inner
The inner! macro descends into an enum variant. It’s more flexible than try!() and unwrap(), and it works with your enum, too!
-
interior_mutability_pointer
A wrapper around
Rc<RefCell<T>>allowing immediate access to inner methods -
libmw
Library for constructing a pipeline of middleware functions
-
funcmap_derive
Derivable functorial mappings for Rust
-
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
-
generational_vector
A vector type using generational indices
-
named-tup
Create named tuples using the tup!() macro
-
progress-streams
Progress callbacks for types which implement Read/Write
-
rt-format
Fully-runtime equivalent of the format! macro
-
serbia
No-fuss big arrays for Serde
-
inter-struct
Automatically generated traits for arbitrary structs
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
axmac
Readable indexing macros for 1-4 dimensional data structures
-
throw
Efficiently add statically-calculated stack traces to errors
-
posix-errors
Posix error codes and handy functions for using them
-
dynamize
trait objects with variable associated types
-
nomore
Personal Standard Rust Lib Publics for reuse and to avoid redefinition
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
assume
Macro for stating unsafe assumptions in Rust
-
enum_index
Trait and macros for extracting Enum variant index
-
custom_derive
(Note: superseded by
macro-attr) This crate provides a macro that enables the use of custom derive attributes -
concat-string
Provides macros for concatenating string slices into owned strings
-
interpolate_idents
Useable macro identifier concatenation plugin
-
public
A attribute macro used to mark struct/union and its fields as public
-
superstruct
Versioned data types with minimal boilerplate
-
konst_macro_rules
Implementation detail of the konst crate
-
from_iter
Initialize arrays from iterators
-
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 -
implementation
The implementation crate
-
struct_field
Derive macros for generating each field in a struct
-
coded
concrete error type with an
ErrorKindenum matching Google’s “canonical error codes” -
coercible_errors
Zero-cost error handling for generic traits
-
geo-postgis
Conversion between
geo-typesandpostgistypes -
market
Infrastructure for producers and consumers
-
unwind_safe
Readable unwind-safe code thanks to a try-finally-looking builder pattern
-
dpc-pariter
Parallel iterator processing
-
safecast
Traits to define safe casting between types
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
psl-types
Common types for the public suffix implementation crates
-
hash-db
Trait for hash-keyed databases
-
shrinkwraprs
Auto-derive for Rust conversion traits – make working with newtypes a breeze
-
cell-map
Many-layered 2D cellular generic map
-
aliri_braid_examples
Examples demonstrating usage of the
aliri_braidcrate -
ubits
Bit fields and masks
-
qed
Compile-time assertions
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
on_drop
on drop
-
zerovec-derive
Custom derive for the zerovec crate
-
embed-doc-image
Embed images in Rust documentation
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
thisisplural
#[derive(Plural)] for creating frictionless new types with a Vec, HashMap, etc
-
helper
A library provided some useful proc macros for Rust
-
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
asserts-rs
Asserts utilliy macros for Rust
-
rexpr
Rust Json Object access Runtime
-
dicom-dictionary-std
Standard DICOM attribute dictionary
-
precisej-printable-errno
Printable system call errors for nix
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
ref-map
Helper trait for Option and Result to map references
-
eventually
Crate for using Event Sourcing in Rust applications
-
enum_macro
Useful macro for enum
-
map-macro
Declarative map! and set! macros for statically initializing a HashMap or HashSet (like the vec! macro for Vec)
-
arrow2_convert
Convert between nested rust types and Arrow with arrow2
-
interruptor
Collection of functions generating Unix process signal receivers for use in the Crossbeam Channel select! macro
-
unconst_trait_impl
Function-like macro that “unconsts” trait implementations
-
wrapped-vec
Macro for generating wrapped Vec types and associated boilerplate
-
thread-scoped-ref
A library that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
struple
Convert structures from and to tuples
-
extent
replacement for std::ops::{Range,RangeInclusive}
-
py-comp
A macro implementing a Python-like generator expression
-
fastperm
A dead-simple, extreme fast permission flag system for Rust with no dependencies
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
single
Provides the Single trait for extracting the element from a single-element iterator
-
rsor
Reusable slice of references
-
fragile
Provides wrapper types for sending non-send values to other threads
-
spez
Macro to specialize on the type of an expression
-
remove_macro_call
Attribute macro that removes a call of a function-like macro
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
fmt-cmp
Traits and utilities for lexicographically comparing values in their
Displayrepresentations -
trait-enumizer-derive
Helper crate for trait-enumizer
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
toy-arms_derive
A derive macro crate for toy-arms
-
enumx
Ad-hoc enum extension
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
morphism
A structure for suspended closure composition in Rust
-
mybench
Simple (and very primitive) benchmarking macro
-
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…
-
entwine
Generic slice-like interface for operating on multiple slices at the same time
-
derive-from-ext
Derive macro implementing ‘From’ for structs
-
eternal_iterator
Trait implementation to promise that the iterator iterates forever
-
incomplete
Provides incomplete!(), a compile-time checked version of unimplemented!()
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
closure
A macro for capturing variables on a per variable basis
-
polymorphic-constant
A macro to define a numerical constant in multiple types at once
-
slugify
Macro for flexible slug generation
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
iterator-ext
An extension to Rust’s Iterator
-
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!
-
bos
Flexible Borrowed, Owned or Shared (B.O.S.) smart pointers. Like std’s Cow but with Rc/Arc and without the ToOwned requirement
-
quick-error2
A macro which makes error types pleasant to write
-
collections_macros
a collection of macros to make making collections easier
-
ad-hoc-iter
Ad-hoc exact size owning iterator macro and other optional utils
-
dispose
A simple wrapper for values that must be consumed on drop
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
shorten
A collection of convenience functions, macros and traits to shorten repetitive code
-
jsonway
JSON building DSL and configurable serializers for Rust
-
borked
Simple and convienient error handling library for rust
-
percolate
Yet another async utility library
-
once
This crate provides an assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
tupleops
Utility library to work with tuples
-
assure
Assure: macros for Rust runtime checks and error handling
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the relative difference
-
init_with
Helper trait to initilize an array with a function
-
rovv
provide the anonymous row type (poor-man’s row polymorphism) in rust
-
partial_application
partial function application via the partial! macro
-
clover
A scripting language
-
lup
A custom indexed loop macro library for Rust
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
serializable_enum
Two macros for implementing serialization / deserialization for enums containing no data variants
-
enum-unitary
Trait and macro for unitary enums
-
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
-
structx
Simulating anonymous struct and named arguments in Rust
-
aerosol
Dependency injection with compile-time guarantees
-
chassis
Compile-time dependency injection framework
-
fehler
A library for error-handling syntax in Rust
-
vcell
Cellwith volatile read / write operations -
regex-macro
A macro to generate a lazy regex expression
-
kinder
Kinder is a small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
constcat
concat! with support for const variables and expressions
-
frunk_derives
frunk_derives contains the custom derivations for certain traits in Frunk
-
default_kwargs
The macro wich enables you to use default and keyword arguments in Rust
-
clonesure
A helper macro to create closures which will clone its environment
-
elor
Base generic implementation of an Either type
-
retrieve
#[{pub_}mod_{pub_}use(a,b,c,…)] => {pub }mod a; {pub }use a::*; and also b,c,
-
monadic
macros to define Haskell style monadic action blocks for IntoIterators, Reader, Writer, State, and macros for the transformers ReaderT and WriterT over Vec, LinkedList and VecDeque
-
high_mem_utils
This crate provides a bunch of mem safe abstractions,some involving transmute
-
for_each_repeat
Iterator::for_eachthat can repeat current iteration -
generics2
Provides macros for parsing generics (with optional where clause) in
macro_rules!- enhanced fork of generics -
overload
Provides a macro to simplify operator overloading
-
pin-init
Safe pinned-initialization in Rust
-
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
-
iter-progress
Calculate progress of your iterators
-
singleton-trait
Singleton trait for types with unique values and Erased type for zero-sized ownership proofs
-
separator
Formats numbers into strings with thousands separators for readability
-
ferrite-session
Session Types DSL for Rust
-
read-restrict
Restrict the number of bytes read from a reader
-
loop_chain
Macro for writing nested Loop expressions
-
lifterr
A small set of adapters extending Rust’s error-handling capabilities
-
socketpair
Cross-platform socketpair functionality
-
impl-tools-lib
Helper macros: autoimpl
-
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… -
never
A stable version of the unstable never type (!)
-
envsubst
Variables substitution
-
trait-set
Support for trait alias feature on stable Rust
-
introsort
Fast sorting compatible with #[no_std]. Also has (optional) support for efficient and robust sorting of floating point numbers. Currently, introsort only builds on nightly
-
kwarg_macros
Keyword argument plugin
-
illicit
An implicit thread-local environment which is indexed by type
-
twilight-error
Error handling utility for the Twilight ecosystem
-
serde_str_helpers
Helpers for using serde with strings
-
funty
Trait generalization over the primitive types
-
cause
A generic [std::error::Error] implementation
-
itermore
More iterator adaptors
-
named-block
Macro implementing early-exit-from-any-block
-
to_unit
ToUnit; Any type to () syntax sugar
-
edisp
Dispatch-on-collect for Rust enums
-
tuple-fn
call functions and closures with tuple of arguments
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
with-api
Simple macro for shrinking scope
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
noneifempty
Convert T to None if empty
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
failure_without_backtrace
Experimental error handling abstraction
-
inline-mod
Inline modules at macro expansion time
-
const_fn_assert
Assertions for const functions
-
kaguya_rs
Functional Programming tools and ADTs
-
tagged_cell
Fast, initializable, and thread safe static variables
-
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…
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
as-result
Traits for converting types which may be interpreted as or into a result
-
globals
Painless global variables in Rust
-
repeated
Allows you to repeat a block of code a number of times
-
total_float_wrap
Floating point wrapper implementing Hash and Ord according to IEEE 754 totalOrd
-
postgres-mapper
Struct mapping for postgres
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
displaythis
derive(Display)
-
dntk-matrix
Statically sized matrix using a definition with const generics (only for nightly)
-
read-byte-slice
An iterator over chunks of bytes as slices from an underlying reader
-
log_err
Log error messages from Unwrap and Expect with log crate
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
auto_ops
Macros for easy operator overloading
-
shoggoth
Generic and type-level programming for Rust
-
ratelimit_rs
The ratelimit package provides an efficient token bucket implementation
-
struct_field_names
Derive macros for generating the name of each field in a struct and each variant name in an enum as
&'static str -
prometheus-metric-storage
Derive macro to instantiate and register prometheus metrics without having to write tons of boilerplate code
-
derive-enum-from-into
Derive for From and TryInto for enums with single fields
-
array-fu
Construct arrays using simple syntax
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
derive-ex
Improved version of the macro to implement the traits defined in the standard library
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
smart_access
A minimalistic “lazy bidirectional pointer” framework
-
autowired
Rust dependency injection
-
i2c-linux-sys
Linux i2c-dev ioctls
-
range-split
Utilities for splitting sequences with range parameters
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
fstrings-rust
Python3 fstring interpolation in Rust
-
build-deps
Rust build-script dependencies generator for data/IDL files
-
comptools
Create iterators using Python’s list comprehesion style
-
shoulda_core
derive macro for test assertions
-
escher
Self-referencial structs using the async/await transformation
-
erasable
Type-erased thin pointers
-
disown
Drop ownership via a method
-
lsp-ty
type definitons for LSP
-
ferrum-plugin
Lazily evaluated, order-independent plugins for extensible types
-
tinytest
Write more compact unit tests with a small macro
-
mdo
Monadic do notation for rust using macro and duck typing
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
derive_di
This crate is realized the dependency injection pattern
-
fuzzypath
Quick & dirty fuzzy path comparison
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
null-terminated
Library of null-terminated slices and UTF-8-encoded strings with thin references
-
tyenum
Attribute macro for type enums
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
phtm
Re-exports for common uses of
PhantomData -
cfg_rust_features
Set cfg options according to probing for Rust compiler, language, and library features
-
trace-error
Extensions to Rust’s error system to automatically include backtraces
-
build-features
A simple proc macro to create a vector that a list of enabled features in a root package
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
annotation-rs-beta
Compile-time annotation parser for rust
-
discrimenum
Derive
HashandPartialEqon enums where only the discriminant matters -
optargs
Easily create macros for functions with optional arguments
-
rustils
Utilities for rust
-
zkp-macros-lib
Library of procedural macros implemented using
proc_macro2 -
impl-enum
Macro for generating methods on an enum that match on the enum and call the same method on each variant
-
bidir_iter
Bidirectional iterators
-
tupletools
Utility functions for tuples
-
regexm
A Rust macro for writing regex pattern matching
-
raise
yeet!all the things -
tch-tensor-like
Derive convenient methods for struct or enum of tch tensors
-
displaydoc-lite
Implement the Display trait using your standard doc comments
-
hypermod
Automatically build the module tree from the src/ dir
-
assert_ok
A macro that asserts a Result is Ok
-
unique-type
Unique and anonymous types generation utilities
-
atomic_macro
Attribute macros for generating AtomicXXX
-
lang_extension
Rust Lang Extension
-
event-observer
Implementation of observer pattern by rust
-
string-eyre
Convenience traits for dealing with errors that don’t want to eyre
-
flag-mast
Ergonomic Rust bit flags
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
itermap
Iterator tools for maps (
HashMap,BTreeMap, etc.) -
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
delegatemethod
Delegate method calls to a field
-
chain_linq
An implementation of .NET’s LINQ in rust as a declarative macro
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
fn_name
Macros that produce the name of the function they’re invoked within
-
match_any
Provides a declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
derive-for
Macro for defining structs using the same derive procedural macros
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
aether_primitives
Helpers for common SDR and signal generation operations
-
unwrap_or
Four easy unwrap Result and Option macros that allow for any inline-scoped code for things like return, continue, and break
-
error-chain-mini
error-chain for minimalist
-
ngram
Iterator adaptors for n-grams and k-skip-n-grams
-
type-variance
Marker traits for subtype variance
-
tailsome
Blanket traits providing
.into_ok(),.into_err(), and.into_some()for happier method chaining -
tapir
Adding tapping functionality to rust
-
project-uninit
Macros for safe references to and initialization of fields in MaybeUninit structs
-
reax
A reactivity system for Rust that infers dependencies between functions
-
breakable-block
A shim library for a stable implementation of what is proposed in RFC 2046
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
multindex
Index slices with multiple const indices/ranges
-
exhaust
Trait and derive macro for working with all possible values of a type (exhaustive enumeration)
-
timed
Macros to time function execution
-
control-flow
A hack to control control-flow outside closures
-
nova
Macro to derive newtypes with support for serde and sqlx
-
dbus-strings
Rust native implementation of different D-Bus string types
-
defer-lite
A lightweight high-performance implementation of Go’s defer statement
-
enhanced_enum
Enhanced Fieldless Enumerations and Associated Array Types
-
derive-debug-extras
More customisable #[derive(Debug)]
-
higher-order-closure
Allow function lifetime elision and explicit
for<'a>annotations on closures -
spectral
Fluent test assertions
-
zkp-error-utils
Assertion like macros for returning
Result::Err -
simple-logging
A simple logger for the log facade
-
singleton-manager
A programatical singleton manager
-
safelog
Conditionally suppress confidential information from logs
-
macro_pub
polyfill proc-macro for visibility scoped macros
-
quick_from
A derive macro for quickly implementing From on on enum variants that wrap other types
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
forward_ref
Rust’s forward_ref_* macros for easier implementation of operator overloading
-
destruct
Destruct structs and enums for simpler combinator implementation
-
entity_rust
Event driven CES framework for Rust with a macro DSL
-
typed_ids
Create unique identifiers for each type. This newtype approach helps to make illegal states unrepresentable by typing your unique ids.
-
clone_all
clone_all!(my,variables,with,long,names);
-
mox
Mockery Of X(ML): a JSX-alike syntax for the builder pattern
-
impl_ops
Macros for easy operator overloading
-
optfield
A macro that generates structs with optional fields
-
static-cond
Macro for performing comparisons during macro expansion
-
typename
Stable alternative to Rust’s type_name intrinsic
-
destruct-drop
Macro for dropping the fields of a struct or enum without dropping the container
-
sortby
adds convenient sort functions for Iterators
-
awred
A convenient derive macro for actix_web::ResponseError trait
-
bounded_types
Provides a type representing bounded integers, implemented using const generics
-
assert_approx_eq
assert approximately equal
-
validaten
Common validators for cryptocurrency, creditcards, domain, url, etc that can be used across projects
-
tynm
Returns type names in shorter form
-
libmw-macro
Library for constructing a pipeline of middleware functions
-
sum_error
Derive macros for fast summing of error types into error enum
-
aspect
An Aspect Toolkit for Rust
-
macro_lisp
Lisp-like DSL for Rust language
-
single_executor
Traits for concurrent primitives
-
inline_dyn
A container type for storing dynamically-sized types inline
-
collection_literals
Easy-to-use macros for initializing std::collections
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
iter_vals
On the fly iterator creation
-
variant_access_derive
Prodedural macros for deriving the VariantAccess traits
-
staticinit
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
one-of
Macro to represent a type that can be converted either
FromorTryIntothe given types -
cor_iter
Correlate of two iterators
-
require_unsafe_in_body
Make
unsafe fnstill requireunsafeblocks in the function’s body -
is-same
A trait for comparing object equality
-
qadapt-spin
Synchronization primitives based on spinning. They may contain data, are usable without
std, and static initializers are available -
bachue-auto_impl
Automatically implement traits for common smart pointers and closures
-
pfn
Provide fn_trait’s
call,call_mut, andcall_onceon Stable Rust -
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
quack
Duck typing traits
-
derivenum
macros intended for use on enums to reduce boilerplate / provide useful shortcuts
-
throttle_my_fn
Throttle your functions
-
endian_trait
A trait for Endianness conversions that can be implemented on most types
-
default-test
A default trait that can be used in tests
-
roopert_macro_common
Another object-oriented toolkit for Rust (common data)
-
typebitset
Type-level bitset implementation
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
enum_derive
This crate provides macros for deriving additional functionality for enums
-
mapcomp
Python-like list comprehensions for standard containers
-
xkcd_unreachable
A Rust macro xkcd_unreachable!() inspired by https://xkcd.com/2200/
-
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
collected
Summation, product, maximum and more special collectors for Rust iterators
-
overflower_support
A bunch of specialized traits + impls to allow automated overflow handling without type inference. Nightly only
-
pool
A pool of reusable values
-
asn1-cereal
ASN.1 and BER serialization
-
panicking
Provides a
std::thread::panickinganalog available in theno_stdcontext -
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
xpr
A general purpose generic expression template library
-
rev_slice
A newtype for operating on a reversed view of a slice
-
kv-derive-impl
Derive struct conversions from and to key-value vectors
-
plague
Parametrized tests tools
-
swahili-dsl
A Swahili-based DSL made for educational purposes
-
seymour-protocol
Client protocol for the seymour gemini feed aggregator
-
xplane_plugin
Provides types and a macro for creating X-Plane plugins
-
grange
create range numbers macro
-
nom-fields
Provides a single function-like macro that removes some boilerplate from a common pattern when using nom
-
cstr-argument
A trait for converting function arguments to null terminated strings
-
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…
-
captur
Macro to capture whole structs from disjoint fields in a closure
-
smart_buffer
A hybrid stack/heap buffer
-
throws
A macro for easy creation per-function errors
-
dyn_partial_eq
PartialEq macros for trait objects
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
specialize
Type specialization macros and helpers
-
multi-structs
Macro for generating a merged struct from multiple sub-structs
-
num_alias
simple macros to declare ‘type checked’ aliases for integers and floats
-
arraytools
A variety of helpful methods for working with fixed-size arrays
-
enum_variant_macros
Macros to generate From & TryFrom for enums
-
serde_type_name
lookup name of type for any struct or enum that derives serde Serialize
-
turbonone
Simple macro for calling functions with Option arguments
-
pinpoint
Crate for pinned references
-
polonius_workaround
Safe replacement for Polonius on stable Rust
-
cargo-verify
Prettier error messages for the verified crate
-
splop
Helper functions to determine the first/last repetition of something
-
discretionary
A tiny procedural macro to make all your struct fields optional
-
validated
The cumulative sibling of
ResultandEither -
nonmax
Numeric types that cannot hold maximum values
-
stable-pattern
Stable port of std::str::Pattern and friends
-
tuple-map
map methods for tuple
-
better_any
Type id and Any for non static types
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
enum-derive-2018
This crate provides macros for deriving additional functionality for enums
-
prange2
Parse numeric ranges for indexing
-
outcome
A Success/Failure type for rust
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
symm_impl
Attribute macro that automatically implements a symmetric trait
-
typesets
Enables generating subtypes and supertypes of a given type via derive macros
-
switch_statement
A simple switch statement macro
-
simple-counter
Macro for generating thread-local static counters. Useful for basic ID generation.
-
tyname
Retrieve type names during program execution on stable Rust
-
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
pariter
Parallel iterator processing
-
const-array-attrs
Attribute macros for const array
-
iter-python
Python generator expressions and ‘list’ comprehensions
-
compiler_error
Triggerable compiler error
-
lens-rs_derive
macro to derive lens for data type
-
integer-iterator
Add the ability to iterate over the digit of all primitive integer types. Also exposes the trait so one can implement it oneself.
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
into_ext
Extension trait for the “Into” trait, offering a method “.into_::()” to specify the target type of conversion
-
zkp-macros-impl
Implementation crate for
proc_macro_hack -
take-until
A take until extension for iterators
-
bitwise_reduce
Multiple arity bitwise functions
-
left-pad
Provides left-padding for strings
-
ternop
A tiny macro that implements a ternary operator for Rust
-
pin-project-internal
Implementation detail of the
pin-projectcrate -
yolo-block
Like a
tryblock, but automatically unwraps the result -
thiserror_core2
derive(Error) (no_std-enabled using core2)
-
ambience
Lightweight library for passing ambient parameters
-
errer
Flexible error management for Rust. An middle-ground between failure and SNAFU
-
winwrap
Rust-friendly Windows API wrappers
-
status
Error container
-
structview_derive
Custom derive for structview’s View trait
-
u16cstr
A macro for creating c-style u16 wide strings at compile time
-
spans
Split an iterator into contiguous spans
-
fix_fn
Macro to create recursive closures (similar to the Y combinator)
-
array-lit
Macros for array and
Vecliterals with superpowers -
byte-slice
Byte slice manipulation macros
-
repr-trait
Traits to represent Rust reprs
-
ownref
Provide the smart pointer type that bundles the data with its owner
-
convertable-errors
This crate defines an ergonomic macro for deriving From conversions for variants of Rust enums
-
ufcs
Helper trait to call free functions using method call syntax
-
rsmnl-linux
linux headers for rsmnl
-
magic_static
Safe, global singletons initialized at program start
-
trait-union
Stack-allocated trait objects
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
stringy
A tiny Rust crate for generating byte-sized enums that represent a fixed, ordered set of &str data
-
macro_macro
Macro templating library for DRYer structs
-
expect_macro
The expect! macro
-
funfun
Macros for working with closures
-
transitive_from
Helper macros for creating hierarchies of transitive
Fromimplementations -
list_builder
Python-like list comprehensions in Rust
-
identifiers
Utilities for working with rust identifiers and keywords
-
conform
Macro to transform struct string fields in place
-
mcurry
Macros for creating curried functions
-
arcmutex
A convenience library for working with
Arc<Mutex<T>>s -
defmac
A macro to define lambda-like macros inline
-
notosans
A simple crate providing several of Google’s Noto Sans true type fonts as slices of bytes
-
stackpin
Crate for data that should be pinned to the stack at the point of declaration
-
enum_variants
Deriving traits for C-like enums using macro 1.1
-
dsl_macros
Convenience macros that rewrites method calls inside a builder closure
-
elain
Set a type’s minimum alignment with const generics
-
any_ref
Creating a bundle that can carry an owner and a struct borrows it
-
poule
A pool of reusable values
-
proc-easy
Macros to make writing proc-macro crates easy
-
transaction
transaction abstraction library (a.k.a. transaction monad)
-
resources_package
Macro that allows you to package files inside your libraries or executables
-
sentry-error-chain
Sentry integration that allows capturing error-chain errors
-
lovm2_std
a lightweight virtual machine with a focus on simplicity and extendability
-
collections-fromstr
Derives FromStr for collection types like Vec or HashSet
-
stronghold-runtime
Runtime and allocation primitives for stronghold
-
byte_conv
Simple conversion traits to bytes
-
typemap-meta
A simple compile-time macro to create type-to-valup maps
-
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.
-
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:…
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
RustyEmitter
RustyEmitter is a basic implementation of a simple emitter. The module expose a Events trait with the on, off and emit methods, and a default implementation of that trait, called Emitter.
-
rust-iteratorcomprehensions
A comprehension syntax for iterators implemented as macros
-
structdoc
Extract structure and documentation from structs
-
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… -
char_combinator
An iterator to create all combination of a given char range
-
aoc-main
A macro which defines a handful main for the Advent of Code
-
pipeliner
Provides a nice interface for parallel programming with iterators
-
errloc_macros
Error location utility macros
-
general_tools
This crate offers many functions for many different types of operations, such as operations with strings, numbers, files, and more!
-
pre-proc-macro
Procedural marco implementations for pre
-
is_trait
Add a macro to check if a type implements a trait at runtime
-
thisctx
Easily create error with contexts
-
derive_builder_macro_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
cell-project
Safe interface for cell projection
-
adrop
Simple and fast dedicated thread drop
-
yui_internal
Internal functions, struct for derive in Yui
-
nes
New Error System for rust
-
ordered_iter
Ordered iterators
-
async_fn_traits
Trait synonyms for “Fn[…]”-trait bounds returning futures
-
conventus
Traits for assembling and disassembling items
-
dependent_ghost
An implementation of Matt Noonan’s ‘Ghosts of Departed Proofs’
-
mods
Simpler module declaration
-
tiny_fail
Provides simple Fail type
-
codespan-derive
derive(IntoDiagnostic) for easy codespan integration
-
gaclen_shader
Tweaked re-export of vulkano_shader! procedural macro
-
docgen
Rust library made for dynamically documenting Rust items created by a macro
-
protocol
Easy protocol definitions
-
byo-graphql
simple bring-your-own graphql client
-
proc_use
Semi-dynamic mod and use
-
type_at
Utility trait to index type of Rust tuples
-
path_semantics_std
A Rust type checked implementation of the standard dictionary of path semantics using constrained functions
-
koute/nes
An NES emulator written in Rust
-
trigram
Trigram-based string similarity for fuzzy matching
-
frunk_laws
frunk_laws contains laws for algebras declared in Frunk
-
constany_blank
Convert any function to constant
-
struct-variant
Minimal helper macro to generate an enum out of a list of structs
-
summon
A logic engine designed to magically give you what you ask for
-
static_assert_macro
Library implementation of so-called
static_assert -
plutonium
Tools to avoid unnecessary use of safe code
-
iroha
A tokenization Library for Rust
-
thin-slice
An owned slice that packs the slice storage into a single word when possible
-
float
Lightweight wrappers around primitive floating point types
-
collect_slice
Collect an iterator into a slice
-
concurrency_traits
Traits for concurrent primitives
-
eager
Crate for eager macro expansion
-
conditional
Provides a conditional! macro which lets you use the syntax of the conditional operator (also known as the ternary operator) in Rust
-
zhi_enum
derive macros to easily use enum
-
ezjs
ezjs is a simple and micro Javascript (ES5) engine is Rust
-
sorted
Provides compile time guarantees for sorted sequences
-
dev_bestia_url_utf8
Library for url utf8 encode/decode
-
frunk_proc_macros
Proc macros for Frunk
-
literal
Literals for Rust’s collections
-
from_as
Traits and derive macros to Read and write types that implement serde Serialize and deserialize to files
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
diesel_derives_traits
Traits for diesel_derives_extra
-
sub-array
Extract a sub-array out of an array
-
struct-pad
Padding types to enable memory layout optimizations
-
isnt
Inverted versions of boolean-valued stdlib functions
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
lucene_query_builder
A procmacro derive crate to generate lucene query builder for Rust structs :
-
endian-type
Type safe wrappers for types with a defined byte order
-
generator_extensions
Basic extensions to Generator types to bring parity with Iterators
-
breaktarget
Implementation of nonlocal breaks in Rust
-
vec_box
A single macro to create a vec of boxed elements, for trait objects
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
anyint
provides traits and structs for working with integers of any bit size
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
annotation-rs
Compile-time annotation parser for rust
-
erroneous
Minimalistic helper for using errors
-
unwrap_all
Unpack multiple levels of
Result<T, E>andOption<T>at once -
cartesian
QOL macro that creates the cartesian product of multiple iterators
-
snaptest
Dead simple snapshot testing
-
tap-trait
Inspect and mutate values without leaving the method chain
-
fn_chain
Helper macro/function to create function chaining
-
slice-diff-patch
Library crate providing utility functions for diff and patch of slices
-
appro-eq
Approximately equal traits and assertion
-
duplex
The Duplex trait: interactive streams
-
sugar
Rust syntax sugar collections
-
io-error
Simple and convenient macro for creating I/O errors
-
match-downcast
A set of downcasting matching Rust macros
-
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. -
deptypes
Dependent types
-
apply_attr
A syntax extension providing higher-order attributes to Rust
-
makeit
Compile-time checked Builder pattern
derivemacro with zero-memory overhead -
syllogism-macro
Utilities to allow for some specialization using stable Rust
-
pub-iterator-type
Abstract an iterator implementation behind a struct tuple
-
cpp_map
A simple C++ std::map emulator
-
quixutils
Common helpers and utils
-
atomic_refcell_try
Threadsafe RefCell
-
bumpalo-herd
Support for bumpalo in scoped threads & rayon
-
wrap
Generic function wrapping
-
lifelink
Erase covariant lifetime parameters from anything, with generic associated types
-
taken
Macros for taking ownership, staring Liam Neeson
-
printf-rs
printf c language like
-
boulder
Like a builder, but heavier
-
pure_decimal
A decimal type with no NaN and Infinity
-
phantom-enum
A simple macro library for creating phantom enums
-
shellexpand-fork
Shell-like expansions in strings
-
newtype-enum
Traits to convert between enums and their variant types
-
rocket_failure
Failure like error handling for rocket
-
result-inspect
Adds the missing Result::inspect() function
-
eliza_error
“Times are bad. Children no longer obey their parents, and everyone is writing an error handling library.” — Cicero
-
new_type
Improve the semantics and correctness of your code by embracing newtypes
-
path-ext
Provide convenient methods for path operations
-
dto_derive
Derive for automatic mapping DTOs to Entities and vice versa
-
clone-into-box
A library for cloning trait objects
-
lifted
Higher-kinded types in Rust
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
disjoint-borrow
Disjoint mutable borrows of slices
-
zkp-criterion-utils
Criterion helpers to benchmark over size and number of processors
-
unify
Trait-based equality constraint for Rust
-
map_for
A Rust macro that implements for comprehensions similar to Scala’s
-
collect_array
Allows for collecting an Iterator into an exactly sized array
-
zkp-logging-allocator
Wrapper around the system allocator that logs large allocations
-
piston_meta_search
A search API for piston_meta
-
block_effects
A macro to chain block effects
-
boar
Flexible clone on write smart pointers with Borrowed, Owned, Arc, Rc and Static variants. Like std’s Cow without the ToOwned requirement and additional Rc, Arc or Static variants
-
predicate
Use enum to predicate something, support & and | operator
-
jenner
Tools for working with generators to work with both iterators and streams
-
anyerror
A type of any error for transport
-
rand_macros
#[derive]-like functionality for therand::Randtrait -
err_tools
Helper traits and functions for building errors in rust
-
lifetime
Traits and derive macros to change the lifetime of a type, allowing efficient reuse of your stucts or enums with any lifetime requirement
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
multi-eq
Macros for creating custom equality trait derives
-
deferrer
defer! macro for deferring functions
-
negate
Attribute macro that generates negated versions of functions that return booleans
-
srcerr
User friendly errors from source data
-
enum_properties
A macro for declaring static properties on enum variants
-
structural
Field accessor traits,and emulation of structural types
-
pad-adapter
A utility crate that provides pad adapter
-
tilde
Using ~ to provide syntax sugar for Rust
-
bind_match
Convenience macro similar to
matches!but binds to variables in the pattern and returns anOptionof the result -
reduce
Fold an iterator without an initial value
-
arrutil
Functions for manipulating arrays from slices
-
to_vec
convenient to_vec, to_set and to_map methods on iterators
-
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… -
ext-trait
Annotation to easily define ad-hoc / one-shot extension traits
-
check
Convenience assert!-like macros which return instead of panicking
-
error-context
Methods and types that help with adding additional context information to error types
-
whiteout
Provides macros that erase the type of any value into an impl Trait for a given trait
-
moveslice
A one-function crate to move chunks in a slice around
-
polymorph
A set of utilities to better enable polymorphic behavior in Rust
-
async_t
zero-cost async-traits
-
anon
Anonymous struct macro
-
desugar-impl
Sugar for less explicit generics in structs, enums, and union declarations
-
byteorder_slice
Byteorder like crate for &[u8]
-
rc-borrow
Borrowed forms of Rc and Arc
-
bail-out
Macros to help keep code clean for validations and error handling
-
lambek
Type-Level Programming in Rust
-
tagged_ptr
A safe tagged union pointer datastructure for x64
-
soft
Provides soft, non-panicking assertions
-
bystr
macro to create compile-time, fixed length, byte array from a string
-
peek-nth
An iterator adapter that allows you to efficiently peek the nth item of an iterator
-
const-if
This crate adds if-else expression into your constant functions
-
almost
A crate for comparing floating point numbers
-
captures
Provides macros to express more powerful closure captures
-
rubber_duck
Enables building functions that can be called with named arg syntax
-
traitcast_core
Cast between dynamic trait objects
-
aspect-weave
An Aspect Toolkit for Rust
-
frust
Functional Programming in Rust
-
mic
Facilitates answering to competitive programming problems
-
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
format-macro
Format procedural macro
-
enum-utils-from-str
Code generation for mapping from strings to arbitrary values
-
streams-rs
OCaml like streams for Russt
-
into-owned
Provides a trait for associating a type with its owned variant
-
named
Procedural macro which allows you to produce functions which can be called with named arguments, optionally with default values
-
kvfmt
A helper macro for stringifying variables into a key=value style string
-
rvs-parser
Parser for Rvs - A library for defining and evaluating random variables using a simple DSL
-
tuple
Element-wise operations on tuples
-
spidermeme
Traits to test for type equality and type inequality
-
tramp
Trampoline for recursive functions, with support for mutual recursion
-
append
Trait for adding to collections
-
scanio
Simple console input macros with the goal of being implemented in the standard library
-
parameterized_test
A macro to support providing arguments to test functions
-
mownstr
Maybe Owned String
-
generic
Higher level serialization of rust values to rust values
-
rustollens
A small and experimental library with a type-level representation of booleans with companion connectives for compile-time sort-of fun with logic
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
random-number-macro-impl
Generate random numbers quickly
-
enum-primitive-derive-nostd
enum_primitive implementation using procedural macros to have a custom derive
-
errors_rust
Just a simple library for error mapping
-
numeric_cast
safe cast between numbers
-
extrude
A macro for unwrapping an enum value into an Option
-
tor-error
Provides the unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
powerset-enum
A poor man’s anonymous enum
-
fast-map
Map-like structs
-
cbox
C pointer boxing, for when working with ffi
-
with-macro
Syntactic sugar for calling methods
-
scopefunc
A trait defining kotlin-like scope functions
-
shippai
failure in other languages
-
result-ext
Extends
Resultwith additional operations -
nan-preserving-float
(Mostly) drop-in replacement for floats that preserves the signalling bit in NaNs under conversions and unary operations
-
roopert_macro_root
Another object-oriented toolkit for Rust (macro)
-
rvs_derive
A helper macros implementation for Value Classes in Rust
-
input-stream
IO streams similar to C++’s streams
-
option-ext
Extends
Optionwith additional operations -
capture
A macro for adding explicit capture clauses to a (closure-) expression
-
fast_fmt
This crate provides faster, more flexible and more correct alternative to core::fmt
-
dynamic
A dyanmically typed value with fast downcasting
-
array_iter_tools
Modify simple arrays
-
arrcat
Array concatenation
-
startup
Tiny (no dependency, no proc macro) way to run some code before main
-
monad
Stackless monads in Rust
-
iter_from_closure
Iterator<Item = Item> from FnMut() -> Option
-
apply_method
Allows you to apply any function given as a parameter to the object
-
same-types
Ensure that two types are the same
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
error-type
Provides a macro for constructing unifying error types
-
ternary-rs
A Rust library for emulating the ternary operator from C/C++ (among other languages)
-
tuple-arity
Get the arity (number of elements) of tuple types with 0-12 elements
-
entangled
A simple fork-join task executor
-
drop_ok
.drop_oksyntax sugar forResult. It’s instead of.map(|_|()). -
macro-vis
Attribute for defining
macro_rules!macros with proper visibility and scoping -
type_eq
Tiny utils for type-level constraints and inference
-
dont_panic
panic!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won’t panic.
-
take-if
A tiny utility for conditionally taking the contents of an option
-
async-anyhow-logger
An easy crate for catching anyhow errors from an asynchronous function, and passing them to your logger
-
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
-
chained_iter
Provides a small helper macro for creating iterators out of values without allocation
-
ndless-static-vars
Rust library for storing static, program-wide parameters for Ndless
-
with_locals-proc_macros
TODO!
-
partial_derive
makes all the properties of a struct type an optional property
-
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
char-device
Character Device I/O
-
derive_from
A simple derive(From) macro
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
text-block-macros
Create a multiline string literal
-
checked_array
A checked API for array types
-
arc-io-error
A version of std::io::Error implemented on top of Arc instead of Box, making it cloneable
-
field_types
Some derive macros for deriving enums, corresponding to the fields of structs
-
typemap-meta-derive
A simple compile-time macro to create type-to-valup maps, derive macro crate
-
vptr-macros
Procedural macros for the
vptrcrate -
soft_assert
Non-panicking assertions
-
check_keyword
A trait for String-like types to check if it is a reserved keyword and convert it to a safe non-keyword if so
-
unique
ptr::Unique for stable Rust
-
iflet
Provides a macro to chain multiple patterns in an
if letrather than nesting them -
enum_to_enum
Derives possibly effectful conversions between enums
-
stable_borrow
A marker trait indicating that borrows are address-stable
-
list-any
Type erased slices and Vecs
-
assert-parse-core
The core for ‘assert-parse’
-
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.
-
internship
Interned string and more
-
opera
Marker types that are easy to understand
-
underscore_args
Macro for underscore named argument syntax, aka Dyon
-
process-results
process-results is a crate that provides the same functionality provided by Itertools::process_results. It helps you process an iterator of results, with a more ergonomic and composable interface.
-
destruct-drop-derive
Actual derive macro for destruct-drop
-
async_fn
Collection of helper annotations and macros for concise and yet explicit
async fnsignatures -
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
rjdebounce
Debouncing function utility
-
persian-rug_derive
Framework for bringing together disparate objects with inconvenient relationships
-
builder_macro
A macro to generate structs and a corresponding builder
-
existential
Existential quantification over lifetimes
-
unit-proc
Procedual macros for physical quantities
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
newtype_derive
This crate provides macros for deriving common traits for newtype structures
-
curry-macro
Have fun currying using Rust’s native closure syntax
-
tylar
Type-Level Arithmetic in Rust
-
type-uuid
Safe, stable IDs for Rust types
-
integer-atomics
This crate allows you to compile code that needs the unstable integer atomics types (Atomic{U,I}{8,16,32,64}) with the stable compiler
-
from_as_file
Traits to Read and write types that implement serde Serialize and deserialize to files
-
dddk_macro
Derive macro lib for dddk_core
-
byte-array-struct
Macro to create a byte-array backed struct
-
eieio
Error Implementing
Eq + Clonereplacingstd::io::Error -
multizip
Zip 3, 4, 5 or more Rust iterators
-
fmt_adapter
Provides newtype adaptors to and from any formatting trait
-
io-read-line-prototype
Prototype for io::read_line
-
into_inner_drop
A helper library for implementing into_inner method for drop types safely
-
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…
-
drop_some
.drop_somesyntax sugar forOption. It’s instead of.map(|_|()). -
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
components-arena-traits
Does not intend for direct use
-
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
-
dangerous_option
This crate provides DangerousOption - a type similar to ! in Swift language. It’s basically an Option which panics if dereferenced while containing None. no_std compatible.
-
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…
-
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.
-
on_demand
A macro to generate aux macros for on-demand usage
-
try_from
TryFrom and TryInto traits for failable conversions that return a Result
-
cex_derive
Macros for checked exception simulation
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
validated_newtype
Simple newtypes with checked predicates (primarily for serde)
-
detach
helper type for being able to detach/reatach a member item
-
real-proc
proc macros for floating point constants
-
multiref
Multireferences: a safe way to do [&T] -> &[T]
-
cast_trait_object_macros
Cast between trait objects using only safe Rust
-
dispose-derive
Derive macro for the dispose crate
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
sconcat
String concatenation
-
boolinator
Provides the Boolinator trait, which lets you use Option and Result-style combinators with bools
-
bounded-static-derive
Macro to derive ToBoundedStatic and IntoBoundedStatic traits
-
loosen_map
Calls a function with self
-
enumeraties
Static properties on enum variants
-
zkp-mmap-vec
Replacement for
Vecthat uses file-backed storage -
into-result
A simple convenience trait for converting something into a
ResultorOption -
tagged-pointer-as-enum
A set of structs, traits and macros to implement tagged pointers
-
validated-slice
Helper macros to implement std traits for custom validated slice types
-
nova-impl
Implementation for nova 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
-
string_map
Create a record to store any type of value
-
namable_closures
Provides types and macros to create namable closure types
-
boulder_derive
Macros for the boulder crate
-
refview
Get a reference view of some fields into a struct
-
scoped-callback
Register scoped functions with local references to ’static lifetime callbacks in a safe manner
-
join_impl
Implementation of the
join!macro -
fast_new_type
A proc_macro attribute to implement common traits for a custom type wrapping other
-
iroha-internal
Internal functions, struct for Iroha
-
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. -
nearly_eq
Nearly(Approximately) equal traits and assertion
-
stringly_conversions
A crate helping to convert to/from various representations of strings
-
read-from
Supplies the ReadFrom and WriteTo traits
-
newtype-derive-2018
This crate provides macros for deriving common traits for newtype structures
-
assert_into
For when writing .try_into().unwrap() feels too long
-
join_to_string
Join a list of items to string/buffer
-
is-impl
Rust macro to check that a type conforms to an impl
-
layered-io
I/O traits extending Read and Write
-
better-as
Explicit type casting
-
helper_fn
A macro to create closure-like helper functions
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
const_env_impl--value
Configure const and static items by environment variables
-
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…
-
dir-assert
Assertion to compare directories recursively
-
ref-portals
Safely use (stack) references outside their original scope
-
fool
Traits for interoperation of Boolean and sum types
-
mox-impl
Implementation for the mox! macro
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
format-core
Core format types
-
unstringify
Procedural macro implemention of the reverse operation of
stringify! -
subset
Various subsets of slice’s items that are able to iterate over references to selected items
-
stack-vec
Ad-hoc compile-time sized
Vec<T>like types on the stack -
tuple-conv
Allows converting tuples of one element to vectors
-
units
Units of Measure for Rust. Easy to use, type-safe and customizable.
-
tor-basic-utils
General helpers used by Tor
-
partialdebug
Derive Debug partially
-
type_at_derive
Provides the #[derive(TypeAt)] proc. macro.
-
bounded
Bounded numeric types
-
assert-cmp
Convenient assertion macros that print the failed expressions and their evaluated values
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
eso
Type machinery to build Cow-like containers
-
newtype_array
A macro to help implementing the standard derived traits on newtype arrays
-
typic
Type-safe transmutations between layout-compatible types
-
iterr
Combinators for dealing with iterators of
Results -
unborrow
Macro for calling a &mut self method with transient &-borrows of self in the parameters
-
rvs
A library for defining and evaluating random variables using a simple DSL
-
boow
Borrow Or oWnedsmart pointer. Alternative to Cow. -
respector
An extension to add inspect method to Option and Result types
-
bointer
Assorted pointer-related utilities
-
assert-impl
Macro for static assert types implement a trait or not
-
expand
Macro to expand byte string and string literals
-
enumx_derive
Macros for ad-hoc enum extension
-
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
try-traits
Alternatives to std lib traits that can fail
-
stringer
An easy way to turn an Unsafe *const c_char into a Rust String type and return a pointer
-
libsugar
libsugar provides syntactic sugar in the form of a library
-
const-enum-tools
Trait definitions for working with enums at compile time using macros
-
default-conversion
A derive macro to automatic implement conversions between similar structs
-
as_tuple
View any struct as a tuple! ✨
-
once_self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
io-streams
Unbuffered and unlocked I/O streams
-
write-only
References/slices that provide write-access, but no read-access
-
rubbl_core
Core types and traits for Rubbl, a Rust package for astrophysics
-
try_into_opt
A macro like try!, but turns a Result into an Option, mainly for use in a filter_map
-
amplify_derive_helpers
Amplifying Rust language capabilities: helper functions for creating proc macro libraries