-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
thiserror
derive(Error)
-
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
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
synstructure
Helper methods and macros for custom derives
-
once_cell
Single assignment cells and lazy values
-
float-cmp
Floating point approximate comparison traits
-
derivative
A set of alternative
deriveattributes for Rust -
anyhow
Flexible concrete Error type built on std::error::Error
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
annotate-snippets
Library for building code annotations
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
lazycell
A library providing a lazily filled Cell struct
-
enumflags2
Enum-based bit flags
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
typed-builder
Compile-time type-checked builder derive
-
geo-types
Geospatial primitive data types
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
err-derive
Derive macro for
std::error::Error -
owning_ref
A library for creating references that carry their owner with them
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
quick-error
A macro which makes error types pleasant to write
-
snafu
An ergonomic error handling library
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
indoc
Indented document literals
-
simple-error
A simple error type backed by a string
-
tap
Generic extensions for tapping values in Rust
-
if_chain
Macro for writing nested
if letexpressions -
educe
This crate provides procedural macros to help you implement Rust-built-in traits quickly
-
conv
This crate provides a number of conversion traits with more specific semantics than those provided by ‘as’ or ‘From’/‘Into’
-
noisy_float
Contains floating point types that panic if they are set to an illegal value, such as NaN
-
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… -
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
sugars
An useful collection of macros to make tasks easier
-
maybe-owned
provides a
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
displaydoc
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
buffered-reader
A super-powered Reader
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
rust_info
Extracts the current rust compiler information
-
hex-literal
Procedural macro for converting hexadecimal string to byte array at compile time
-
validator_types
Basic type for validator and validator_derive
-
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…
-
safe-transmute
A safeguarded transmute() for Rust
-
auto_enums
A library for to allow multiple return types by automatically generated enum
-
retain_mut
Provide retain_mut method that has the same functionality as retain but gives mutable borrow to the predicate
-
tt-call
Token tree calling convention
-
unchecked_unwrap
Adds an unchecked version of
unwrap()andexpect()to Option and Result -
scroll_derive
A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate
-
frunk
Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
amethyst_error
Internal error handling for Amethyst
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
drop_bomb
A runtime guard for implementing linear types
-
uninit
A collection of tools for a safer usage of uninitialized memory
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
funty
Trait generalization over the primitive types
-
evcxr_repl
A REPL for Rust
-
semval
Semantic validation
-
take_mut
Take a T from a &mut T temporarily
-
advent-of-code
Solutions to Advent of Code
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
const-random
Provides compile time random number generation
-
amplify_derive
Amplifying Rust language capabilities: derive macros for the ‘amplify’ library
-
derive_deref
Adds
#[derive(Deref)]and#[derive(DerefMut)] -
gumdrop
Option parser with custom derive support
-
k8-client
Core Kubernetes metadata traits
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
batch_oper
batch_oper provides some batch operation macro for some operations
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
smart-default
Rust custom-derive macro for Default with more control on the fields
-
rental
A macro to generate safe self-referential structs, plus premade types for common use cases
-
failsafe
A circuit breaker implementation
-
unroll
An attribute-like procedural macro for unrolling for loops
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
tynm
Returns type names in shorter form
-
with_locals
Function attribute to return references to locals by using CPS
-
filters
Build filters/predicates with the builder pattern
-
tokenlock
Send-able cell type whose contents can be accessed only via an inforgeable token
-
enum-iterator
Tools to iterate over the variants of a field-less enum
-
mode
A behavioral state machine library written in Rust
-
structview
Viewing binary data as high-level data structures, safely
-
float-ord
A total ordering for floating-point numbers
-
arraygen
Derive macro for generating arrays from struct fields
-
predicates-core
An API for boolean-valued predicate functions
-
pin-utils
Utilities for pinning
-
intertrait
Allow for inter-trait casting
-
chainerror
Make chaining errors easy
-
impls
Determine if a type implements a logical trait expression
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
error-rules
Archived! Error handling without pain
-
shrinkwraprs
Auto-derive for Rust conversion traits – make working with newtypes a breeze
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
palette_derive
Automatically implement traits from the palette crate
-
cast_trait_object
Cast between trait objects using only safe Rust
-
anomaly
Error context library with support for type-erased sources and backtraces
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
problem
Error handling for command line applications or prototypes
-
try_match
An expression macro that does pattern matching and returns the result in
Result -
lazy_format
A utility crate for lazily formatting values for later
-
cstr
Macro for building static CStr reference
-
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
-
macro-attr-2018
This crate provides the
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
lazy-static-include
This crate provides
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
fstrings
Python3 fstring interpolation in Rust
-
fehler
A library for error-handling syntax in Rust
-
mox
Mockery Of X(ML): a JSX-alike syntax for the builder pattern
-
concat-with
Extend the function of the
concat!macro instd -
tylift
Lift enum variants to the type-level
-
wrapped-vec
Macro for generating wrapped Vec types and associated boilerplate
-
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 -
serde_str_helpers
Helpers for using serde with strings
-
chalk-derive
A helper crate for use by chalk crates for
derivemacros -
frunk_proc_macros
Proc macros for Frunk
-
concat-idents
Allows concatenating multiple identifiers and using them everywhere
-
xladd-derive
A simple macro that helps write Excel UDF functions in Rust
-
thiserror-impl
Implementation detail of the
thiserrorcrate -
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
tuples
Provides many useful tools related to tuples
-
aspect-weave
An Aspect Toolkit for Rust
-
yui_internal
Internal functions, struct for derive in Yui
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
illicit
An implicit thread-local environment which is indexed by type
-
thread-scoped-ref
A library that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
displaythis
derive(Display)
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
partial_function
A clean way to define function as a set of subfunctions where each has defined start and end bounds
-
abi_stable_derive
Implementation detail of abi_stable
-
bounded-integer
Bounded integers
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
extend
Create extensions for types you don’t own with extension traits but without the boilerplate
-
bool_ext
A crate which defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
event-listener-primitives
Low-level primitive for building Node.js-like event listeners
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
static_assert_macro
Library implementation of so-called
static_assert -
unzip-n
Procedural macro to generate
unzipfor iterators over n-sized tuples -
hado
Monadic do notation using a macro
-
compound-error
Compound errors with flat hierarchy
-
enum-as-inner
A proc-macro for deriving inner field accessor functions on enums
-
eventually
Crate for using Event Sourcing in Rust applications
-
enumx
Ad-hoc enum extension
-
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…
-
secp256k1-zkp-sys
FFI for
libsecp256k1-zkplibrary -
blanket
A simple macro to derive blanket implementations for your traits
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
error_def
A Rust syntax extension for generating error-handling boilerplate code
-
cex
Checked exception simulation
-
detach
helper type for being able to detach/reatach a member item
-
progress-streams
Progress callbacks for types which implement Read/Write
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
str-macro
The str!() macro, similar to vec![] but for strings
-
result-like
Option/Result-like monad interface for your own enum
-
trackable_derive
Custom derive for
trackablecrate -
iter-read
A Read implementation for iterators over u8 and related types
-
current
A library for setting current values for stack scope, such as application structure
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
components-arena
Simple library for creating complex domain-specific self-referential data structures
-
lazy-init
Lazy initialization
-
dynerr
Macros for dynamic error handling
-
riker-patterns
A collection of common actor patterns for Riker
-
require_unsafe_in_body
Make
unsafe fnstill requireunsafeblocks in the function’s body -
cryo
Extend the lifetime of a reference. Safely.
-
rsb_derive
An opinionated macros implementation for Rust struct builder pattern
-
frunk_laws
frunk_laws contains laws for algebras declared in Frunk
-
advancedresearch-asi_core0
An agent architecture candidate core for Artificial Super Intelligence (ASI)
-
enum_derive
This crate provides macros for deriving additional functionality for enums
-
match_any
Provides a declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
once
This crate provides an assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
cast
Ergonomic, checked cast functions for primitive types
-
simple-logging
A simple logger for the log facade
-
butcher
An easy way to interact with structs and enums wrapped in Cows
-
by_address
Wrapper for comparing and hashing pointers by address
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
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…
-
enum-kinds
Generate enums with matching variants but without any of the associated data
-
yui
An attribute reader generator for Rust
-
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
-
multindex
Index slices with multiple const indices/ranges
-
stdext
Extensions for the Rust standard library structures
-
chalk-macros
Macros for Chalk
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
hdf5-derive
Derive macro for HDF5 structs and enums
-
reduce
Fold an iterator without an initial value
-
once_self_cell
Experimental, safe-to-use proc-macro-free self-referential structs in stable Rust
-
trait_eval
We all know Rust’s trait system is Turing complete, so tell me, why aren’t we exploiting this???
-
derive_di
This crate is realized the dependency injection pattern
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
read-restrict
Restrict the number of bytes read from a reader
-
partial_application
partial function application via the partial! macro
-
tryhard
Easily retry futures
-
zkp-macros-decl
Procedural macros
-
derive-try-from-primitive
Custom derive a try_from method for primitive to enum conversions
-
aoc-main
A macro which defines a handful main for the Advent of Code
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
repeated
Allows you to repeat a block of code a number of times
-
quick-error2
A macro which makes error types pleasant to write
-
assert_approx_eq
assert approximately equal
-
drop_ok
.drop_oksyntax sugar forResult. It’s instead of.map(|_|()). -
copy_from_str
An extension trait to copy a string into another string
-
easy-error
Simple error utilities
-
format
A utility crate to make it easier to work with the formatter
-
merge
Merge multiple values into one
-
derive_builder_core
Internal helper library for the derive_builder crate
-
grouping_by
A simple library which allows the user to group an iterator by various ways
-
iter-progress
Calculate progress of your iterators
-
opaque_typedef_macros
Supports defining opaque typedefs
-
cute
A macro for Python-esque comprehensions
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
parse-display-derive
Procedural macro to implement Display and FromStr using common settings
-
reax
A reactivity system for Rust that infers dependencies between functions
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
zkp-macros-lib
Library of procedural macros implemented using
proc_macro2 -
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… -
gtmpl_derive
Derive for gtmpl_value
-
ad-hoc-iter
Ad-hoc exact size owning iterator macro and other optional utils
-
throw
Efficiently add statically-calculated stack traces to errors
-
enum-unitary
Trait and macro for unitary enums
-
lifted
Higher-kinded types in Rust
-
annotation-rs-beta
Compile-time annotation parser for rust
-
dyn-context
Non-owning service provider pattern implementation
-
inner
The inner! macro descends into an enum variant. It’s more flexible than try!() and unwrap(), and it works with your enum, too!
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
iterslide
A “sliding window” iterator
-
bitwrap_derive
derive for bitwrap
-
flag-mast-derive
Ergonomic Rust bit flags
-
as_derive_utils
private derive utilities used by abi_stable and structural
-
random-number
Generate random numbers quickly
-
structural
Field accessor traits,and emulation of structural types
-
num_enum_derive
Internal implementation details for ::num_enum (Procedural macros to make inter-operation between primitives and enums easier)
-
morphism
A structure for suspended closure composition in Rust
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
unique-type-id-derive
A unique id proc-macro generator for types
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
impl-enum
Macro for generating methods on an enum that match on the enum and call the same method on each variant
-
timed
Macros to time function execution
-
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
-
apply_method
Allows you to apply any function given as a parameter to the object
-
cargo-verify
Prettier error messages for the verified crate
-
zkp-criterion-utils
Criterion helpers to benchmark over size and number of processors
-
lambda_runtime_errors_derive
Rust runtime errors derive for AWS Lambda
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
fix_me
A very simple macro that lets you write temporary code that WILL NOT build in release mode
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
spez
Macro to specialize on the type of an expression
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
ff_derive
Procedural macro library used to build custom prime field implementations
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
mitochondria
Mitochondria is the powerhouse of the
Cell -
geo-postgis
Conversion between
geo-typesandpostgistypes -
noship
Noship is a macro that acts similar as todo! but will throw a compilation error when compiled on release profile
-
py-comp
A macro implementing a Python-like generator expression
-
named-block
Macro implementing early-exit-from-any-block
-
ambassador
Trait implementation delegation via procedural macros
-
enum_set2
A bit-set indexed by enum variants
-
error-code
Alternative Error for Rust
-
ref-map
Helper trait for Option and Result to map references
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
rustils
Utilities for rust
-
market
Infrastructure for producers and consumers
-
macro_machine
State machine generator using macros
-
boxfnonce
safe FnOnce boxing for rust stable
-
aerosol
Dependency injection with compile-time guarantees
-
mac
A collection of great and ubiqutitous macros
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the relative difference
-
edisp
Dispatch-on-collect for Rust enums
-
typename
Stable alternative to Rust’s type_name intrinsic
-
structview_derive
Custom derive for structview’s View trait
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
one-of
Macro to represent a type that can be converted either
FromorIntothe given types -
gpg-error
Libgpg-error bindings for Rust
-
incomplete
Provides incomplete!(), a compile-time checked version of unimplemented!()
-
sealed
Macro for sealing traits and structures
-
default-test
A default trait that can be used in tests
-
tia
tia; trait, impl, accessors | automatic
-
moveslice
A one-function crate to move chunks in a slice around
-
type-variance
Marker traits for subtype variance
-
butcher_proc_macro
Procedural macros for butcher
-
kinder
Kinder is a small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
closure
A macro for capturing variables on a per variable basis
-
tupletools
Utility functions for tuples
-
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
fix_fn
Macro to create recursive closures (similar to the Y combinator)
-
typemap_rev
A hashmap, but stores types as keys
-
switch_statement
A simple switch statement macro
-
reinterpret
Low level utility functions to reinterpret arrays of data
-
ff_derive_ce
Procedural macro library used to build custom prime field implementations
-
indoc-impl
Indented document literals
-
ndless-static-vars
Rust library for storing static, program-wide parameters for Ndless
-
rjdebounce
Debouncing function utility
-
ffi_helpers
A crate to help make working with FFI easier
-
direction
Representations of directions
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
generics
Provides macros for parsing generics (with optional where clause) in
macro_rules! -
supercow
A generic way to accept general reference-like values without proliferating generics
-
cell-project
Safe interface for cell projection
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
trait-union
Stack-allocated trait objects
-
single
Provides the Single trait for extracting the element from a single-element iterator
-
bind_match
Convenience macro similar to
matches!but binds to variables in the pattern and returns anOptionof the result -
machine
State machine utilities
-
conventus
Traits for assembling and disassembling items
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
sortby
adds convenient sort functions for Iterators
-
idata
Small tools to reduce mutability
-
srcerr
User friendly errors from source data
-
rust-fsm-dsl
Macros for rust-fsm DSL
-
try_from
TryFrom and TryInto traits for failable conversions that return a Result
-
file
For Rust 1.25 and older. 1-liner convenience functions for reading and writing files
-
aspect
An Aspect Toolkit for Rust
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
rustollens
A small and experimental library with a type-level representation of booleans with companion connectives for compile-time sort-of fun with logic
-
nshare
Conversion between n-dimensional types in different Rust crates
-
eventmill_derive
Derive macros for convient implementation of some traits of the
eventmillcrate -
generator_extensions
Basic extensions to Generator types to bring parity with Iterators
-
zkp-mmap-vec
Replacement for
Vecthat uses file-backed storage -
mdo
Monadic do notation for rust using macro and duck typing
-
kwarg_macros
Keyword argument plugin
-
collate
Traits and a data structure to support collation and bisection
-
assert_into
For when writing .try_into().unwrap() feels too long
-
tapir
Adding tapping functionality to rust
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
status
Error container
-
resiter
Helper crate for handling iterators over result
-
lang_extension
Rust Lang Extension
-
cenum-derive
A rust derive macro for C-style primitive enums
-
failure_without_backtrace
Experimental error handling abstraction
-
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
-
enum-lexer
A proc_macro lexer generator. using
enum-like syntax. -
tuple-arity
Get the arity (number of elements) of tuple types with 0-12 elements
-
range-split
Utilities for splitting sequences with range parameters
-
fool
Traits for interoperation of Boolean and sum types
-
repr-trait
Traits to represent Rust reprs
-
transitive_from
Helper macros for creating hierarchies of transitive
Fromimplementations -
default-conversion
A derive macro to automatic implement conversions between similar structs
-
enhanced_enum
Enhanced Fieldless Enumerations and Associated Array Types
-
drop_some
.drop_somesyntax sugar forOption. It’s instead of.map(|_|()). -
kaguya_rs
Functional Programming tools and ADTs
-
slugify
Macro for flexible slug generation
-
imex
A library/CLI for merging multiple iterators/files into one, with the optional use of an IMEx, or Iterator-Merging-Expression, for controlling the merge
-
dispose
A simple wrapper for values that must be consumed on drop
-
downcast
Trait for downcasting trait objects back to their original types
-
parameterized_test
A macro to support providing arguments to test functions
-
summon
A logic engine designed to magically give you what you ask for
-
coercible_errors
Zero-cost error handling for generic traits
-
col_macros
A collection of general purporse macros for construct distinct types of collections
-
enum_const_value
Providing const values for enums. Unit and enums with associated types are supported. Each variant gets a unique sequential value.
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
messages
A midground between channels and actors
-
miniserde-enum
Derive macros for miniserde on enums
-
derive_setters
Rust macro to automatically generates setter methods for a struct’s fields
-
hypospray
Lightweight dependency injection library
-
socketpair
Cross-platform socketpair functionality
-
gazebo
A collection of well-tested utilities
-
preflight
Input validation made easy with two simple macros
-
enumflags
Bitflags
-
lovm2_error
a lightweight virtual machine with a focus on simplicity and extendability
-
control-flow
A hack to control control-flow outside closures
-
libtor-derive
Internal #[derive] macros for libtor
-
read-from
Supplies the ReadFrom and WriteTo traits
-
ferrum-plugin
Lazily evaluated, order-independent plugins for extensible types
-
pin-project-internal
Implementation detail of the
pin-projectcrate -
ts-rs-macros
derive macro for ts-rs
-
ketos_derive
Derive traits for Ketos scripting language
-
ffishim_derive
Procedural macros for generating ffi-compatible stubs
-
bidir_iter
Bidirectional iterators
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
drop_guard
The drop_guard crate enables you to implement the Drop trait on any type. So you can run a closure on any value running out of scope
-
failchain
Ergonomic companion library for failure
-
bail-out
Macros to help keep code clean for validations and error handling
-
plain_enum
Mimicing Java’s enum::values() and EnumMap
-
default-ext
This library provides extension methods for the
Defaulttrait -
cfor
A macro that gives Rust a C-style for loop, with initialisation, condition and step. This correctly handles control-flow like continue and break.
-
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
-
whiteout
Provides macros that erase the type of any value into an impl Trait for a given trait
-
concat-string
Provides macros for concatenating string slices into owned strings
-
union_type
A proc macro to introduce union type into rust
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
cor_iter
Correlate of two iterators
-
cynic-proc-macros
Procedural macro crate for cynic - a GraphQL query builder & data mapper for Rust
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
fn_chain
Helper macro/function to create function chaining
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
apply-macro
An attribute macro to apply function-like macros
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
phantom-enum
A simple macro library for creating phantom enums
-
og_fmt
The original
format! -
read-byte-slice
An iterator over chunks of bytes as slices from an underlying reader
-
fourcc
Syntax extension to generate FourCCs (four-character code)
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
high_mem_utils
This crate provides a bunch of mem safe abstractions,some involving transmute
-
ref-portals
Safely use (stack) references outside their original scope
-
const_fn_assert
Assertions for const functions
-
borked
Simple and convienient error handling library for rust
-
io-error
Simple and convenient macro for creating I/O errors
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
iter-comprehensions
A library for iterator comprehensions
-
dodo-derive
Dodo persistence library derives
-
unwrap_all
Unpack multiple levels of
Result<T, E>andOption<T>at once -
exotic-iter
My personal collection of special-case iterator methods
-
en
The easiest numeric traits!
-
as-result
Traits for converting types which may be interpreted as or into a result
-
pstr
Global String Intern Pool
-
block_effects
A macro to chain block effects
-
error-chain-mini
error-chain for minimalist
-
is-same
A trait for comparing object equality
-
tyenum
Attribute macro for type enums
-
never
A stable version of the unstable never type (!)
-
namedarg_rustc_macro
namedarg main package
-
derive-aktor
Create actors in rust with a derive macro
-
safecast
Traits to define safe casting between types
-
cast_trait_object_macros
Cast between trait objects using only safe Rust
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
macro_lisp
Lisp-like DSL for Rust language
-
typic
Type-safe transmutations between layout-compatible types
-
type-uuid
Safe, stable IDs for Rust types
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
fragile
Provides wrapper types for sending non-send values to other threads
-
round
This crate provides utilities to round your floats with precision from 1 to 10
-
mapcomp
Python-like list comprehensions for standard containers
-
pushback-iter
An iterator with a push_back method that allows items to be pushed back onto the iterator
-
simpledi-rs
simpledi-rs, a simple and thread-safe dependency injection library
-
gaclen_shader
Tweaked re-export of vulkano_shader! procedural macro
-
trace-error
Extensions to Rust’s error system to automatically include backtraces
-
overload
Provides a macro to simplify operator overloading
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
outcome
A Success/Failure type for rust
-
enum_properties
A macro for declaring static properties on enum variants
-
annotation-rs
Compile-time annotation parser for rust
-
pre-proc-macro
Procedural marco implementations for pre
-
named_constants
Procedural macro makes enums behave like named constants in languages like C/C++ or C#
-
tyname
Retrieve type names during program execution on stable Rust
-
ambience
Lightweight library for passing ambient parameters
-
gen-iter
temporary util for creating iterators using generators
-
tealr_derive
The derive macro for tealr
-
bumpalo-herd
Support for bumpalo in scoped threads & rayon
-
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… -
as-is
An abstraction over ownership
-
dependent_ghost
An implementation of Matt Noonan’s ‘Ghosts of Departed Proofs’
-
sugar
Rust syntax sugar collections
-
enum-primitive-derive-nostd
enum_primitive implementation using procedural macros to have a custom derive
-
impl_ops
Macros for easy operator overloading
-
assert_that
Helper macros for use with boolean-valued predicate functions
-
lset
Data types describing linear sets
-
dcc-lsystem-derive
Macro implementation of #[derive(TurtleContainer)]
-
rusty_v8_helper_derive
A rust derive macro for rusty_v8_helper
-
error
A fancy error type for highly generic cases
-
endian-type
Type safe wrappers for types with a defined byte order
-
dsl_macros
Convenience macros that rewrites method calls inside a builder closure
-
isnt
Inverted versions of boolean-valued stdlib functions
-
arc-io-error
A version of std::io::Error implemented on top of Arc instead of Box, making it cloneable
-
xkcd_unreachable
A Rust macro xkcd_unreachable!() inspired by https://xkcd.com/2200/
-
rust-enum-derive
A simple library (and program) for generating rust enums and associated traits from text files
-
floatconv
Floating point conversion functions
-
delegatemethod
Delegate method calls to a field
-
sanitizer_macros
Derive macro for the sanitizer crate
-
anysafe
any safe
-
split_by
Split anything implementing Read trait by multiple sequences of bytes
-
sum_error
Derive macros for fast summing of error types into error enum
-
slice-ext
Useful extensions to slices and iterable types
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
gumdrop_derive
custom derive support for gumdrop
-
try_clone_derive
a crate wich add a derive TryClone macro for the TryClone Trait of the fallible_allocation crate
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
defmac
A macro to define lambda-like macros inline
-
partial_ref_derive
Derives for partial_ref
-
into-result
A simple convenience trait for converting something into a
ResultorOption -
fff_derive
Procedural macro library used to build custom prime field implementations
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
public
A crate used to make struct/union and its fields public
-
expect_macro
The expect! macro
-
throws
A macro for easy creation per-function errors
-
errors_rust
Just a simple library for error mapping
-
show
A
show!debugging macro to print expressions with the Show formatting trait, without writing out"{}",in theprintln!macro -
interleave
An arbitrary iterator interleaver for exhaustive consumption of iterators. Each iterator is guaranteed to be no more than a single next call behind any other iterator.
-
hash-db
Trait for hash-keyed databases
-
stackpin
Crate for data that should be pinned to the stack at the point of declaration
-
map_for
A Rust macro that implements for comprehensions similar to Scala’s
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
ufcs
Helper trait to call free functions using method call syntax
-
ama
Quasi-quotation system for designing procedural macros mixed with Rust code
-
minidom_ext
Extension traits for minidom::Element
-
specialize
Type specialization macros and helpers
-
boow
Borrow Or oWnedsmart pointer. Alternative to Cow. -
variantly
Derive helper methods for enum variants that are familiar from
std::option::Option&std::result::Resultsuch asunwrap_ororand_then -
errer
Flexible error management for Rust. An middle-ground between failure and SNAFU
-
dep-obj
Dependency object: effective reactive heterogeneous container
-
fast_new_type
A proc_macro attribute to implement common traits for a custom type wrapping other
-
derive-error-chain
A Macros 1.1 implementation of error-chain
-
endian_trait
A trait for Endianness conversions that can be implemented on most types
-
adante
A versatile, small options parser for use in the command line
-
inherent-pub
Mark methods in
impl Trait for Typeblocks inherent to the type -
list_builder
Python-like list comprehensions in Rust
-
enum_index
Trait and macros for extracting Enum variant index
-
resultit
Iterator adapters for iterators over results
-
ever-macro
Helper macro for
ever, which prints the build information with minimal boilerplate -
hirpdag_derive
Procedural macro for generating hirpdag boilerplate. See hirpdag crate.
-
spatialos-macro
Procmacro crate used to expand SpatialOS component and types created with spatialos-codegen
-
const-if
This crate adds if-else expression into your constant functions
-
struct-pad
Padding types to enable memory layout optimizations
-
flow_impl
Definition of an Implementation trait for flow functions, and a derive macro
-
concat_strs
Macro for quickly building a String from components
-
almost
A crate for comparing floating point numbers
-
iter_vals
On the fly iterator creation
-
extension-trait
Macro to declare extension traits
-
bytecheck_derive
Derive macro for bytecheck
-
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
-
frunk_proc_macro_helpers
Common internal functions for frunk’s proc macros
-
pinpoint
Crate for pinned references
-
piston_meta_search
A search API for piston_meta
-
bitwise_reduce
Multiple arity bitwise functions
-
yade
Yet Another Derive Error
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
simple_parse_derive
A derive macro that implements the simple_parse traits
-
ord_by_key
Provides a convenient macro for implementing Ord trait with logic specified in an inline expression
-
snaptest
Dead simple snapshot testing
-
envsubst
Variables substitution
-
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…
-
eager
Crate for eager macro expansion
-
multi-structs
Macro for generating a merged struct from multiple sub-structs
-
kg-diag-derive
Macro implementation for #[derive(Detail)]
-
named_type_derive
Derive support for named_type
-
into_inner_drop
A helper library for implementing into_inner method for drop types safely
-
system_error
A library for cross platform system errors
-
blunder
Dumb crate to make error handling easy
-
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
single-instance
A rust library for single instance application
-
eieio
Error Implementing
Eq + Clonereplacingstd::io::Error -
rlua-builders-derive
Derive helpers for struct/enum for rlua
-
splop
Helper functions to determine the first/last repetition of something
-
derive_builder_macro
Rust macro to automatically implement the builder pattern for arbitrary structs
-
remote-trait-object-macro
Macro that expands a Rust trait to a remote-trait-object service
-
either_trait_macro
An attribute-like macro to implement traits for Either
-
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:…
-
macro_macro
Macro templating library for DRYer structs
-
inline_dyn
A container type for storing dynamically-sized types inline
-
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…
-
unstd
A little utility belt
-
tagged_ptr
A safe tagged union pointer datastructure for x64
-
pl-lens-derive
Provides procedural
derivemacros that are used in conjuction with thepl-lenscrate -
size_hint
A very simple library to provide a size_hint for an iterator which does not provide it’s own
-
enum-iterator-derive
Procedural macro to iterate over the variants of a field-less enum
-
gazebo_derive
Derive macros for the Gazebo library
-
rev_slice
A newtype for operating on a reversed view of a slice
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
dto_derive
Derive for automatic mapping DTOs to Entities and vice versa
-
eliza_error
“Times are bad. Children no longer obey their parents, and everyone is writing an error handling library.” — Cicero
-
num_alias
simple macros to declare ‘type checked’ aliases for integers and floats
-
rubber_duck
Enables building functions that can be called with named arg syntax
-
nes
New Error System for rust
-
xplane_plugin
Provides types and a macro for creating X-Plane plugins
-
waitcell
A cell type containing a value which may not yet be available
-
ref_slice
Turn a reference into a slice of length one
-
mcurry
Macros for creating curried functions
-
fn-error-context
An attribute macro to add context to errors from a function
-
bitbuffer_derive
Reading bit sequences from a byte slice
-
sorted
Provides compile time guarantees for sorted sequences
-
compiler_error
Triggerable compiler error
-
cbox
C pointer boxing, for when working with ffi
-
with_locals-proc_macros
TODO!
-
try_into_opt
A macro like try!, but turns a Result into an Option, mainly for use in a filter_map
-
event_feed
Event systems implemented using event feeds
-
new_type
Improve the semantics and correctness of your code by embracing newtypes
-
anon
Anonymous struct macro
-
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
named
Procedural macro which allows you to produce functions which can be called with named arguments, optionally with default values
-
mods
Simpler module declaration
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
peek-poke-derive
Derive macro for peek-poke
-
vptr-macros
Procedural macros for the
vptrcrate -
koute/nes
An NES emulator written in Rust
-
peek-nth
An iterator adapter that allows you to efficiently peek the nth item of an iterator
-
fn_block
Crate defining macros for calling blocks or expressions in a closure
-
count_tts
A simple macro for counting tokens
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
array-lit
Macros for array and
Vecliterals with superpowers -
enum_variants
Deriving traits for C-like enums using macro 1.1
-
asserter-macros
New assertion library for rust
-
zkp-error-utils
Assertion like macros for returning
Result::Err -
diff_derive
A derive macro for implementing Diff on the diff-struct crate
-
expand
Macro to expand byte string and string literals
-
transaction
transaction abstraction library (a.k.a. transaction monad)
-
enum-methods
Generates methods for each enum variant
-
nifpga-type-macro
helper macro for nifpga datatype
-
variant_access_derive
Prodedural macros for deriving the VariantAccess traits
-
error-type
Provides a macro for constructing unifying error types
-
tiny_fail
Provides simple Fail type
-
compile_msg
A plugin for emitting errors, warnings and notes to the developer at compile time
-
disjoint-borrow
Disjoint mutable borrows of slices
-
interpolate_idents_gnzlbg_fork
Useable macro identifier concatenation plugin
-
doublysure
Using types to make sure that you’re sure, sure, and doubly sure
-
libgpg-error-sys
Raw bindings for libgpg-error
-
big_enum_set_derive
An internal helper crate for big_enum_set. Not public API.
-
derive_display_from_debug
A trivial Rust macro to derive the Display trait for any type with the Debug trait
-
enum-tryfrom
Error types and traits for use with enum-tryfrom-derive
-
clipboard2
clipboard2 is an improved version of clipboard-rs with better error handling and MIME type handling on Windows
-
rsor
Reusable slice of references
-
altbitflags
Macros to implement a struct which behave similar to bitflags
-
ternop
A tiny macro that implements a ternary operator for Rust
-
subset
Various subsets of slice’s items that are able to iterate over references to selected items
-
unify
Trait-based equality constraint for Rust
-
lexical_bool
parse arbitrary strings as bools
-
derive_state_machine_future
Custom derive implementation for the
state_machine_futurecrate. Use that crate instead of this one directly. -
internship
Interned string and more
-
rkyv_derive
Derive macro for rkyv
-
conform
Macro to transform struct string fields in place
-
telebot-derive
Getters and setters for the telebot library
-
never-type
This library is an alternative implementation of never type for stable rust
-
err_tools
Helper traits and functions for building errors in rust
-
common_failures
Helpers for ‘failure’, including io::Error wrappers with paths, quick_main!, display_causes_and_backtrace
-
clone-block
A very simple macro that clones a list of variables before calling an expression
-
boolenum
Derive From and Into for your boolean enums
-
enum_to_u8_slice_derive
A simple fork of enum_to_str_derive (by @DCjanus), convert enum to u8 slice ref
-
mkit-derive
Macros for distributed peer-to-peer applications
-
abscissa_generator
Template-based generator for creating new Abscissa applications
-
rustorm-derive
procedural macro code generator for rustorm
-
sconcat
String concatenation
-
enum_macro
Useful macro for enum
-
error_derive
Macros for deriving Error implementations through custom_derive!
-
enum_from_str
Enable deriving FromStr for enums
-
either_n
An Either enum with N variants
-
enum-derive-2018
This crate provides macros for deriving additional functionality for enums
-
validated-slice
Helper macros to implement std traits for custom validated slice types
-
tuplex
Rust tuple extension
-
dont_panic
panic!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won’t panic.
-
enum_for_matches
enum_for_matchesis a procedural macro that runs a match arm for each enum variant passed into it regardless of type -
const_fn
An attribute for easy generation of const functions with conditional compilations
-
macro-ob
a macro to inline rot13 to confuse IDEs
-
noise_fn
Some simple noise functions and traits to allow easy integration with your own
-
propane
a generator syntax experiment
-
coalesce
Combine disjoint types that share common traits
-
newtype_array
A macro to help implementing the standard derived traits on newtype arrays
-
conditional
Provides a conditional! macro which lets you use the syntax of the conditional operator (also known as the ternary operator) in Rust
-
derive-new
#[derive(new)]implements simple constructor functions for structs and enums -
rhs_first_assign
An attribute macro to hack compound assignment
-
quixutils
Common helpers and utils
-
with-macro
Syntactic sugar for calling methods
-
type_eq
Tiny utils for type-level constraints and inference
-
yolo-block
Like a
tryblock, but automatically unwraps the result -
dync-derive
Attribute macros for producing
dynccompatible traits -
limit_read
A companion to std::io::Take and an extension to std::io::BufRead to put a cap on methods that could potentionally read infinitely
-
mox-impl
Implementation for the mox! macro
-
fn_ops
Temporary traits for function operator overloading, pending the stabilization of
Fn,FnMut, andFnOnce -
slist-derive
Deriving traits for the slist crate
-
ccl_owning_ref
A library for creating references that carry their owner with them
-
clone-into-box
A library for cloning trait objects
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
multi-eq
Macros for creating custom equality trait derives
-
funfun
Macros for working with closures
-
breaktarget
Implementation of nonlocal breaks in Rust
-
ferrite-session
Session Types DSL for Rust
-
num-digitize
Converts integer of type N into Vec containing its digits
-
overflow-error
Common overflow error types
-
enum-to-types
Macro for generating pseudo-enums for type-level programming
-
pipeline-macro
A crate to create a pipeline in Rust
-
scoped
Run deferred closures at success, failure, or exit of a scope. Also supports cancelling them
-
taken
Macros for taking ownership, staring Liam Neeson
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
tense
n-rank tensor calculus
-
pub-iterator-type
Abstract an iterator implementation behind a struct tuple
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
enum_extract
Helper macros for extracting single enum variants of an enum
-
error-bender
Reserving crate name
-
tuple-map
map methods for tuple
-
tu-error
Utilities for Error
-
err_prop
Super simple ( and stupid ) floating point error propagation calculating type
-
take-until
A take until extension for iterators
-
he_di_internals
Common code for he_di crates
-
clone_all
clone_all!(my,variables,with,long,names);
-
tuple_list
Crate for macro-free variadic tuple metaprogramming
-
tilde
Using ~ to provide syntax sugar for Rust
-
enum_variant_type
Generates types for each enum variant and conversion trait impls
-
threadbound
Make any value Sync but only available on its original thread
-
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
-
as-any
provide the AsAny trait
-
wrapped_enum
Useful macro to wrap existing types in an enum (common use for quick error handling)
-
errloc_macros
Error location utility macros
-
underscore_args
Macro for underscore named argument syntax, aka Dyon
-
better-as
Explicit type casting
-
cenum
A rust derive macro for C-style primitive enums
-
take-if
A tiny utility for conditionally taking the contents of an option
-
dyn_safe
Take control of the Semver hazard of the
dynsafety of your traits! -
dedup_iter
Deduplicating iterator adapters
-
default-boxed-derive
Custom derive for default-boxed
-
wrap
Generic function wrapping
-
build_epoch
Macro for calculating the epoch at compile time
-
diff-enum
A macro library to help defining enum variants by their differences
-
rustup-find
Use rustup to automatically find and/or install the latest Rust version that supports all the currently installed components
-
type-layout-derive
Derive macro implementation for type-layout crate
-
enum_stream_codegen
A parser generator. This package handles code generation for the
enum_streammacro.” -
structbuilder_derive
Super simple macro to derive a builder trait for your struct
-
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
join_impl
Implementation of the
join!macro -
jane-eyre
By Currer Bell
-
exclusive
Place code into an exclusive context that won’t collide with another context
-
enumx_derive
Macros for ad-hoc enum extension
-
mpesa_derive
MpesaSecuritytrait derive macro crate -
splits_iter
Iterator over all 2-splits
-
evitable
Custom error types with context and derive
-
vectrix-macro
A macro for composing matrices
-
to_vec
convenient to_vec, to_set and to_map methods on iterators
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
split_preserve
An iterator that splits on whitespace but doesn’t throw it away
-
functionate
Automatically implement Fn* traits for structs and enums
-
enum_dispatch
Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed
-
traitcast_core
Cast between dynamic trait objects
-
fmt_adapter
Provides newtype adaptors to and from any formatting trait
-
ref-cast-impl
Derive implementation for ref_cast::RefCast
-
variadic_monoids
Construct variadic functions using monoids
-
extprim_literals_macros
Internal crate to support
extprim_literals. You typically don’t need this crate directly. -
as-dyn-trait
An attribute macro that generates methods for retrieving supertraits from trait-objects (upcasting)
-
rust-iteratorcomprehensions
A comprehension syntax for iterators implemented as macros
-
error-context
Methods and types that help with adding additional context information to error types
-
higher-derive
Custom derives for
higher -
auto_ops
Macros for easy operator overloading
-
track-macro
A macro to track data changes
-
verified
A library of types to facilitate the development of verifiable rust
-
bitpattern
bitwise pattern matching and extracting
-
frust
Functional Programming in Rust
-
yew-state
Ergonomic shared state for Yew (comparable to context hooks in React)
-
checked_ops
Automatic checked arithmetic operations in Rust
-
error-chain-for-dumb-ides
Faux’ apt package manager for Debian
-
std_prelude
prelude that the rust stdlib should have always had
-
hexfloat
Syntax extension to create floating point literals from hexadecimal strings
-
accel-derive
Procedual macro for writing GPGPU kernel
-
iroha
A tokenization Library for Rust
-
notedown_fmt
-
no_error
an error library for no_std
-
derive-error
Derive macro for Error using macros 1.1
-
iter_from_closure
Iterator<Item = Item> from FnMut() -> Option
-
progressive
A rust library for showing progress of iterators and loops
-
erroneous
Minimalistic helper for using errors
-
flat-bytes-derive
Derive macro for flat-bytes
-
userror
User-facing error messages for command-line programs
-
from_map
A crate that exposes the
FromMaptrait -
enum_primitive
Macro to generate num::FromPrimitive instances for enum that works in Rust 1.0
-
dahufi
A program to write and convert to Dahufi Language
-
hmap
Adds hmap! macro for easily generate HashMap
-
macro_const
A macro for creating corresponding macro definitions for constants which evaluate to the same values
-
hoist_temporaries
Procedural macro to extend the lifetimes of temporary variables
-
eraserhead
erase the lifetimes from types
-
match-downcast
A set of downcasting matching Rust macros
-
lelet-utils
lelet utils
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
capture
A macro for adding explicit capture clauses to a (closure-) expression
-
every_variant
To be used with all variant, contains the derive macro
-
rusteval-derive
macros for rusteval
-
adjacent-pair-iterator
An iterator over adjacent pairs in another iterator
-
powerset-enum
A poor man’s anonymous enum
-
join_to_string
Join a list of items to string/buffer
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
zkp-macros-impl
Implementation crate for
proc_macro_hack -
newtype_derive
This crate provides macros for deriving common traits for newtype structures
-
fn-compose
A small macro for function composition
-
transaction-stm
transaction abstraction of stm
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
varianteq
Derive the equality of enum variants ignoring fields
-
ternary-rs
A Rust library for emulating the ternary operator from C/C++ (among other languages)
-
error-chain
Yet another error boilerplate library
-
lisbeth-tuple-tools
A set of tools for tuple manipulation
-
hash-of
A typesafe wrapper for hashes
-
exitfailure
A basic newtype wrappers for use with ? in main
-
init_with
Helper trait to initilize an array with a function
-
partial-application-rs
A macro to transform functions into partially applicable structs
-
fmt-utils
Various utilities for use with std::fmt::Display and fast_fmt::Fmt
-
tch-tensor-like
Derive convenient methods for struct or enum of tch tensors
-
iflet
Provides a macro to chain multiple patterns in an
if letrather than nesting them -
primitive_enum
Little utility for dealing with enums no extra data in variants
-
int-enum
A procedural macro for conversion between integer and enum types
-
unborrow
Macro for calling a &mut self method with transient &-borrows of self in the parameters
-
scopefunc
A trait defining kotlin-like scope functions
-
or-iterator
Rust iterator which takes two iterators and returns non-empty one
-
repr-trait-derive
Derive macros for working with repr-trait
-
reexport-proc-macro
Re-export a procedural macro
-
cex_derive
Macros for checked exception simulation
-
cute_custom_default
Derive macro for
Defaulttrait with customization -
generic-newton
Simple generic Newton method
-
seek-ext
Extension trait to add convenience methods to
io::Seektypes -
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].
-
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
clierr
Non-panicking error handling for small CLI scripts
-
result
Helpers for dealing with nested Result and Option types
-
duck
Like
Iterator::peekable, but can be stacked an arbitrary number of times -
handle-error
An error handling helper macro to avoid the constant if let Err(e) pattern
-
c2rust-bitfields-derive
C-compatible struct bitfield derive implementation used in the C2Rust project
-
lift-fail
A library to handle
failurein an iterable collection -
inline-python
Inline Python code directly in your Rust code
-
arrayref
Macros to take array references of slices
-
dioptre-derive
Custom derive macro for #[derive(Fields)]
-
libsugar
libsugar provides syntactic sugar in the form of a library
-
apply_pub
A Rust syntax extension for applying the
pubvisibility modifer to many items at once -
transfer
Crate that exposes a Transfer trait, that is to move what Clone is to copy
-
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.
-
tylar
Type-Level Arithmetic in Rust
-
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
-
unwrap_return
A set of macros for returns and breaks in the None and Err cases
-
improved_slice_patterns
A tiny crate that provides macros to help matching on Vecs and iterators using the syntax of slice_patterns
-
proc-macro-error-attr
Attribute macro for proc-macro-error crate
-
builder_macro
A macro to generate structs and a corresponding builder
-
dispose-derive
Derive macro for the dispose crate
-
enum_traits_macros
Procedural macros that adds functionality to enums by deriving traits from the crate
enum_traits -
enum-lexer-macro
A proc_macro lexer generator. using
enum-like syntax. -
format-core
Core format types
-
cutlass
Macro based library to take the boilerplate out of configuration handling
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
monad
Stackless monads in Rust
-
lazy-panic
Lazy utils to customize panic messages
-
try-traits
Alternatives to std lib traits that can fail
-
tearor
Easily turn data races into data corruption!
-
set-error
A very simple trait that overwrites errors
-
boxing-day
Unwrap a Box in festive fashion, only on boxing day!
-
identity
A stable Rust implementation of an identity (a.k.a., “equality witness”) type
-
blair_mountain
Union types in release mode with debug assertions in debug mode
-
bitpat
Bit-level matching against values
-
rvs_derive
A helper macros implementation for Value Classes in Rust
-
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
-
into-owned
Provides a trait for associating a type with its owned variant
-
is-same-derive
Derive proc macro for the is-same crate
-
scrapmetal
Scrap Your Rust Boilerplate
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
dynamic
A dyanmically typed value with fast downcasting
-
random-number-macro-impl
Generate random numbers quickly
-
inherent
Make trait methods callable without the trait in scope
-
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.
-
structural_derive
Implementation detail of the structural crate
-
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
-
mutator
Mutator allows to use a struct in later crate as your builder
-
traitlit
This crate exposes an atribute for implementing traits for integer and float types
-
beau_collector
Collect up all errors into a single error
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
from_remote_derive
Procedural macro for deriving
Fromfor types with same internal structure -
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
try_enum
match enum
-
tch-tensor-like-derive
Derive macro implemenations used by tch-tensor-like crate
-
lfa_derive
Macros for LFA
-
shippai
failure in other languages
-
nan-preserving-float
(Mostly) drop-in replacement for floats that preserves the signalling bit in NaNs under conversions and unary operations
-
effect-monad
A native-rust implementation of an Effect monad, inspired by PureScript’s EFF Monad
-
human-panic
Panic messages for humans
-
tool
A grab-bag of tools for functional programming
-
pure_decimal
A decimal type with no NaN and Infinity
-
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
-
io
-
arsert_failure
Traits used by the
arsertcrate -
stringlit
A macro to convert from str to String
-
static-events
A library for creating zero-cost event systems
-
curry-macro
Have fun currying using Rust’s native closure syntax
-
tuple-conv
Allows converting tuples of one element to vectors
-
stringly_conversions
A crate helping to convert to/from various representations of strings
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
bevy_fallible_derive
Proc macro crate for bevy_fallible
-
endian_trait_derive
A custom derive for the Endian trait
-
lazy_futuristic
Initialize variables lazily, futuristically
-
future-union
Use future::Either with
impl Future -
pipe_macro
A macro to pipe function calls like in functional programming languages
-
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…
-
new_type_derive
Combat primitive obsession by easily creating strongly-typed wrappers and reference types
-
merge_derive
Derive macro for the merge::Merge trait
-
efficient_enum
Space-efficient enum values
-
tramp
Trampoline for recursive functions, with support for mutual recursion
-
plugger-macros
Plugger macros
-
next-gen_proc-macro
Safe generators on stable Rust
-
field_types
Some derive macros for deriving enums, corresponding to the fields of structs
-
static_slice
Macro for creating static slices of arbitrary types
-
rkyv_typename_derive
Derive macro for rkyv_typename
-
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
phantom_newtype
Lightweight newtypes without macros
-
error-chain-mini-derive
derives for error-chain-mini
-
chained_iter
Provides a small helper macro for creating iterators out of values without allocation
-
pretty-sure
Like
.unwrap()or.or_else()for arbitrary patterns -
withers_derive
A macro to implement wither methods for properties of a struct
-
invariant
A library for creating wrapper types that enforce invariants
-
fake-enum
A rust crate for creating FFI safe “fake” enum types
-
slice-copy
Go style copying for slices
-
enumn
Convert number to enum
-
primitive-from
Provides a trait PrimitiveFrom that is what From is to Into for num_traits::AsPrimitive
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
frunk_derives
frunk_derives contains the custom derivations for certain traits in Frunk
-
function_group
A macro to hack in function overloading to rust
-
transaction-diesel
transaction abstraction of diesel
-
conform-derive
Macros 1.1 implementation of #[derive(Conform)]
-
convute
Conversion between types with overlapping valid bit patterns and arrays, vecs and slices of those values
-
idealist
A library of non-empty wrappers for standard list types
-
ref_eq
Determine if two borrowed pointers point to the same thing
-
forever
-
char-iter
A performant iterator over a linear range of characters (
chars), correctly handling the surrogate range -
fixed-macro-impl
Proc-macro implementation for the
fixed-macrocrate -
fma
Tiny crate to use FMA(Fused Multiply-Add) instruction easily
-
enumiter
An iterator through the variants in an enum
-
cffi-impl
Safe* C FFI interface generator - macro
-
gatherr
Helpers for collecting values and errors from result iterators
-
take-cell-option
Utility for taking the value from a cell of a option without cloning
-
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
-
col_proc_macros_impl
The implementation crate of macros marked with the proc-macro-hack derive macro
-
same
Traits for testing identity of objects
-
ps
A safe wrapper around
std::mem::transmute -
pluralize
A generic trait across single and multiple elements
-
also
A collection of Kotlin-esque blanket impl helper functions, enabling easier function chaining patterns
-
bounded
Bounded numeric types
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
assert-impl
Macro for static assert types implement a trait or not
-
enumflags_derive
Bitflags
-
lazy_cat
Lazy concatenation of strings and other things in Rust
-
cast_trait
cast trait
-
type-level-logic
Primitive types and operations for type-level logic
-
typed_index_derive
Custom derive to easily create newtype index types
-
typebool
Type-level booleans meant for compile-time hackery
-
derive_from
A simple derive(From) macro
-
downcast-trait
Allow casting between traits
-
any-error
When you just want to use
?in peace -
w_result
A result type that carries warnings
-
newtype-enum
Traits to convert between enums and their variant types
-
read_with
Create a Read from a function
-
overloadf_derive
unlock function overloading for rust
-
type_level_examples
Examples of using type-level values and functions
-
err-context
Lightweight context layers for stdandard library errors
-
abistr-macros
proc macro implementations for abistr
-
loosen
Derives a wrapper function which loosen the arguments into a tuple
-
byteorder_slice
Byteorder like crate for &[u8]
-
extdot-impl
Please see
extdotcrate for actual usage -
displaydoc-watt
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
validator_derive
Macros 1.1 implementation of #[derive(Validate)]
-
atomig-macro
Defines procedural macros for the crate
atomig. Please see the main crate. -
define_error
A library for easily defining an error type
-
gcast
A library for using Google Cast devices
-
dylink_macro
Dynamic function loading macro
-
alias
aliasoffers some basic ways to mutate data while aliased -
from_tuple
Derive structs from tuples
-
pl-hlist-derive
Provides the HListSupport derive macro used in conjuction with the
pl-hlistcrate -
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
hashmap_derive
A proc_macro to derive the FromMap trait
-
dioptre
Struct field projection tools
-
struple
Convert structures from and to tuples