-
bitflags
A macro to generate structures which behave like bitflags
-
anyhow
Flexible concrete Error type built on std::error::Error
-
ordered-float
Wrappers for total ordering on floats
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
once_cell
Single assignment cells and lazy values
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
predicates
boolean-valued predicate functions
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive -
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
pin-project
safe and ergonomic pin-projection
-
bon
Next-gen compile-time-checked builder generator, named function's arguments, and more!
-
typenum
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, but its…
-
bytes
Types and traits for working with bytes
-
snafu
An ergonomic error handling library
-
thiserror
derive(Error)
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
inventory
Typed distributed plugin registration
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
smol_str
small-string optimized string type with O(1) clone
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
human-panic
Panic messages for humans
-
similar-asserts
assert_eq! like macros with colorized diff output
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
memoffset
offset_of functionality for Rust structs
-
approx
Approximate floating point equality comparisons and assertions
-
frunk
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
-
generic-array
Generic types implementing functionality of arrays
-
dyn-clone
Clone trait that is dyn-compatible
-
ouroboros
Easy, safe self-referential struct generation
-
scroll
A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
typed-builder
Compile-time type-checked builder derive
-
tap
Generic extensions for tapping values in Rust
-
zerovec
Zero-copy vector backed by a byte array
-
scopeguard
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… -
io-lifetimes
A low-level I/O ownership and borrowing library
-
streaming-iterator
Streaming iterators
-
az
Casts and checked casts
-
rustlings
Small exercises to get you used to reading and writing Rust code!
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
nonempty
Correct by construction non-empty vector
-
beef
More compact Cow
-
lasso
A multithreaded and single threaded string interner that allows strings to be cached with a minimal memory footprint, associating them with a unique key that can be used to retrieve them at any time
-
float-cmp
Floating point approximate comparison traits
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
counter
package to count generic iterables
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
scoped-tls
standard library’s old
scoped_thread_local!macro for providing scoped access to thread local storage (TLS) so any type can be stored into TLS -
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
rustc_apfloat
Rust port of C++ llvm::APFloat library
-
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]checks -
polonius-the-crab
Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
cargo-manifest
Helper crate to parse and manipulate manifests -
Cargo.tomlfiles -
nutype
The newtype with guarantees
-
dlopen2
opening and operating on dynamic link libraries (also known as shared objects or shared libraries)
-
constcat
concat! with support for const variables and expressions
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
rustdoc-types
Types for rustdoc's json output
-
assertables
assert macros for better testing, debugging, quality assurance, and runtime reliability
-
volatile
wrapper types for raw pointers
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
cfg-if
A macro to ergonomically define an item depending on a large number of #[cfg] parameters. Structured like an if-else chain, the first matching branch is the item that gets emitted.
-
crunchy
unroller: deterministically unroll constant loops
-
enclose
A convenient macro, for cloning values into a closure
-
educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits
-
if_chain
Macro for writing nested
if letexpressions -
iri-string
IRI as string types
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
async-once-cell
Async single assignment cells and lazy values
-
float-ord
A total ordering for floating-point numbers
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
orchestra
Generate an orchestra of subsystems from a single struct
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
derive-where
Deriving with custom trait bounds
-
bounded-integer
Bounded integers
-
bit_field
bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
shellexpand
Shell-like expansions in strings
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
unwinding
in Rust and for Rust
-
tynm
Returns type names in shorter form
-
all_asserts
multiple types of asserts that don't exist in the standard library
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
codespan
Data structures for tracking locations in source code
-
faux
mock structs
-
stdext
Extensions for the Rust standard library structures
-
axum-valid
validation extractors for your Axum application, allowing you to validate data using validator, garde, validify or all of them
-
aws-smithy-types-convert
Conversion of types from aws-smithy-types to other libraries
-
enumflags2
Enum-based bit flags
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
async-trait
Type erasure for async trait methods
-
enum-ordinalize
enables enums to not only obtain the ordinal values of their variants but also allows for the construction of enums from an ordinal value
-
iter-read
A Read implementation for iterators over u8 and related types
-
by_address
Wrapper for comparing and hashing pointers by address
-
fallible_collections
adds fallible allocation api to std collections
-
erasable
Type-erased thin pointers
-
failsafe
A circuit breaker implementation
-
version-sync
ensuring that version numbers in README files and other files are kept in sync with the crate version
-
buffered-reader
A super-powered Reader
-
field-offset
Safe pointer-to-member implementation
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
tuples
many useful tools related to tuples
-
retour
A cross-platform detour library written in Rust
-
bounded-collections
Bounded types and their supporting traits
-
dyn-stack
Dynamic stack wrapper for unsized allocations
-
konst
Const equivalents of std functions, compile-time comparison, and parsing
-
io-extras
File/socket handle/descriptor utilities
-
error-code
Error code
-
easy-cast
Type conversions which are expected to succeed
-
safe-transmute
A safeguarded transmute() for Rust
-
scoped-tls-hkt
more flexible version of
scoped-tls, allowing the following additional features: Storage of references to dynamically sized types. Storage of mutable references. Storage of… -
recursion
cache-aware stack safe recursion
-
tiny-fn
Type erased closures on stack
-
indoc
Indented document literals
-
lender
A lending-iterator trait based on higher-rank trait bounds, with full std::iter::Iterator functionality
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
calendrical_calculations
Calendrical calculations in Rust
-
fallible-streaming-iterator
Fallible streaming iteration
-
arrayref
Macros to take array references of slices
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
thiserror-no-std
derive(Error)
-
soa_derive
Automatic Struct of Array generation
-
rustrict
profanity filter for Rust
-
anymap3
A safe and convenient store for one value of each type
-
resman
Runtime managed resource borrowing
-
loupe
Profiling tool for Rust
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
strck
Checked owned and borrowed strings
-
shaku
Compile Time Dependency Injection for Rust
-
fallible-iterator
Fallible iterator traits
-
lending-iterator
Fully general lending iterators in stable rust: windows_mut!
-
tryhard
Easily retry futures
-
try_match
Fallible pattern matching with a function-like syntax
-
fatality
extension to
thiserror::Error -
const-gen
generating (relatively) complex compile-time constants in rust
-
cascade
Dart-like cascade macro for Rust
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
argp
Derive-based argument parser optimized for code size
-
simple-error
error type backed by a string
-
overload
macro to simplify operator overloading
-
pusherator
Push-based version of Rust iterators
-
deriving_via
DerivingVia
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
random-number
Generate random numbers quickly
-
o2o
Object to Object mapper for Rust. Derive '(Try)From' and '(Try)Into' traits.
-
dyn-clonable
Attribute wrapper for dyn-clone
-
oxc-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
joinery
A small crate for generically joining iterators with a separator
-
dupe
Marker for types which are cheap to clone
-
ra_ap_project_model
A representation for a Cargo project for rust-analyzer
-
terrors
ergonomic and precise error handling built atop type-level set arithmetic
-
nshare
Conversion between n-dimensional types in different Rust crates
-
const_soft_float
Const Soft Float Point
-
rdftk_names
set of modules that contain the
IRIs andQNamestrings for commonly used vocabularies. It also provides macro support for defining new namespaces in the same style as this library. -
elain
Set a type's minimum alignment with const generics
-
halo2-base
Embedded domain specific language (eDSL) for writing circuits with the
halo2API. It simplifies circuit programming to declaring constraints… -
cfn-guard-ffi
AWS CloudFormation Guard is an open-source general-purpose policy-as-code evaluation tool. It provides developers with a simple-to-use, yet powerful and expressive domain-specific language (DSL)…
-
reborrow
Emulate reborrowing for user types
-
cast_trait_object
Cast between trait objects using only safe Rust
-
genetic_algorithm
A genetic algorithm implementation
-
send_wrapper
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…
-
auto_enums
allow multiple return types by automatically generated enum
-
sealed
Macro for sealing traits and structures
-
dync
An efficient alternative to
dyn Traitfor containerized types -
concat-with
Extend the function of the
concat!macro instd -
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
with_locals
Function attribute to return references to locals by using CPS
-
inline-python
Inline Python code directly in your Rust code
-
munge
Macro for custom destructuring
-
r3bl_redux
Redux library built using Tokio, concurrent & parallel
-
condtype
Choose types at compile-time via boolean constants
-
reblessive
A small runtime for running deeply nested recursive functions
-
components-arena
creating complex domain-specific self-referential data structures
-
yazi-macro
Yazi macros
-
loft
embedded scripting language
-
documented
Derive and attribute macros for accessing your type's documentation at runtime
-
outref
Out reference
-
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
exhaust
Trait and derive macro for working with all possible values of a type (exhaustive enumeration)
-
awint_macro_internals
Internal macro utilities for the
awintsystem of crates -
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_partsandVec::into_raw_parts -
internal-iterator
Internal iteration equivalent of
std::iter::Iterator -
moveit
safe, in-place construction of Rust (and C++!) objects
-
macro-machines
State machine macros with logging and graphviz DOT file generation
-
assert_approx_eq
assert approximately equal
-
orion-error
Struct Error for Large Project
-
open-enum
An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
better_scoped_tls
scoped-tls, but with good error message
-
myutil
Rust Util Collections
-
fluent-comparisons
Boost readability by writing multicomparison expressions like
if any_of!({a,b,c}>=5) {...}while keeping the benefits of hand-written code -
async-fn-stream
Lightweight implementation of
async-streamwithout macros -
panic-halt
Set panicking behavior to halt
-
yamlscript
Program in YAML — Code is Data
-
vector2d
The spoon of 2D vector libraries, intended for simple game development
-
freecs
A high-performance, archetype-based Entity Component System (ECS) written in Rust
-
data-rw
io buffer write reader
-
times
Timing Benchmark, Repeated Runs, with Statistics
-
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… -
stackalloc
Safely allocate and manipulate arbitrarily-sized slices on the stack at runtime
-
funty
Trait generalization over the primitive types
-
flex-error
Flexible error definitions using macros and traits
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
uniplate
boilerplate-free operations on tree-shaped data types
-
copyless
Ways to eliminate memcpy calls when using the standard library
-
cap-std-ext
Extension APIs for cap-std
-
regex-macro
A macro to generate a lazy regex expression
-
validated_struct
Easily generate nested structures with getters and predicated setters
-
parsable
A trait to easily parse data structures
-
aide
A code-first API documentation library
-
proc-bitfield
expressively declare bitfield-like structs
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
rc-borrow
Borrowed forms of Rc and Arc
-
dispose
wrapper for values that must be consumed on drop
-
advent-of-code
Solutions to Advent of Code
-
rust_info
Extracts the current rust compiler information
-
gat-lending-iterator
iterators who's items can [mutably] reference the iterator
-
any_of
A general optional sum of product type which can be Neither, Left, Right or Both
-
sptr
Strict Provenance Polyfill
-
mini-mcmc
A compact Rust library for Markov Chain Monte Carlo (MCMC) methods with GPU support
-
tan
language
-
fixnum
Fixed-point numbers with explicit rounding
-
k8-client
Core Kubernetes metadata traits
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
void
The uninhabited void type for use in statically impossible cases
-
slice-dst
Slice-based custom DSTs
-
istring
A replacement for String that allows storing short strings of length up to sizeof<String>() - 1 without a heap allocation
-
autofolder
Single-element folding wrapper
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
biome_js_factory
create JavaScript AST for biome_js_parser
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
entrait
Loosely coupled Rust application design made easy
-
macon
builder macro-based generator with its own idioms
-
lowdash
A Lodash inspired utility library to manipulate array and object for Rust
-
error_set
An error set macro that simplifies error management by providing a streamlined method for defining errors and easily converting between them. Inspired by Zig's error set type.
-
async-recursion
Recursion for async functions
-
tuplex
Rust tuple extension
-
valitron
ergonomics, functional and configurable validator
-
iced_anim
creating animations in Iced
-
fixed-hash
Macros to define custom fixed-size hash types
-
psl-types
Common types for the public suffix implementation crates
-
miden-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
qualifier_attr
Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items
-
as-any
provide the AsAny trait
-
rustica
functional programming library for the Rust language
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
aerosol
dependency injection for Rust
-
retry
retrying operations that can fail
-
resiter
Helper crate for handling iterators over result
-
lazy_errors
Effortlessly create, group, and nest arbitrary errors, and defer error handling ergonomically
-
nunny
the definitive non-empty slice/array/vec library for Rust
-
refined_type
imbuing rules into types and elevating them to more robust types
-
sugars
An useful collection of macros to make tasks easier
-
moddef
Macro for convenient module declaration. Each module can be put in a group, and visibility can be applied to the whole group with ease.
-
delegation
Macro-based delegation for enums and structs
-
andex
Safe, strongly typed array indexes and wrappers for rust with zero dependencies
-
lazy-static-include
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
racer
Code completion for Rust
-
wai-bindgen-rust
Generate WAI glue for a Rust guest
-
metastruct
Abstractions for iterating and mapping over struct fields
-
doku
A framework for documenting Rust data structures
-
orx-pseudo-default
PseudoDefault trait allows to create a cheap default instance of a type, which does not claim to be useful
-
diff-struct
A trait for diffing and applying diffs to types
-
smarterr
Smart error handling library
-
renege
Tracking cache validity using fast concurrent invalidation propogation
-
emboss
Macros to embed metadata as an ELF/Mach-O section in your final binary
-
tracerr
Custom compile-time captured error tracing
-
nar_dev_utils
用于NARS相关项目开发的实用工具包
-
buildstructor
Macro to derive a builder from a constructor function
-
leptos-mview
A concise view macro for Leptos
-
fauxgen
write your own generators in stable rust
-
display-error-chain
Formats a standard error and its sources
-
relib_internal_shared
relib is a framework for reloadable dynamic libraries
-
tinyvec_macros
Some macros for tiny containers
-
radiation
Convert Rust type into raw bytes and vice versa
-
macro-asm-builder
macro-assemblers
-
mydi
MyDI. Dependency Injection library
-
hax-lib
Hax-specific helpers for Rust programs
-
socketpair
Cross-platform socketpair functionality
-
const-field-offset
Wrapper around field-offset crate and const-field-offset-macro
-
mownstr
Maybe Owned String
-
pagetable
Wait-free 4-level 64-bit pagetable for roughly-contiguous keys
-
corlib
A various ideas library
-
static-keys
Reimplement Linux kernel static keys for Rust userland applications
-
direction
Representations of directions
-
mock-http-connector
Mock hyper HTTPConnector
-
endian-writer
[no_std] Methods for efficient reading and writing of structures to raw pointers in a stream-like fashion
-
collect-with
enhanced collection operations with capacity control
-
include-utils
mdBook-like include macro as the powerful replacement for the standard
include_strmacro -
ext-trait
Annotation to easily define ad-hoc / one-shot extension traits
-
actuate
A reactive user-interface framework
-
enum-assoc
Procedural macro to associate constants with enum variants
-
wiwi
Stuff™
-
oxrdf
providing basic data structures related to RDF
-
statum
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
file_rw
high-performance, memory-mapped file I/O utilities
-
conv
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
one_err
OneErr to rule them all
-
type-safe-id
A type-safe, K-sortable, globally unique identifier
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
railsgun
Excessive tooling for Result handling - If you want rails you got RAILS!
-
b-x
The stupidest boxed error ever
-
steckrs
A lightweight, trait-based plugin system for Rust applications and libraries
-
crustal
generating C/C++ code
-
strong-type
Procedural macros for naming and strong-typing pritimives and strings
-
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
cartesian
QOL macro that creates the cartesian product of multiple iterators
-
refinement-types
Refinement types
-
event-driven-library
Event Driven Message Handling
-
nenyr
initial version of the Nenyr parser delivers robust foundational capabilities for interpreting Nenyr syntax. It intelligently processes central, layout, and module contexts, handling complex variable…
-
kindest
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
iterate-trait
Experiment with methods on IntoIterator
-
option_trait
Helper traits for more generalized options
-
downcast
Trait for downcasting trait objects back to their original types
-
zed
A minimal, Redux-like state management library for Rust with advanced features
-
model-mapper
Derive macro to map between different types
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
bool_ext
defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
auto_ops
Macros for easy operator overloading
-
scaffolding-core
A software development kit that provides the scaffolding for building applications and services using OOP
-
familiar
reserve
-
swamp-script-error-report
Swamp script error report
-
derive_destructure2
Destructure structs that implement Drop
-
cast
Ergonomic, checked cast functions for primitive types
-
enum-derived
Generate random instances of your enums and structs
-
marauders
A work-in-progress code mutation tool
-
state-department
state management and dependency injection in Rust
-
hermit-sync
Synchronization primitives for kernels
-
certain-map
A typed map which can make sure item exist
-
rc-box
Known unique versions of Rc and Arc
-
enum-ptr
Ergonomic tagged pointer
-
show-option
displaying Options
-
fn_meta
Returns metadata about a function at runtime
-
trait-cast
Get your own Any with support for casting to trait objects
-
dyn-context
mechanism for lifetimes erasing
-
hlist2
Compile-time heterogeneous list implementation
-
doc-comment
Macro to generate doc comments
-
allow
Alias/label lints (to disable) with your intentions. Reexported from allow_prefixed, grouped under rustc::, clippy:: and rustdoc:: modules.
-
lsts
Large Scale Type Systems
-
traitsequence
Traits to abstract over sequences
-
logkit
Super fast, structured, scalable logging library for Rust
-
rudi
out-of-the-box dependency injection framework for Rust
-
sod-actix-web
Service Oriented Design - Actix Web
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
clone_cell
A Cell that works with a restrictive form of Clone
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
devela
A cohesive development layer
-
dioxus-class
Dioxus class
-
vector2math
Traits for doing 2D vector geometry operations using standard types
-
case_insensitive_string
A case insensitive string struct
-
tokenlock
cell types that decouple permissions from data
-
pinkie
(Almost) compile-time scoped CSS-in-Rust
-
ref_iter
Dynamic borrowing iterator
-
recursive
Easy recursion without stack overflows
-
wavltree
An intrusive Weak AVL Tree
-
fp_rust
Implement fp features for Rust
-
drop_bomb
A runtime guard for implementing linear types
-
snurr
Read BPMN 2.0 files and run the process flow
-
flexcell
A flexible cell that allows safe circumvention of double borrow issues
-
globals
Painless global variables in Rust
-
pipe-trait
possible to chain regular functions
-
rshyper
focuses on hypergraphs
-
cfg-elif
Formatter-friendly conditional compilation at item and expression positions
-
tern
Embedded database migrations in SQL or Rust
-
text-block-macros
Create a multiline string literal
-
quoth
scannerless (no-lexing), developer-friendly parsing library for implementing DSLs and syntax parsers in Rust
-
conflate
Merge multiple values into one
-
relend
A generalized reborrowing mechanism that extends beyond simple references. It also allows for implementing traits that work with reborrowing for custom types.
-
dogma
Dogma.rs
-
nject
Zero cost dependency injection module
-
stringleton
Extremely fast string interning library
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
human-errors
An error library focused on providing your users with relevant advice for any problem
-
rs_envflag
An easy way to define flags by environment variables
-
frunk_proc_macro_helpers
Common internal functions for frunk's proc macros
-
should
Postfix assertion library for Rust
-
type-toppings
Opinionated extensions to standard types
-
borrowme
The missing compound borrowing for Rust
-
alternating-iter
Provide an iterator adaptor which alternate between two iterators
-
rustversion
Conditional compilation according to rustc compiler version
-
linear_type
Linear types for rust
-
hierr
RUST Error
-
capacity_builder
Builders where the code to calculate the capacity is the same as the code to write what's being built
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
hyperlight-guest
build guest applications for hyperlight
-
empty-fallback-chain
Iterator adaptor like chain, but conditional on empty first iterator
-
http-request-derive
Use derive to create HTTP requests
-
numeric_cast
Safely cast between numbers
-
scout-parser
A web crawling programming language
-
tupletools
functions for tuples
-
inline-c
Write and execute C code inside Rust
-
implementation
The implementation crate
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
bignumbe-rs
Large, medium-precision numbers
-
rst-common
A shortcut to common Rust crates
-
crabtime
A powerful yet easy-to-use Rust macro that generates code by evaluating inline Rust logic at compile time
-
macro-toolset
Some useful macros
-
path_scan
A lightweight Rust procedural macro for parsing path patterns (URLs, routes) with variable capturing, static binding, and compile-time checks
-
salsa-macro-rules
Declarative macros for the salsa crate
-
copy_from_str
An extension trait to copy a string into another string
-
retry-error
An error type for an operation that can fail more than once
-
defer
excecution of code, inspired by go's defer statement
-
scarb-proc-macro-server-types
Types for interacting with an RPC server set up by the
scarb proc-macro-servercommand -
safecast
Traits to define safe casting between types
-
aad
Automatic adjoint differentiation library
-
thiserror-context
A wrapper around thiserror, giving you the ability to add context
-
elicit
SmartPointer-like structure for polymorphism
-
validated
The cumulative sibling of
ResultandEither -
strangemeadowlark
Parser for the Starlark configuration language. Ported from https://github.com/google/starlark-go
-
evcxr_repl
A REPL for Rust
-
fmt-cmp
Traits and utilities for lexicographically comparing values in their
Displayrepresentations -
transpose-future
Transpose Option<impl Future>
-
radicle-std-ext
Monkey patches of std types
-
pytauri
Tauri binding for Python through Pyo3
-
typeables
type aliases. By SixArm.com.
-
valico
JSON Schema validator and JSON coercer
-
yield-return
Implement a coroutine like C#‘s
yield returnusing Rust’sasync,await -
std-next
Opinionated utilities and polyfills
-
self-rust-tokenize
Turns instances of Rust structures into a token stream that creates the instance
-
deki
A base for most of my rust projects (tailored to myself)!
-
dialogue-macro
An extension to dialoguer that simplifies command-line interaction interfaces
-
orx-closure
An explicit closure with absolute seperation of the captured data from the function
-
expect-exit
Result.expected(): display an error message and exit without a panic
-
urlquerystring
A high-performance, zero-allocation URL query string parser
-
baxe
that simplifies error handling in Axum
-
tamago
generating C code
-
bounded-vector
Vec wrapper that guarantees upper and lower bounds on type level
-
orx-self-or
Defines SoR (self-or-ref) and SoM (self-or-mut) traits that are useful in reducing code duplication and pushing forward the ownership transfer decision from the type designer to the consumer
-
cove
Casts Of Varying Elegance (COVE): extension traits for casting numerical types
-
derive_generic_visitor
Boilerplate for building rust visitors
-
structx
Simulating anonymous struct and named arguments in Rust
-
collate
Traits and a data structure to support collation and bisection
-
option-operations
Traits and auto-implementations to improve arithmetic operations usability when dealing with
Options -
linux-errnos
A list of error numbers
-
cgp-error
Context-generic programming error components
-
soapy
Structure-of-arrays derive macro
-
kind
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
sovran-typemap
A thread-safe heterogeneous container with type-safety
-
code-spells
Aliases some common (and less common) code snippets to macros named after thematically appropriate spells from Harry Potter, so that instead of calling drop(x), you can cast obliviate!(x)
-
static_file_util
generating and managing static files in Rust applications
-
flat_string
FlatString is fixed allocated size String that that can be created direcly on the stack
-
relax
Derive Partial<T>
-
hex_lit
Hex macro literals without use of hex macros
-
ownable
Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more
-
qcl
A Query Check Language written in Rust
-
ownedbytes
Expose data as static slice
-
teleparse
-
abs-file-macro
A macro that returns the absolute file path of the Rust source file in which it is invoked
-
thiserror-core
derive(Error)
-
pair
Safe API for generic self-referential pairs of owner and dependent
-
supertrait
enables default associated types and const fn trait items in stable Rust
-
naan
A fast, easy, and tasty functional programming prelude
-
semval
Semantic validation
-
ux2
Non-standard integer types like
u7,u9,u10,u63,i7,i9etc -
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
non_structural_derive
nonstructural derives for auto traits
-
try-specialize
Zero-cost specialization in generic context on stable Rust
-
airbag
handling errors and panics using 3rd party services
-
cortex-ai
An asynchronous flow-based processing framework for building flexible data pipelines with conditional branching and error handling
-
pilgrimage
A Kafka-like message broker in Rust
-
cfg_rust_features
Set cfg options according to probing for Rust compiler, language, and library features
-
ra_ap_hir_expand
Macro expansion for rust-analyzer
-
easy-error
error utilities
-
easy-err
An easy Error wrapper
-
visibility
Attribute to override the visibility of items (useful in conjunction with cfg_attr)
-
hash-db
Trait for hash-keyed databases
-
mapper
Mapping macro to help to reduce mapping boilerplate
-
sumtype
Generate zerocost sumtype of iterators or closures
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
value-box
Allows developers to pass Rust-allocated structures over ffi
-
sdre-rust-logging
logging library for Rust, with a custom formatter
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
version-ranges
Performance-optimized type for generic version ranges and operations on them
-
type_cell
Attach values statically to a type using static get/set methods
-
openapi_type
OpenAPI type information for Rust structs and enums
-
ty-tag
TypeId for lifetime containing types via type tags
-
amonoid
A general-purpose monoid library
-
wrap-match
A procedural macro to wrap a function in match statement to make error logging super easy
-
nnn
Generate your newtypes from a single macro
-
unzip_iter
Unzip an iterator to iterators
-
linked_list_r4l
Linked lists that supports arbitrary removal in constant time
-
impls
Determine if a type implements a logical trait expression
-
enum_cycling
Small macro for working with enums
-
screeps-async
Tick-aware Async runtime for Screeps
-
vsprintf
Rust bindings to the libc vsprintf function
-
drain
that supports graceful shutdown
-
re_error
Helpers for handling errors
-
steel-core
Core compiler and VM implementation for steel
-
spade-types
Helper crate for https://spade-lang.org/
-
entity_data
A container for entity component data
-
iterstats
Statistics for rust iterators
-
maybe-uninit-ext
Extended maybe-uninit types
-
restructed
Quickly derive subsets of your structs
-
gan
Just do it! A small tool provides ergonomic value handling with ignore/ ok/ some semantics
-
tisel
Effective type-based pseudodynamic dispatch to impls, enums and typeid
-
typle
Generic tuple bounds and transformations
-
cache_diff
Generate clean, human readable diffs between two cache structs
-
pathbufd
PathBuf with Display + formatting macro
-
deptypes
Dependent types
-
schachmatt
A chess library
-
barexp
that automatically generates mod.rs files for your project
-
reductor
Generic abstractions for combining and nesting reduction patterns for iterables
-
prange2
Parse numeric ranges for indexing
-
boxarray
Safe way to allocate and initialize nested arrays directly on the heap in Rust
-
rancor
Scalable and efficient error handling without type composition
-
failed-result
A small crate for converting various failed value to result with corresponding error type
-
assume
Macro for stating unsafe assumptions in Rust
-
variadics_please
Implement things as if rust had variadics
-
mu_rust_helpers
Helper functions for UEFI Rust applications
-
prost-unwrap
A procedural macro for prost-generated structs validation and type-casting
-
jkcenum
Rust enum library
-
is-odd
Returns true if the given number is odd
-
maybe-borrow
Macros for conditionally returning borrowed data
-
deterministic_default_hasher
A deterministic initialisation of the stdlib default hasher
-
nonbox
NaN boxing without boxing
-
branch_hints
that provides likely and unlikely branch hint functions in stable Rust
-
parametrized
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
err-rs
Error level management
-
bon-sandbox
Not a real crate! It’s just a showcase of examples used by
bon’s documentation to demonstrate the rustdoc output for code generated by builder macros. Don’t use this crate, it… -
optfield
A macro that generates structs with optional fields
-
portaldi
An ergonomic lightweight compile-time depencency injection library
-
axum-resp-result
Help Struct For Axum Response
-
prima_bridge
implement the bridge pattern
-
fmt-derive
A more robust and versatile derive macro for Debug and Display
-
ferment
Traits for FFI conversions and some helper methods
-
enumeration
An extension to rust enum
-
shadow_counted
An iterator that counts every iteration in a hidden counter, nested iterators may commit the count to parents
-
cell_wrappers
set of macros for ergonomically working with TCells and TLCells from the qcell crate
-
conerror
macro that automatically adds context to errors
-
funcmap
Derivable functorial mappings for Rust
-
tremor-common
Tremor common functions
-
natrix
Rust-First frontend framework
-
ordes
treating arrays and tuples a little bit more like vectors
-
code-path
A code path macro
-
re_tuid
128-bit Time-based Unique Identifier
-
derive-regex
Easily parse a regex into a struct or enum variant
-
unchecked_wrap
Convenient UncheckedSync/Send wrapper types
-
c-types
Re-exports of cross-platform types, gathered from libc and winapi
-
wallee
Flexible concrete Error type built on std::error::Error with caller location tracking
-
random_variant
To be used with all variant, contains the derive macro
-
anyhow-http
Customizable HTTP errors built on anyhow
-
result-like
Option/Result-like monad interface for your own enum
-
with_drop
Nostd wrapper for using a closure as a custom drop function
-
dyn-hash
Hash trait that is dyn-compatible
-
to_method
micro-crate for using Into more ergonomically
-
cew
Personal Rust utility library
-
width_counters
Atomic counters with variable bit widths and customizable atomic ordering
-
columnation
Unsafe columnar containers for native Rust types
-
mod_use
pub mod xxx; use xxx::*;
-
mylibrary_
my personal library
-
fallthrough
Pattern match with fallthrough, in the style of C switch
-
pyo3-error
Unified error causality chains across Rust and Python
-
sitrep
Frontend-agnostic progress reporting
-
fn-traits
function traits like the standard library ones, but can be used in stable Rust
-
blanket
macro to derive blanket implementations for your traits
-
tantivy-derive
Generate code to converts struct from and to tantivy documents
-
lazycell
providing a lazily filled Cell struct
-
simple_parse
A declarative converter for Rust type to and from binary
-
selfie
Experimental, macro-free and allocation-free self-referential structs
-
px-wsdom-macros-decl
wsdom crate
-
vtid
generating volatile type IDs
-
xwt-error
A suite of reusable error types that naturally emerge from the xwt API. Use when you don't want/need your own more precise types
-
take-until
A take_until extension for iterators
-
non-empty-str
Non-empty strings
-
sod
Service Oriented Design
-
gazebo
A collection of well-tested utilities
-
irox-types
Enums and structs to describe Rust's basic type system
-
redb_model
Redb model derive macro and DTO type conversion
-
problem
Error handling for command line applications or prototypes
-
padder
Highly efficient data and string formatting library for Rust
-
panic-message
Get a panic message from a panic payload
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
lure
Shift left with Lure, a Rust crate that provides a macro for creating lazy Regex instances with compile-time validation, ensuring invalid patterns fail to compile
-
deltoid
calculate and apply deltas to structs and enums
-
eoe
exiting processes on errors gracefully
-
surreal_devl
Contains core logic of surreal derive
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
const_fn
A lightweight attribute for easy generation of const functions with conditional compilations
-
ffizz-passby
FFI helpers for implementing pass-by-value and pass-by-pointer
-
trybuild-internals-api
A fork of trybuild with the internals exposed as a public API
-
dynarg
mechanism for dynamic robust argument handling
-
animatron
Animation state management
-
concat-string
macros for concatenating string slices into owned strings
-
stub-macro
stub!() is a better version of todo!() that can be assigned to a variable
-
service-builder
A lightweight, type-safe service construction library for Rust that provides compile-time dependency injection through builder pattern
-
named-tup
Create named tuples using the tup!() macro
-
degeneric-macros
Hides struct generics into trait associated types
-
borrow-or-share
Traits for either borrowing or sharing data
-
univec
A vector that can hold elements of any single type
-
ffi_helpers
help make working with FFI easier
-
never
A stable version of the unstable never type (!)
-
chainerror
Make chaining errors easy
-
ucpack
serialization format used in the Arduino Alvik
-
mode
A behavioral state machine library written in Rust
-
syllogism
allow for some specialization using stable Rust
-
humanbyte
A procedural macro for deriving human readable byte functions
-
axum-routes
Create an axum Router from an enum and resolve routes
-
round
your floats with precision from 1 to 10
-
rukt
dialect for token-based compile-time scripting
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
indexed_valued_enums
Create enums resolving into values, and get their variants back through their values or their discriminant, inspired by Java
-
variadiz
Variadic function support for rust
-
derive-merge-struct
A derive macro to partially update a named struct
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
pipa
Pipe Operator Library for Rust
-
partial_derive2
makes all the properties of a struct type an optional property
-
hs-bindgen
Handy macro to generate C-FFI bindings to Rust for Haskell
-
precomputed-hash
intending to be a base dependency to expose a precomputed hash
-
assert_matches2
A version of the assert_matches! macro that brings variables from the pattern into scope
-
circuit_breaker
Circuit Breaker pattern for building resilient and fault-tolerant systems
-
lowbulls
lowbull is a Rust crate facilitating message handling and event monitoring
-
filemagic
libmagic bindings
-
as-is
An abstraction over ownership
-
type-fn
Allows for simpler coding of type-level logic, e.g. for type-number systems.
-
cloneable_errors
similar to anyhow, that allows the errors to be cloned, shared, cached and even sent over the network
-
gen_ops
Macros for operator overloading for generic types
-
generics
macros for parsing generics (with optional where clause) in
macro_rules! -
slugify
Macro for flexible slug generation
-
stupid_utils
that provides some simple and maybe stupid or useful tools
-
ser_mapper
Mapped DTO serialzation wrapper for DBO/Model
-
rusty-typesh
A flexible type pattern matching system for Rust
-
ffi-enum
Simply write and use
enums like rust native enums, freely passing through ffi -
processmanager
manage process lifecycles, graceful shutdown and process faults
-
tacit
macro to make newtypes easier to create
-
sawp-ffi
FFI helper macros and traits
-
ufotofu
Abstractions for lazily consuming and producing sequences
-
easy_node
Smart pointer for graph nodes
-
composable
Easy composition of functional traits, functions or closures
-
currying
anything implementing
FnOnce. Arguments can be passed one at a time, yielding a new something implementingFnOnce(and possiblyFnMutandFn) which can be called with one less argument. -
generativity
Generation of unique invariant lifetimes
-
hax-frontend-exporter
mirrors of the algebraic data types used in the Rust compilers, removing indirections and inlining various pieces of information
-
dontpanic
Get instant notifications about any panic!(); in your codebase
-
iter-comprehensions
iterator comprehensions
-
wiwi-macro-decl
declarative macros for wiwi, a library, of, Stuff™ (implementation detail; do not depend on this crate directly)
-
primitive-from-enum
macros for get primitive enum from complex
-
fixedstr-ext
A fork of fixedstr, which add more const functions to it
-
assert-eq-float
assert_eq_float!macros that support floats -
iterator-sorted
Stable functions for checking iterator sorting
-
mutually_exclusive_features
Macros to check that only none or one of a set of features is enabled at a time, as known as mutually exclusive features
-
sourceannot
render snippets of source code with annotations
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
default-constructor
Macros for creating pseudo-dsls that constructs structs through default construction and field conversion
-
rhai-rusp
Rhai bindings for the Rust USP toolkit
-
async-iterator
An async version of iterator
-
game_inventory
An inventory system independant of item data
-
std-traits
Traits for types in the standard library
-
ez_log
logging library for Rust
-
tighterror
A minimalistic error representation framework
-
bint
Bounded Integer in Rust
-
sigmut
a state management framework designed to be used as a foundation for UI frameworks
-
path-dsl
DSL and macro to help deal with Paths and PathBufs
-
pattern_code
Given a path patterm matched source code
-
derail
An alternative to
core::error::Error -
pike
A macro collection to pipe |> your functions calls, like in functional languages such as F#, Elixir and OCamel
-
partial_application
partial function application via the partial! macro
-
fast-concat
Fastest macro for concatenating strings
-
fastpeek
A different way to peek iterators
-
enumtrait
macros for polymorphism using enums
-
jist
Welcome to Jist a lightweight and efficient programming language built in Rust, designed for simplicity, flexibility, and fast performance with a clean and readable syntax. Github: https://github.com/jon429r/JistR
-
maybe_path
Zero overhead static initializer for Path
-
objectionable
storage of unsized types inline inside allocated objects
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
xacro
A xml preprocessor for xacro files to generate URDF files
-
hkt-pin-list
Self managed HKT intrusive linked list
-
konst_macro_rules
detail of the konst crate
-
nz
Collection of 100% safe macros for creating non-zero integers more easily
-
copstr
COpy STRing module
-
no-break
Typesafe extraction of continuation values from unbreakable control flows
-
vcell
Cellwith volatile read / write operations -
parsql-sqlite
Parsql için sqlite entegrasyonunu sağlayan küfedir
-
maybe-single
A singleton. Maybe.
-
manifest-dir-macros
function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
safelog
Conditionally suppress confidential information from logs
-
panic
Humanized panic message wrapper
-
iter-index
More flexible alternative to Iterator's enumerate() method
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
iced_af
The iced application framework project
-
heterob
conversion between bytes/bits and heterogeneous lists (tuples)
-
threadporter
First aid kit for !Send + !Sync values ⛑️
-
mac
A collection of great and ubiqutitous macros
-
small_uid
A 64 bit lexicographically sortable unique identifier implementation
-
seasick
FFI-safe nul-terminated strings with ownership semantics
-
size-of-no-padding
A procedural macro to calculate the size of a type without padding
-
intertrait
Allow for inter-trait casting
-
dowhile_rs
Do while macro for rust with labels and nesting support
-
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
-
lazy-init
Lazy initialization
-
codespan_preprocessed
Beautiful diagnostic reporting for M4 (or cpp) preprocessed text files
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
defer-heavy
A versatile and easy to use defer statement for Rust. Similar to Go's or Zig's defer.
-
nohashmap
Use HashMap syntax in Rust for non-hashable types
-
ocl-macros
Macros for easier/faster working with the ocl crate
-
patched
Macro for patch like structure
-
argcall
Enables enums and structs to be callable by associating functions with their variants or fields
-
embed_it_utils
The utils for [
embed_it] -
evalexpr-jit
JIT compilation and symbolic differentiation of evalexpr expressions with Cranelift
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
stream_assert
Macros to simplify testing of
Streambased APIs -
guard-clause
Syntactic sugar for writing simple guard clauses
-
pgde
A macro library for consuming PostgreSQL row data into structs
-
home-prelude
Prelude library to support home applications
-
dyn_std
Dynamic (object-safe) version of std traits
-
lexi-matic
A Lexer Library
-
easy-ext
A lightweight attribute macro for easily writing extension trait pattern
-
slugify-rs
generate slugs from strings
-
rust-code-analysis-web
Run a web service to compute and export code metrics
-
iter-scan
Iterator scan methods that don't suck
-
arrcomp
Python-style list comprehension syntax for contiguous memory Rust arrays
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
drying_paint
observer pattern for Rust
-
typestate
A proc macro DSL for typestates
-
datetime_literal
A macro for creating chrono::DateTime instances
-
genrc
refcounted pointer type that allows subobject pointers
-
retryable-result
repeatedly try on some recoverable errors until too many or a fatal error
-
io-streams
Unbuffered and unlocked I/O streams
-
checked-rs
encoding validation semantics into the type system
-
TSPL
The Simplest Parser Library
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
misfortunate
Perverse implementations of safe Rust traits
-
rig-dyn
A dynamic client-provider abstraction framework for Rust applications on top of rig-core
-
pin-macros
primarly used to simplify the proccess of working with self-referencial structures
-
clamp_to
Clamp integer and float values to the values that fit within both the original number type and the receiving type
-
derive-insert
GetOrInserttrait for enums and its derive macro -
lucene_query_builder
A procmacro derive crate to generate lucene query builder for Rust structs :
-
nipdf-cff-parser
that parses CFF files, part of nipdf library
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
cmp
convenience macros and function for comparing
-
more-di
support for dependency injection (DI)
-
niloecl
axum handler pattern for twilight interactions
-
defmac
A macro to define lambda-like macros inline
-
rustc-ap-rustc_errors
Automatically published version of the package
rustc_errorsin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
nitinol
event sourcing
-
harper-literate-haskell
The language checker for developers
-
ebnsf
A CLI to generate railroad (syntax) diagrams from EBNF specs
-
unwinder
Call stack spoofing for Rust
-
small_len
A small library for storing the length in the smallest internal type
-
capture-it
Modern c++-ish capture syntax for rust
-
rock-paper-scissors
open-source Rust game API that allows users to create custom implementations of the classic game 'Rock, Paper, Scissors'
-
bounds
interact with bounded and unbounded ranges
-
asm_block
Translate tokens to string for Rust inline assembly
-
dims_macro
Macros for Generating Systems of Units
-
tardar
Extensions for diagnostic error handling with
miette -
error-iter
Error::sources on stable Rust
-
option-like
Create your own Option-like enum
-
rcss
Rust CSS embedding library
-
v8_derive
Derive macros and helpers for Rusty v8
-
rusty-hkt
Higher-kinded types for Rust
-
namewise
Derived trivial name-wise conversions for Rust types
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
transitionable
A no_std compatible type to transition
T -> Twhere you have an&mut T -
sealed_trait
making sealed traits more accessible
-
nu-std
The standard library of Nushell
-
pyderive
Derive macro of Python special methods and a class attributes for PyO3
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
wutil
A lightweight library that contains useful functions, wrappers, and macros
-
map
map!macro andmap_insert!macro, to create a HashMap collection and insert key-value pairs. Inspired by thevec!macro. -
crony
cron runner that spawns another thread to run your cron jobs
-
chandeliers-sem
Semantics of Candle, a shallow embedding of Lustre in Rust
-
state-shift
Macros for implementing Type-State-Pattern on your structs and methods
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
swamp-script-derive-tests
tests for swamp macro
-
adjacent-pair-iterator
An iterator over adjacent pairs in another iterator
-
typed_index
A strongly typed Index that know what it is indexing
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
bp3d-util
template
-
separator
Formats numbers into strings with thousands separators for readability
-
murrelet_livecode_macros
livecode macros for murrelet, a livecode framework
-
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
structre
Static-checked parsing of regexes into structs
-
iter_fixed
Iterator of fixed length
-
ghost
Define your own PhantomData
-
pstd
parts of Rust std library ( different implementations, features not yet stabilised etc )
-
open-hypergraphs
Data-Parallel Algorithms for Open Hypergraphs
-
nonany
Integer types with customizable niche values
-
nolife
open a scope and then freeze it in time for future access
-
borrow-framework
More flexible borrowing
-
ship
Sail your configuration files
-
makepad-live-id
Makepad live id symbol interning
-
notedown-error
Notedown Error Handlers
-
fluent-string
Fluent versions of String mutation methods
-
cast_checks
A procedural macro to check for invalid casts
-
shorter-bounds
Write shorter bounds with a trait alias macro
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
duplicate_macrotest
Fork of the macrotest crate specifically to test the duplicate crate
-
approxim
Approximate floating point equality comparisons and assertions
-
deep_safe_drop
Safe dropping of deep trees that otherwise could cause stack overflow
-
nil
Noxmore's Ixperimental Lutilities
-
simple-logging
logger for the log facade
-
grid-iter
Ideomatic Grid operations via Iterators
-
limbo_ext
Limbo extensions core
-
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
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
supply
Provider API for arbitrary number of lifetimes
-
serde_table
Write structs in an easy table format
-
rustato
A global state management library for Rust applications
-
cheap-clone
A trait which indicates that such type can be cloned cheaply
-
cubob
Structured output helpers for display mode
-
utilz
miscellaneous utilities too small for their own crates
-
array_trait
A generic trait for any array, with item as type and length as const parameter
-
trybox
stable,
no_std-compatible, fallible heap allocation -
flagger
Enum flag generator
-
iter-identify_first_last
A helper iterator, flagging first and last elements
-
quickfork
A meta package manager and programming assistant
-
ref-ops
An escape hatch for implementing
opstraits for references to newtypes -
fx-callback
A subscription based callback to inform subscribers about relevant data events within structs
-
wipe-on-fork
A replacement to OnceCell, LazyCell, Once, OnceLock, LazyLock that wipes itself when being forked in Unix
-
clap-doc
Create markdown descriptions for
clap::Commands -
macon_api
builder macro-based generator with its own idioms
-
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
safe-string
safe interface for interacting with multi-byte strings in Rust, namely IndexedStr, IndexedString, and IndexedSlice
-
stroka
Small String optimization
-
rw-exact-ext
Extension of std::io to read and write data types with exact amounts of bytes
-
anyreader-walker
reading streams of compressed and uncompressed data without knowing the format in advance
-
cowstr
Copy-on-Write shared strings
-
clsx
A flexible class name composition utility for Rust, inspired by clsx and tailwind-merge
-
enumcapsulate
Safe casting for newtype enums and their variants
-
sudo_plugin
Macros to easily write custom sudo plugins
-
region_local
Isolate variable storage per memory region, similar to
thread_local! -
tamanegi-error
detail of
tamanegi-errorcrate -
return_crusher
A shitty tool to crush a function body into (technically) one return statement using tree-sitter. Won't work for non GNU C syntax or loop with exits or returns.
-
sandkiste
Language independent scripting language sandbox API
-
core_io
copy of libstd::io with all the parts that don't work in core removed. Most importantly, it provides the Read and Write traits. This crate is (mostly) automatically generated from the rust git source…
-
cs_epic_api
APIs for epic, a simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format
-
culpa
error-handling syntax in Rust
-
ast2str
pretty-printing ASTs and other recursive data structures
-
scout-lexer
A web crawling programming language
-
plain_hasher
Hasher for 32-byte keys
-
sodium
FRP (Functional Reactive Programming)
-
rangeset
Integer collection backed by ranges with set operation support
-
constructivism
Simplify the construction of structured data
-
unsafe_cell_slice
A microlibrary for creating multiple mutable references to a slice
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
http-error
Error trait to help convert errors to http error responses
-
type_reflect
Extensible runtime reflection through a Derive macro
-
karen
Detect if you are running as root, restart self with sudo or any other wrapper if needed or setup uid zero when running with the SUID flag set
-
xmacro_lib
macro engine for producing multiple expansions
-
carykh-macro-rust
macro for finding strings that contain self-referential numbers. Inspired by carykh. This description contains twenty-seven words, fifty-four vowels, and ninety-nine consonants.
-
smt-str
working with SMT-LIB strings in Rust
-
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
the-string-macro
The missing
string!macro to constructStringvalue from string literal -
error_handling
Macro used to clean and centralize error handling within async processes
-
pretty-error-debug
If the process ends with an
Error, write out theErrormessage and chain -
hlua
Zero-cost high-level wrapper for Lua
-
my_tuple
A pretty implementation of tuple
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
pyo3_special_method_derive
Automatically derive Python dunder methods for your Rust code
-
shuriken-bindings
Safe bindings for the [Shuriken bytecode analyzer
-
cgp-error-eyre
Context-generic programming error handlers implemented using eyre
-
proc-easy
Macros to make writing proc-macro crates easy
-
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
-
tiny-tools
a tiny collection of helper utils
-
portable-io
“ A subset of Rust
std::iofunctionality supported forno-std -
superstruct
Versioned data types with minimal boilerplate
-
tuplemagic
manipulating tuples through various operations like mapping, filtering, nesting, and reducing
-
strprintf
Provide a way to interpolate printf-style format strings using native Rust types. Part of libnewsboat lib dependencies
-
golangify
published at 01.04.2024 this crate brings familiar flavor for newcomers from golang
-
nougat
(lifetime) GATs on stable Rust
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
destructure_traitobject
Unsafe helpers for working with raw trait objects. (Forked from traitobject)
-
vnum
Create enums with a constant value associated to every variant
-
dilib
A dependency injection library for Rust
-
numtest
Unit testing for numerical methods
-
zero_v
implementing iterators over function outputs for collections of types implementing a common trait, without using vtables/ dynamic polymorphism
-
isbn
handling ISBNs
-
friperms
framework for creating typed permission models for whatever system you could phatom
-
tuple_split
An extension for the tupleops crate which adds a trait for splitting tuples
-
const-type-layout
Derivable const trait to view and compare the layout of a struct, union, or enum
-
singleton-manager
A programatical singleton manager
-
granite
Generic backing storage framework for building data structures
-
mago-interner
A string interning library that stores and reuses identical strings efficiently, improving memory use in large codebases or tools
-
once_cell_serde
Single assignment cells and lazy values
-
not-found-error
Convert Option to Result using convenient functions
-
impl-opaque
Macro for declaring complex struct and initializer
-
lichen
Scripting DSL (for Dialogue Graphs, et al)
-
progress-streams
Progress callbacks for types which implement Read/Write
-
early_returns
Macros to make early returns easier to work with in Rust
-
weak_true
Similar to the automatic implicit conversion to boolean values in weakly typed languages
-
ffi_time
FFI assistant for Rust time types
-
vector3d
3D vector type
-
ir_aquila
personal utility library, not for public use(yet)
-
marker_trait
Implement a blanket implementation for a marker trait
-
reax
A reactivity system for Rust that infers dependencies between functions
-
windows-helpers
Helpers for the windows crate
-
implicit-fn
A macro that adds support for implicit closures to Rust
-
cve-rs
Blazingly fast memory vulnerabilities, written in 100% safe Rust
-
piston-float
Traits for generic floats in game development
-
custom-format
Custom formatting for Rust
-
paracord
A fast, simple, multi-threaded string interning library
-
abcgen
A procedural macro to generate boilerplate code for objects implementing the 'Actor' pattern
-
bitmask
generator for enum scoped bit flags
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
stackmap
A fast stack-only hashmap for small high-performance scenarios
-
ref_wrapper
Wrapper of dynamically borrowed data
-
cs_epic_wallet_impls
Concrete types derived from libwallet traits
-
tri_ton
A Macro for Handling Exceptions
-
lifted
Higher-kinded types in Rust
-
despatma
Design Pattern Macro like Loki
-
kurtbuilds_regex
Wraps the regex library to also provide macros
-
poison-guard
maintaining sane state in the presence of panics and failures
-
macro_error
A macro to display error message
-
enum-unitary
Trait and macro for unitary enums
-
nzliteral
Macro simplifying use of NonZero literals
-
elor
Base generic implementation of an Either type
-
collect_exact
Allows zero-cost collection into exact-size arrays and tuples
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
nade
Adding named and default arguments to Rust functions
-
docpos
Compact-document items after defining them (fn, struct, enum) + document fn parameters with rustdoc (⑂roxygen)
-
yukon
trait for the ability to cheaply duplicate an object
-
methods-enum
Two macros for easy implementation of 'state' design pattern and other dynamic polymorphism using enum instead of dyn Trait
-
smol-symbol
compile-time globally unique, 25-character, 128-bit symbols similar to the Symbol type in Crystal Lang
-
macro-attr-2018
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
seesaw
generate traits from C header files
-
declarative_enum_dispatch
Declarative macro generating boilerplate for enum dispatch
-
first-err
Find the first Err in Iterator<Item = Result<T, E>> and allow iterating continuously
-
errno-dragonfly
Exposes errno functionality to stable Rust on DragonFlyBSD
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
unwrap_or
Four easy unwrap Result and Option macros that allow for any inline-scoped code for things like return, continue, and break
-
chainchomp
Tinyest Opinionated parser combinator library for Rust
-
yugen
Writing rust like python
-
notzero
macro for constructing
std::num::NonZero*from constants -
const-macros
Various macros for const contexts
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
enum-update
representing state changes as enums
-
trustmebro
macro that magically turns unsafe code into ‘totally safe, bro’ with no consequences. Ideal for those who want to assert dominance over the compiler and live on the edge of catastrophe.
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
chalk-macros
Macros for Chalk
-
graphql-starter
GraphQL starter kit
-
syrette
The convenient dependency injection framework
-
enum_downcast
Safe downcasting for enums
-
cmdstruct
A lightweight macro for implementing commands with a struct
-
choices
HTTP configuration service by defining a struct
-
overloaded_literals
Overloaded Literals to construct your datatypes without boilerplate and with compile-time validation
-
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
match-commutative
Match on patterns commutatively, reducing the use of duplicated patterns. ↔️
-
illicit
An implicit thread-local environment which is indexed by type
-
thin_cstr
An experimental crate which provides a truly thin std::ffi::CStr
-
rs_filter
filter library for matching on complex data structures
-
our-string
Customizable shared strings with inlining
-
softfloat-sys
Rust bindings for Berkeley SoftFloat 3
-
has-some
The opposite of is_empty (and is_empty for filters)
-
esync
This package contains some useful synchronization primitives
-
nyar-error
Error types for valkyrie language
-
error_mapper
standardized Results and Errors handling accross all your projects
-
coded
concrete error type with an
ErrorKindenum matching Google’s “canonical error codes” -
anthill-di
Rust di containers system
-
variant_counter
Rust's Enum variant counter
-
teo-teon
Object notation for Teo
-
as_num
Checked conversions between Rust's numeric types
-
runestr
User-perceived characters related types and data structures
-
backyard-nodes
Nodes representing PHP code AST
-
effing-mad
The hottest algebraic effects library in Rust
-
flexi_func_declarative
exposes the fb! macro to create a function with a flexible signature
-
tuple_list
macro-free variadic tuple metaprogramming
-
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. -
isolator
A lightweight library for isolating Rust functions
-
control-flow
A hack to control control-flow outside closures
-
defer-lite
A lightweight high-performance implementation of Go's defer statement
-
rama-error
error types and utilities for rama
-
chasa
A parser combinator with
manytaking iterator, conditional branching, and method chain -
zzz
Fast progress bar with sane defaults
-
tao-of-rust
《Rust编程之道》随书源码
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
shared-type
Shared type alias and several traits to simplify working with Arc<Mutex<T>>
-
maybe-uninit
MaybeUninit for friends of backwards compatibility
-
abstract-impl
Create abstract implementations for traits
-
description
like Display, but 'static
-
annasul_macro
annasul: macro library
-
bty
Streamlined definition and usage of branded types in Rust
-
summum-types
A sum-type macro crate with all the conversions, accessors, and support for abstract methods across variants, and interoperability between sum-types
-
pl-lens
support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
aspect
Toolkit for Rust
-
assert_unordered
A direct replacement for
assert_eqfor unordered collections -
newer-type
Support defining newtype wrapper with inheriting trait implementations
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
generic_graph
implementing general purpose graphs. Including some default implementation (the latter are still WIP)
-
jget
Rust tools
-
laxcow
Clone-on-write smart pointer with relaxed trait constraints
-
option-ext
Extends
Optionwith additional operations -
prev-iter
Iterator which allows you to view the previous element
-
derive-name
Derive macro to get the name of a struct, enum or enum variant
-
panda-re
The official library for interfacing with PANDA (Platform for Architecture-Neutral Dynamic Analysis)
-
scoped_thread_local
Highly flexible Scoped thread local with HKT builtin
-
table_enum
A convenient rust macro to create enums with associated constant data (note: this is different from normal rust enums which are really tagged unions)
-
inline_dyn
A container type for storing dynamically-sized types inline
-
rs-std-ext
An extension for the standard library
-
static_str_ops
A package allows using static strings with non-trivial operations, e.g.,
concat!,format!,call_once, and more -
singleton-attr
singleton procedural attribute and derive macro
-
market
Infrastructure for producers and consumers
-
entwine
Generic slice-like interface for operating on multiple slices at the same time
-
circomspect-parser
Support crate for the Circomspect static analyzer
-
eventually
using Event Sourcing in Rust applications
-
incomplete
incomplete!(), a compile-time checked version of unimplemented!()
-
gostd_builtin
Package builtin binds the basic type in go through the type alias, and implements the basic type cast macro function.builtin 包通过类型别名绑定Go中的基础类型，并实现了基础类型强制转换宏函数…
-
butcher
An easy way to interact with structs and enums wrapped in Cows
-
tiny-input
Tiny input macros
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
drop_guard
enables you to implement the Drop trait on any type. So you can run a closure on any value running out of scope
-
throw
Efficiently add statically-calculated stack traces to errors
-
fn_macro
函数宏
-
io-adapters
Adapters to convert between different writable APIs
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
consume_on_drop
A zero-cost abstraction that allows Drop::drop to consume self by value
-
proto-mapper
A Macro library for easier mapping between custom models and proto generated code
-
named-block
Macro implementing early-exit-from-any-block
-
physical-quantity
dimension and unit system for general physical physical quantities
-
roopert
object-oriented toolkit for Rust
-
fuck-backslash
replace the backslash with slash in-place in your PathBuf
-
fixed-macro-types
Macro aliases used in the
fixed-macrocrate -
dyn-dyn
Flexible trait object downcasting using ptr_metadata
-
check
Convenience assert!-like macros which return instead of panicking
-
borrow
Zero-overhead, safe implementation of partial borrows. This crate allows you to borrow selected fields from a struct and split structs into non-overlapping sets of borrowed fields.
-
qm-utils
functions and macros
-
nix-compat-derive-tests
Nix protocols and data formats
-
bit_roles
Granular role management based on bit flags
-
utility-macros
emulate Utility Types and Unions from TypeScript
-
lazyinit
Initialize a static value lazily
-
refl
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 -
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
str-macro
The str!() macro, similar to vec![] but for strings
-
const_struct
macro that allows const structures to be passed as const generics
-
rtlola-reporting
An error reporting crate for RTLola-related crates
-
struct-metadata
Macros for attaching metadata to structs
-
parse_rust
Python's parse library for string parsing and pattern matching
-
lset
Data types describing linear sets
-
structz
Anonymous struct implementation in rust
-
cifg
A macro for defining #[cfg] if/else blocks; alternate to cfg-if
-
fmttools
Tools for modifying text without allocating any intermediate buffers or unsafe code
-
hado
Monadic do notation using a macro
-
adhesion
A set of macros for design by contact in Rust. The design of this library was inspired by D's contract programming facilities.
-
safe-discriminant
A minimalistic,
no_stdcompatible trait and procedural macro for extracting discriminants from enums at zero cost -
apparat
A lightweight event-driven behavioral state machine
-
ryu_floating_decimal
Fast floating point to floating decimal conversion. See the crate 'ryu' for more details
-
unarray
working with uninitialized arrays
-
cond
Rust macro to use a match-like syntax as an elegant alternative to nesting if-else statements
-
heapsz
calculating the heap usage of a data structure
-
yadir
Dependency Injection Registry for Rust
-
shoogah
Add some syntactic 'shoogah' to Rust
-
combin-iterator
Some usefull facilities for combining iterators
-
plain_enum
Mimicing Java's enum::values() and EnumMap
-
tuple-traits
Additional tuple traits to enable ergonomic types
-
zerror_full
macro for implementing helpful errors
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
smart-string
A collection of string types and traits designed for enhanced string manipulation
-
diman_lib
Commonly used types for internal use in diman
-
sly_static
Seamless Rust Static Initialization: Effortless and Efficient
-
romap
A trait for read-only-maps
-
accompany
with-like macro for Rust -
pre
Compile-time assistance for working with unsafe code
-
except
The only one
Error -
docsplay
A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
squeak
providing types allowing execution of callbacks in response to values being broadcast or mutated
-
type_ulid
Trait for associating ULIDs with Rust types
-
scoped-writer
Scoped writer utility
-
selfref
Semi-pain-free self-referential pinned types
-
handled
error handling library
-
deki_lerp
linear interpolations!
-
const-exhaustive
Enumerate all values of a type at compile time
-
retrying
General-purpose retrying library for Rust with macros and functions
-
typemap-meta
compile-time macro to create type-to-value maps
-
fn_zip
zip trait for functions, allowing two functions to be combined before being called
-
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
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
extension-eyre
Re-export of color-eyre that introduces Extensions (type-map) to eyre::Report
-
sdml-core
Core Model for Simple Domain Modeling Language (SDML)
-
should_error
The test should fail with Err
-
pgx-utils
functions for 'pgx'
-
simple_detailed_error
Stack and specify errors explainations saying what happened, why, how, where, how to solve it and its causes
-
rsor
Reusable slice of references
-
color-core
Color shared definition
-
spade-hir
Helper crate for https://spade-lang.org/
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
integer_or_float
A data type holding an ‘integer or float’ (a data type in the Unified Font Object specification, among others)
-
multer-derive
derive for constructign type from multer Multipart
-
panicking
std::thread::panickinganalog available in theno_stdcontext -
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
cfgenius
Conditional compilation with macro support in Rust
-
enum_delegate
Easily replace dynamic dispatch with an enum, for speed and serialization
-
nightly-quirks
A basic set of utilities that mimic nightly behaviour in stable Rust, with the possibility of using nightly implementation with the nightly feature
-
iter-progress
Calculate progress of your iterators
-
typed-sql
A strongly typed sql serialization/deserialization framework
-
char-device
Character Device I/O
-
hans-http
Writing a http request and http response safely
-
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
as-result
Traits for converting types which may be interpreted as or into a result
-
grouping_by
allows the user to group an iterator by various ways
-
benri
Convenient macros wrapping the standard library
-
twinsies
Smart pointer providing 2-way joint ownership of an object
-
result-ext
Extends
Resultwith additional operations -
opaque_typedef
Supports defining opaque typedefs
-
tc-error
TinyChain's generic error struct
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
copy_impl
Macro for effortlessly duplicating impl block code across various types in Rust
-
hurl_core
Hurl Core
-
thread-scoped-ref
that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
simplicio
Gets rid of the boilerplate in rust
-
irox-structs
Traits for Struct Types - linearly serialized big/little endian bytes
-
maybe_null
A pointer type for handling potentially null values without accidental dereference
-
pyo3_special_method_derive_lib
Automatically derive Python dunder methods for your Rust code
-
global-errors
sinsegye test runtime global errors
-
enum-display
A macro to derive Display for enums
-
externcfn
macro_rules for define correct extern 'C' functions with an normal syntax
-
error-graph
Allows non-fatal errors in a tree of subfunctions to easily be collected by a caller
-
comparator
A Java-like Comparator type
-
rexpr
Rust Json Object access Runtime
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
delegare
delegate struct easy
-
thiserror-ext
Useful extension utilities for
thiserror -
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!,include!, orconcat_idents!) -
enumx
Ad-hoc enum extension
-
assemblist
Define your builder patterns as you use them
-
almost
comparing floating point numbers
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
enum_handler
A macro to generate a handler trait for enums variants
-
astr
A const lenght stack str
-
ebacktrace
error wrapper which captures a backtrace and can carry an optional textual description
-
test_help-rs
Test helpers for Rust
-
crosstrait
Cast from
dyn Anyto other trait objects, with no_std, no alloc support -
set_derive
Using Macros to Implement List comprehension Similar to Python Language
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
aorist_primitives
Primitive macros for the aorist project
-
rust_kafka_like
A Kafka-like message broker in Rust
-
err_mac
no dependency macro for creating error enums with automatic
Fromimplementations -
pingora-error
Error types and error handling APIs for Pingora
-
yikes-intenum
Augment integer-based enums with an unknown variant; a macro that makes you say "yikes!"
-
boost-rs
boosting your develop productivity on Rust
-
veccell
variant of Vec with interior mutability
-
anyhow-std
Wrap std APIs with anyhow error context
-
koute/nes
emulator written in Rust
-
type-sets
Sets implemented in the rust type-system
-
wtflip
A language in a Rust macro... or something.
-
min-max
max! and min! macros
-
applying
Apply functions in method-position
-
veho
a iterable toolset
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
cbsk_mut_data
ref mut tool
-
frunk_laws
contains laws for algebras declared in Frunk
-
better_any
Type id and Any for non static types
-
automap
pattern to implement key-value maps where the value type contains the key type
-
string-literals
Rust macros to more easily create String types
-
derive_constructors
Deriving From, TryFrom and create new_with_*args* functions
-
culprit
error crate with the goal of identifying precisely where and in which context an error occurs
-
emboss_common
Common types and constants for emboss
-
crete
Ergonomic, thread-safe & flexible state management
-
diesel_derives_traits
Traits for diesel_derives_extra
-
effective
An effects library, an alternative to keyword generics
-
iterator_item
a generator syntax experiment
-
isclose
A collection of trait and macros for comparing approximate equality
-
sql_tool_core
这个库是 sql_tool_macros 库的核心，存储 trait
-
doc-image-embed
Embed images in Rust documentation
-
shared_singleton
trait provides singleton pattern state management with shared container
-
projecture
Easy arbitrary type projections without proc macros
-
interning
Thread-Lcoal and Global Interning Library
-
traitreg
Create a registry of implementations of a trait
-
containerof
Macros and traits facilitating the use of intrusive structures in Rust
-
high_mem_utils
bunch of mem safe abstractions,some involving transmute
-
rvs
defining and evaluating random variables using a simple DSL
-
hand
Easy to use, pretty cmd log for lazy devs
-
imgref-iter
A small crate for iterating over the rows or columns of
imgrefbuffers -
mini-macro-magic
Export tokens to other modules and crates. Now with 100% less proc macros!
-
unwrap-macros
Convenience macro for unwrapping result and option
-
srcerr
User friendly errors from source data
-
aliri_macros
Macros used by the
alirifamily of crates -
vec-string
To print Vec<Display>
-
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…
-
wg-utils
Personal Utility Functions
-
log_limit
A rate limiting logging crate
-
scientisto
A light-weight Rust implementation of the github/scientist library used for careful refactoring of critical code paths
-
once
assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
tryiter
functions for Iterators of Results
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
tcp-struct
Share structs over tcp
-
kust
Kotlin-like APIs for Rust
-
bestbefore
A procedural macro for marking code with expiration dates
-
actix_error_proc
A small crate to integrate thiserror with actix_web
-
buffer
Safe, write-only, generics-free buffer abstraction
-
str_stack
string allocator for allocating many write-once strings. This library is primarily useful for parsing where you need to repeatedly build many strings, use them, and then throw them away…
-
ffizz-header
FFI helpers to generate a C header for your library
-
defer-rs
Deferred execution Rust utilities
-
llinks
-
partialdebug
Derive Debug partially
-
haz
A thin abstraction over polymorphic environments
-
pluck
Extract values conveniently
-
zonbi
Type-Erase tools for non-
'statictypes -
undo_stack
A minimal undo stack for user defined types
-
desaturate
This package aims to makes it easier to maintain a single code base for both regular and async functions
-
functor_derive
A derive macro to derive a functor for a type
-
ad-hoc-iter
Ad-hoc exact size owning iterator macro and other optional utils
-
mapcomp
Python-like list comprehensions for standard containers
-
enum_variant_macros
Macros to generate From & TryFrom for enums
-
pass_by_catastrophe
Please do not use this
-
bswap
byte-swapping integers, pointers, and slices
-
serde-textual
derive Display/FromStr by using serde
-
standback
New standard library, old compiler
-
wx-core
微信数据解析工具
-
bytify
macro that can write given const-expr values into a continuous byte array
-
ez-err
error handling library with support for ergonomic and fast error handling
-
objid
Generate a random object identifier
-
tailsome
Blanket traits providing
.into_ok(),.into_err(), and.into_some()for happier method chaining -
new_type
Experimental implementation of newtypes by type level logic
-
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
jnt
full of just neat things
-
internship
Interned string and more
-
zipped
recursively unzipping tuples, Options of tuples and Results of tuples
-
dyn-error
Error-related utilites for Rust
-
trait-union
Stack-allocated trait objects
-
tea-error
creating custom errors for tevec
-
cisness
Runtime 'live witness' of two types being the same
-
pigeon-core
Generate recursive-descent & precedence climbing parsers. (traits)
-
tryvial
Small crate for ok-wrapping and try blocks
-
collection_literals
macros for initializing std::collections
-
enum_to_enum
Derives possibly effectful conversions between enums
-
unused
Allows for unused generic parameters that do not act like they are owned
-
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
-
free-wrap
Provide a easy way to define NewType Wrapper
-
std_io_iterators
An iterator for
STDINand a wrapper forSTDOUT. Allows easy piping, and graceful closing of application if pipe breaks -
tapir
Adding tapping functionality to rust
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
unwrap_none
Implements the
unwrap_noneandexpect_nonemethods removed by https://github.com/rust-lang/rust/pull/83349 -
rsb_derive
An opinionated macro implementation for Rust struct builder pattern with compile-time validation
-
fsize
fsizeis aliased to the floating-point type of pointer size -
ocapn-netlayer
OCapN transport layer interfaces and types
-
smartcow
a cow for smartstrings
-
flow-control
Declarative macros for common flow-control use cases such as break, continue, and return
-
lup
A custom indexed loop macro library for Rust
-
cantor
A general toolkit for working with types that have a small number of values
-
iterator-ext
An extension to Rust's Iterator
-
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
uwuizer
Rust Macro to UwUize your text. UwU.
-
collar
easy array collection
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
airbrake
(https://airbrake.io) notifier library for the Rust Programming language. The library provides minimalist API that enables the ability to send Rust errors to the Airbrake dashboard.
-
tch-tensor-like
Derive convenient methods for struct or enum of tch tensors
-
sized-dst
Owned container for dynamically-sized types backed by inline memory
-
head-tail-iter
An iterator that repeatedly splits head & tail
-
open-vaf
A compiler frontend for VerilogA aimed predominently at compact modelling
-
dcss-scenario-builder
A scenario builder for DCSS Webtile
-
nonasync
A set of utilities useful for building a non-blocking non-async APIs
-
enum-derive-2018
macros for deriving additional functionality for enums
-
memory-size-type
A data type for dealing with memory sizes
-
context-iterators
Iterators adaptors with associated read-only data
-
peeking-iter
An iterator adapter that allows infinitely-deep peeking
-
enum_pipeline
way to use enums to describe and execute ordered data pipelines
-
phantasm
Small lib that helps with variance
-
deadlocker
Bringing builder pattern to defeat deadlocks
-
permeable
A permission-demand trait. Decouples the permission-demander from the permission / auth provider.
-
linq
Language Integrated Query in Rust
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
inherent
Make trait methods callable without the trait in scope
-
gur
A undo-redo framework
-
read-restrict
Restrict the number of bytes read from a reader
-
kstring
Key String: optimized for map keys
-
dbg_unreachable
Switch between unreachable! and unreachable_unchecked with a single macro
-
funlib
Rust functional library
-
try-lazy-init
Fallible lazy initialization
-
ghost-lite
custom PhantomData types
-
multindex
Index slices with multiple const indices/ranges
-
racer-interner
thread-local string interner for racer-rust
-
holium-rs-sdk
Holium Rust SDK
-
rs-category
Categorical traits
-
warnalyzer
Show unused code from multi-crate Rust projects
-
cgp-error-std
Context-generic programming error handlers implemented using
std::error::Error -
curerr
easy error handling
-
gitoxide-core
implementing all capabilities of the gitoxide CLI
-
bit
helpers to manipulate bits and bit ranges
-
kube-core
Kube shared types, traits and client-less behavior
-
sensulator
sensor simulator, provides noisy readings of ideal measurements
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
cgp-extra
Context-generic programming extra meta-crate
-
nyar_valkyrie
-
lurk-ipld-macro
lurk-ipld macro
-
cubiomes-sys
Raw ff binding for the cubiomes library
-
cryo
Extend the lifetime of a reference. Safely.
-
debug-fn
A function adapter that implements Display and Debug
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
whiteout
macros that erase the type of any value into an impl Trait for a given trait
-
type-factory
unique opaque types
-
rigz_error
Includes the definition of the RigzError enum
-
the-newtype
The Newtype trait
-
audi
Generic listener abstraction
-
unwrap-enum
generate methods to access enum variants
-
enum_macro
Useful macro for enum
-
holder
getter setter auto gen with holder trait
-
ddd-rs
Domain-Driven Design (DDD) building blocks, for Rust applications
-
retry-policy
Retry Policy
-
scout-interpreter
A web crawling programming language
-
prae
that aims to provide a better way to define types that require validation
-
nonicle
Tools for type-safe, canonical data representations
-
name-it
Give a name to async fn return types
-
fold-license
Folding licenses from multiple dirs with
cargo/Cargo.toml andyarn/package.json -
dyn-eq
Test equality between trait objects
-
stackerror
A pragmatic error handling library for Rust that provides helpful strings for debugging, and structured data for runtime error handling
-
standard_test
A set of tests checking the properties of your impls of std traits
-
id_sys
data structures which can be marked such that they only work with similarly marked integer data types
-
elvish
Overengineered Advent of Code framework - not quite Santa's elves
-
noir
rust based, DSL alike and request driven, black box testing library for HTTP APIs
-
chassis
Compile-time dependency injection framework
-
unwind_safe
Readable unwind-safe code thanks to a try-finally-looking builder pattern
-
sequin
enumerate the sequential values of a type
-
partially
Partial trait, and an optional macro to mirror a struct, wrapping each field in an Option
-
hereditary
Procedural macros for emulating OOP Inheritance in Rust
-
seventy
Newtype sanitization and validation
-
hipblas-sys
Bindings for HIP blas
-
tracel
SDK
-
hb_error
Useful macros and traits for creating and handling errors
-
captur
Macro to capture whole structs from disjoint fields in a closure
-
string-builder
string builder type
-
ownref
Provide the smart pointer type that bundles the data with its owner
-
tupl
Perform generic operations on tuples
-
oop
Object-Oriented Inheritence in Rust
-
sod-crossbeam
Service Oriented Design - Crossbeam
-
inline-const
Inline consts implemented as a macro
-
dev_bestia_url_utf8
url utf8 encode/decode
-
unroll_range
Repeats a block of code for each number in a specified range
-
wgsl-types
WGSL Types
-
crossdylib
Cross-platform shared state across shared libraries/modules
-
async_fn_traits
Trait synonyms for “Fn[…]”-trait bounds returning futures
-
coi
Dependency Injection library
-
peekable-fwd-bwd
Iterator Peekable with multi-forward-peek and multi-backward-peek
-
easy-ffi-wrapper
Types and utilities to enable writing C FFI wrappers easily
-
impl_ops
Macros for easy operator overloading
-
stuff
Stuffing things into pointers
-
globiter
Replace with description
-
r-ex
Zero-bloat Rust core library extensions
-
controlflow_inspect
inspect_* methods for ControlFlow
-
doxed
making Rust doc strings available at runtime
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
shallowclone
Traits for working with copy-on-write types more efficiently
-
regexm
macro for writing regex pattern matching
-
num-sign
enum Sign { Positive = 1, Negative = -1 }
-
derive_variants
derives an additional enum from a nested enum that contains only variants and no nested fields
-
kinded
Generate enums with same variants, but without data
-
s-string
s!() macro for quick String::from()
-
look_inside
Look inside structs, enums, and unions!
-
enum-tags
A Derive-Macro library that generates a companion tag-enum for any enum so that variants can be referred to without specifying fields
-
kmacros
Useful macros
-
derive
providing a minimal example of a derivable trait (via companion crate derive-derive) for testing and illustration
-
extract-variant
Destructure expressions into, and return assignments from, a single pattern
-
arc_macro
A macro wrapper around Arc::new() for convenience
-
oxydized-money-macros
Companion library to oxydized-gains providing convenience macros
-
enum_ext
procedural macro that enhances enums with additional methods and conversions
-
codespan-derive
derive(IntoDiagnostic) for easy codespan integration
-
box-dyn
Macro to derive the implementation of Trait for Box<T: Trait>
-
pin-init
Safe pinned-initialization in Rust
-
cart_prod
Cartesian product of iterators
-
error_status
Model common error context with HTTP 4xx and 5xx code
-
fluid-macro
Write long method chains as a series of steps instead, and more!
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
edisp
Dispatch-on-collect for Rust enums
-
repeated
Allows you to repeat a block of code a number of times
-
path_semantics_std
type checked implementation of the standard dictionary of path semantics using constrained functions
-
bagel
Compile-time evaluation and other tools
-
limnus-local-resource
local resource storage
-
cereal
data serialisation library
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
slip
A hassle-free utility to encrypt error handling strings in your public binaries to protect your business logic
-
portaldi-core
Core functionalities for portaldi
-
buggy
A less panicky replacement for unreachable!() and unwrap
-
size
expressing, formatting, and interacting with file sizes
-
gtk_widget_macro
A derive macro helps you handle Gtk widgets
-
try_buf
no-panic API for bytes::Buf
-
loop-let
An immutable loop structure that can be used as an expression
-
ratelimit_rs
The ratelimit package provides an efficient token bucket implementation
-
mvcc_cell
Software-transactional memory for Rust
-
static-cow
Cowat the type level: a framework of traits for writing types that are generic over ownership of their contents -
multiline-str
multiline string Rust macro, which allows you to write multiline strings in a more readable way. It allows for any combination of space-joined and newline-joined strings.
-
iter_peek_end
current element the last one of a peekable iterator ? (
is_last()andis_not_last()) -
cpp_to_rust_generator
Automatic generator of C++ library wrappers
-
type-variance
Marker traits for subtype variance
-
dry-mods
Macros to make your module management DRY
-
infix_macro
macro that generates the neccesary boilerplate to use "*operator*" infix functions
-
eager
macro expansion
-
macro_lisp
Lisp-like DSL for Rust language
-
tiny-ordered-float
Tiny version of OrderedFloat
-
string_error_wrap
providing a macro for an error type wrapping a String
-
find_all
A (nearly) identical alternative for
Iterator::findwhich returns anOption<Vec<usize>>containing all elements which meet a given predicate (instead of just the first) -
c8str
String types that are both utf-8 and null terminated
-
kommons_macros
a set of macros with utils
-
zachs18-stdx
My commonly used extensions to std APIs
-
unsafe-any
Traits and implementations for unchecked downcasting
-
typestate-builder
Derive-macro-based generator that combines
TypestateandBuilderpatterns -
mstr
2-word, immutable Cow<str>
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
stacker
A stack growth library useful when implementing deeply recursive algorithms that may accidentally blow the stack
-
lazy_bastard
A helpfull macro because writeing a seperate Default function is too much effort
-
null-terminated
slices and UTF-8-encoded strings with thin references
-
tagged-pointer-as-enum
A set of structs, traits and macros to implement tagged pointers
-
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
-
aggregate
attributes of structs for runtime
-
aranya-buggy
A less panicky replacement for unreachable!() and unwrap
-
read_buffer
ReadBuffer, a wrapper to safely read into a buffer from a Read
-
hazmat
A collection of helpers for working with hazardous materials in Rust crates
-
impl-converter-helper
declarative macro library to help you implement the
FromorTryFromtrait for your type -
simple-triple-buffer
triple buffer
-
podio
Additional trait for Read and Write to read and write Plain Old Data
-
ctjs
compile time javascript as a rust proc macro
-
humane_commands
Allows you to write more shell-like Commands
-
spanned_error_message
Pretty error messages with spans outside of proc macros
-
typesets
Enables generating subtypes and supertypes of a given type via derive macros
-
typenum-consts
Procedural macros that take a literal integer (or the result of an evaluation of simple mathematical expressions or an environment variable whose value is a literal integer) and convert…
-
tinytest
Write more compact unit tests with a small macro
-
assert-type-eq
Macro to assert types across potentially different crate versions are compatible
-
derive-for
Macro for defining structs using the same derive procedural macros
-
cronjob
scheduling your methods
-
quick-error
A macro which makes error types pleasant to write
-
en
The easiest numeric traits!
-
serialization_minecraft
encode and decode your struct
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
coercible_errors
Zero-cost error handling for generic traits
-
rollercoaster
Extra iterators for grouping, sorting, arithmetic, and more
-
cargo-verify
Prettier error messages for the verified crate
-
splop
Helper functions to determine the first/last repetition of something
-
axocli
common code for setting up a CLI App and handling errors/printing
-
burrtype
A framework for exporting types to other languages
-
materially
A macro for material implication
-
beard
Handy macro to generate formatted text in rust
-
classes
Dependency-free macro that simplifies the process of building class strings for DOM elements
-
johalun/module
FreeBSD kernel module in Rust
-
enum-extract-error
A companion crate for
enum-extractthat exports an error type -
init_with
Helper trait to initilize an array with a function
-
sha2-derive
exporting a derivable
Hashabletrait that works withsha2 -
wurm
Non-fatal, strongly typed errors
-
funkjon
One of the worst macros this world has ever been (dis)graced with
-
simple-undo
Easy to use undo-redo library
-
abort_on_panic
Intercept panic! from unsafe locations and abort the process
-
pin-utils
pinning
-
iter_from_fn
Create iterator from repeatedly aplying a function that takes no parameters
-
for-loop-iterator
Iterators like traditional for loops
-
trait_enum
Easy enum wrapper that implements all traits that the wrapped objects implement
-
log_err
Log error messages from Unwrap and Expect with log crate
-
extracterr
helper type and traits for passing context through dyn Error trait objects
-
concat_strs
Macro for quickly building a String from components
-
cron_macro
cron macro
-
json_extract
This macro reduces boilerplate when using serde_json::Value variants when trying to get into a nested property
-
taker
Option-like taking for everyting with a default value
-
postfix-macros
Postfix macros on stable Rust, today
-
foreign-types-shared
An internal crate used by foreign-types
-
wrappr
A libary for some useful wrapping traits
-
truthy
Check if a value is "truthy"
-
letr
The macro for the lazy
-
iceyee_error
Error Message
-
tracing-assert-macros
A macro for capturing trace logs
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
intfloat
Fast and simple hashable float alternative using ints
-
scoped-threadpool-std
scoped threadpool implementation and related tests including a password hasher
-
variant_count
Derive macro for enum which adds to it the count of variants
-
unwind-unsafe
Zero-sized marker types which do not implement UnwindSafe or RefUnwindSafe
-
async-convert
Async TryFrom/TryInto traits
-
input-macro
No-nonsense input!(...) macro for Rust
-
tlbf
Type level bitflags
-
rerast_macros
Macros for use in Rerast rules
-
higher-kinded-types
"Generic generics" / higher-kinded APIs in stable Rust
-
convertnumber
illustrate number conversion from float to integer, I was trying out
implandtraitsand thought it was cool to build something from it -
power-assert
Power Assert in Rust. Provides better assertion message.
-
microtype
simplify the creation of microtypes
-
tyenum
Attribute macro for type enums
-
combine_traits
A Macro to create Traits wich are just a combination of existing ones
-
typology
Type derivation for foreign use
-
rust-enum-derive
(and program) for generating rust enums and associated traits from text files
-
liftor
Functors for Rust lifetimes
-
helper
provided some useful proc macros for Rust
-
size-trait
Traits for restricting the size of type parameters
-
iter_accumulate
An iterator adaptor that accumulates the elements and yields the current accumulated value for each iteration
-
zip_clone
Zip an iterator to a repeately cloned object
-
breakable-block
A shim library for a stable implementation of what is proposed in RFC 2046
-
xstd
eXtended STandarD library
-
rustc-ap-rustc_lint_defs
Automatically published version of the package
rustc_lint_defsin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
commandspec
Rust macro to build std::process::Command objects with shell syntax. Uses macro_rules! and works on stable.
-
fieldfilter
trait that lets you filter stuff!
-
vtable
Helper crate to generate ffi-friendly virtual tables
-
transient
Reimplementation of
std::any::Anywith support for non-'statictypes -
list_comprehension
A macro for Haskell-like list comprehensions in Rust
-
derive_destructure2_examples
Examples for crate derive_destructure2
-
wrapping-macro
wrapping macro
-
error_def
syntax extension for generating error-handling boilerplate code
-
bumpalo
A fast bump allocation arena for Rust
-
whaterror
Customizable handling for fallible main
-
sod-mpsc
Service Oriented Design - Multi Producer Single Consumer
-
srce
Self-Ref Cell Environments
-
rustils
Utilities for rust
-
itermap
Iterator tools for maps (
HashMap,BTreeMap, etc.) -
escher
Self-referencial structs using the async/await transformation
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
splitbits
Concise bit field extraction
-
tuple_tricks
A couple of traits on tuples that allow inductively building new traits
-
tor-async-utils
Async/futures helpers for use with Tor
-
typestring
String constants lifted into types. This is a stopgap until const generics support strings.
-
crates-io-macro-crate
An example macros-by-example crate for demonstrating a regression
-
macro-utils
Some macros to make code writing more elegant and funny
-
wedpr_l_macros
WeDPR shared macros
-
kind-derive
Derive generator the kind compiler
-
conventus
Traits for assembling and disassembling items
-
peak-result
trait that extends the standard Result enum to allow you to run some code in case of error or success
-
with-id
trait providing method for getting string id from struct
-
sm_dev
Math operations with safety checks that throw on error
-
easy_switch
A macro for traditional C-style switch statements
-
value_unit
every unit imaginable. Also contains a handy macro
-
comprehensive_dns
A DNS resolver for https://crates.io/crates/comprehensive
-
esvc-traits
Traits for ESVC
-
qed
Compile-time assertions
-
tangu
language
-
merge
multiple values into one
-
mist-pdk
mist plugin development kit
-
persian_str_rs
functions for working with Persian strings in Rust
-
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
common_macros
common macros like
hash_map!orhash_set!(WIP) -
dec-number
Decimal Floating Point Arithmetic for Rust
-
extrust
intended as an extension of the standard library
-
abi_stable_shared
detail of abi_stable
-
switch_statement
switch statement macro
-
try_utils
The try! macro descends into an enum variant. It's more flexible than ? and unwrap(), and it works with your enum, too!
-
for_each_repeat
Iterator::for_eachthat can repeat current iteration -
transmute_guard
Transmute between types that have been marked as safe by the marker type
-
strunemix
allows to build a struct with a form of its fields, by deriving enums of them
-
match_to_str
match pattern to str
-
tailwag_macro_inline
The logic for A collection of macros to support the tailwag crate
-
lock-free-freelist
A fast lock free limited length free list for multiple producer and consumer
-
cismute
Safely transmute type to itself in generic contexts
-
nested-ref
References to data contained in one or more nested RefCells
-
dto_derive
Derive for automatic mapping DTOs to Entities and vice versa
-
rustructure
Run-time introspection on compile-time flagged structures
-
io-read-line-prototype
Prototype for io::read_line
-
drng
A disjoint range implementation
-
rustkell
haskell like functions in rust
-
iota-rs
macro for other Go refuges who miss const blocks and iota
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
datastore
A generic store wrapper
-
phantomdrop
Go-like deferring of function calls
-
nonminmax
Primitives types which cannot be their minimum/maximum value
-
discard-while
Get the first non-matching element, and the amount of discarded elements
-
filters
Build filters/predicates with the builder pattern
-
label
functions and iterate over them
-
aranya-trouble
A wrapper to implement the Error trait
-
custom_float
Custom floating-point types
-
openapiv3-extended
data structures that represent the OpenAPI v3.0.x specification easily deserializable with serde
-
kittycad-execution-plan
A DSL for composing KittyCAD API queries
-
padlock
Safely acquire RwLock/Mutex locks
-
singleton-trait
Singleton trait for types with unique values and Erased type for zero-sized ownership proofs
-
retryable
Automatic function retry macro
-
slazy
small, no-std, macro-based lazy static library for Rust
-
iex
Idiomatic exceptions
-
extractors
lightweight library for extracting function call parameters from a provider
-
swamp-script-semantic
semantic types for swamp script
-
noticeable
lazy observables
-
ctrl_macros
Control flow macros for Option and Result
-
fat_type
A type which permits thin references to arrays and dynamic types
-
borrow_channel
A channel for borrows
-
from_variant
Automatically derive From impls for enums
-
citadel
-
synstructure_test_traits
Helper test traits for synstructure doctests
-
ndless-static-vars
storing static, program-wide parameters for Ndless
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
my_logger
marco to do logging in a file.log
-
dependent_ghost
Matt Noonan's 'Ghosts of Departed Proofs'
-
anony
Anonymous struct
-
xkcd_unreachable
macro xkcd_unreachable!() inspired by https://xkcd.com/2200/
-
mcurry
Macros for creating curried functions
-
dynstack
A stack for trait objects that minimizes allocations
-
string-eyre
Convenience traits for dealing with errors that don't want to eyre
-
persisted
Persist arbitrary program state quickly and easily
-
recursive_reference
way to walk on recursive structures easily and safely
-
match_any
declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
lia-plugin
Compiler plugin for writing Lia code as a macro
-
std_prelude
prelude that the rust stdlib should have always had
-
fieldx_plus
Design patterns built on top of fieldx crate
-
simt_hip_sys
part of simt. hip driver api bindings
-
roxy_core
transforming a readable input
-
ser_raw
fast serializer
-
parsel
Zero-code parser generation by using AST node types as the grammar
-
handlevec
Small abstraction over index-style iteration over a vector, with deletion, insertion, and other operations on the vector while iterating
-
spidermeme
Traits to test for type equality and type inequality
-
wrapping_macros
A macro for wrapping arithmetic
-
substrs
substring functionality for the str type in Rust
-
signrel
Trait expressing relationship between integers of different signedness
-
pennereq
Port of the Penner easing equations to rust
-
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
int
Integer traits
-
result_logger
aux functions for Results to log errors
-
evcxr_ssg
A convenience library for calling functions exposed to wasm in the jupyter notebook
-
source-chain
Formats StdError with it's source chain
-
phantom-enum
macro library for creating phantom enums
-
nb-from-env
A convenient way to construct structrual configuration from environment variables
-
len-trait
Len trait for collectons
-
loop_chain
Macro for writing nested Loop expressions
-
source-location
Container struct for source location data + construction macro
-
arcerror
thin wrappers around Arc<T> and Rc<T> where T: Error. Impls Error for both of these types. No unsafe, no dependencies.
-
rust_hawktracer_normal_macro
helper crate for hawktracer profiling library
-
value-bag-sval2
detail for value-bag
-
stackpin
data that should be pinned to the stack at the point of declaration
-
aeruginous
Open Source Development Toolbox
-
messages
Runtime-agnostic actor library
-
uzero
UZero
-
tupleops
work with tuples
-
kix
A result type for testing that supports to eliminate using of Result::unwrap
-
closure
A macro for capturing variables on a per variable basis
-
politeness-macro
Isn't it time to be a bit nicer to rustc?
-
fluent_builder
builder API
-
stable-step
Step for stable rust
-
atomic_refcell_try
Threadsafe RefCell
-
kinds
Higher-Kinded Types simulated by GATs
-
pes
Pe parse tools
-
kaboom
Intuitive library for Next-Gen application exiting
-
rhizomedb
RhizomeDB
-
html5ever_macros
High-performance browser-grade HTML5 parser − compiler plugins
-
formatx
A macro for formatting non literal strings at runtime
-
disuse
The way to notify the implementation which return value is disuse
-
kinder
small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
rust_bridge
The rust_bridge
-
flac-sys
Bindings for FLAC 1.3.2
-
thin-slice
An owned slice that packs the slice storage into a single word when possible
-
bytebuff
usefull derive macro for serializing data to send ower network
-
pfn
Provide fn_trait’s
call,call_mut, andcall_onceon Stable Rust -
esrs
A Prima.it-opinionated library to achieve cqrs/es
-
log-once
Collection of helper macros for logging some events only once
-
samsvar
trait for matching on custom types
-
sentry-error-chain
Sentry integration that allows capturing error-chain errors
-
actix-web-error
Derive ResponseError for your errors
-
cbrzn_msgpack
WRAP msgpack encoding standard
-
grit-junk-drawer
Collection of small utilities, types, traits, helpers, etc
-
validus
A string validation library
-
iter_vals
On the fly iterator creation
-
hold-macro
extended todo!() macro that can suppress unused value warnings
-
sync_stream
Aggregate multiple streams by polling stream items in order, keeping the consumption of multiple streams in sync
-
flow_impl
Definition of an Implementation trait for flow functions, and a derive macro
-
padded-iterator
An iterator that can be padded to a specified length
-
unwrap_or_log
adding two functions to all std::resut::Result to log errors using the log crate
-
scoped-sleep
RAII sleep
-
ulibrs
but universal library written in Rust
-
prgrs
progress bar for rust, that aims to work like the python package tqdm
-
traverse
Proof-of-concept trait for internal iterators called traversals
-
arc-interner
An interner that deallocates unused values
-
func
that helps creating colsures from function pointers
-
prost-uuid
ProstUuid new-type wrapper around uuid::Uuid with prost::Message implemented for it
-
rustbench
A lightweight Rust procedural macro for benchmarking function execution time
-
filecmp
comparing files and directories, the rust implementation for CPython filecmp module
-
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
yadi
Dependency Injection framework for writing applications with Rust programming language
-
af-macros
Macros for the indigo crate
-
zkp-error-utils
Assertion like macros for returning
Result::Err -
targets
Some helpers to get you started with declarative programming in Rust
-
col_proc_macros
A bunch of procedural macros for declare collections of various kinds from their contents as fast as possible
-
checked_clamp
Clamp alternative that returns a result instead of panicking
-
repr-trait
Traits to represent Rust reprs
-
fullypeek
Peek forward in an iterator as far as you'd like, memory allowing!
-
simple-life
async lifecycle trait and convenient macros
-
display_macro
Like print! macro but always flushing
-
tracers-macros
Macros which generate tracers and the code that fires the tracers. See the 'tracers' crate for further instructions
-
rich-phantoms
Phantom types with control over variance and sync/sync inheritance
-
iter-n
functions returning impl Iterator to return one of several distinct types
-
clc-engine
Provide calculation api for calculator ui
-
let_clone
Declarative macro to clone multiple values at once
-
osm-geo-mapper-macros
Contains various helper macros for the osm-geo-mapper crate
-
cmd-macro
makes std::process::Command simple to use
-
components-arena-traits
Does not intend for direct use
-
temp-inst
safe lifetime-erased representations for objects with lifetime parameters. Can be used to pass an object across an API where lifetime parameters would prevent it.
-
tiny_fail
Fail type
-
pyphen-rs
A pure Rust port of Pyphen, a Python hyphenation library
-
very-bad-error-propagation
Using the panic system to implement error propagation (please don't actually use this)
-
eliza_error
“Times are bad. Children no longer obey their parents, and everyone is writing an error handling library.” — Cicero
-
error_hook
error hook
-
const-enum-tools
Trait definitions for working with enums at compile time using macros
-
typed_macros
Adds typing to your macro's arguments, making it a lot less of a pain to deal with them
-
nodespeak
A JIT-ish compiler for number-crunching applications
-
tagname
get the name of a variant in your enum as a string
-
focusable
A trait for types that can be focused
-
boh
A holder of many things
-
easy-plugin
A compiler plugin that makes it easier to write compiler plugins
-
intern-all
A safe and predictable interner for data of mixed and arbitrary type
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
arrays
Construct an array from an iterator
-
typeon
metaprogramming
-
vesta
Extensible pattern matching
-
derive_environment
modifying structs via environment variables
-
gbparser
providing a representation of a GenBank sequence records file, a reader for such files implementing Iterator
-
iterator-endiate
Extension method for (exact size) iterators which yields tuple containing whether item is last in iterator
-
refraction
A general-purpose lens library for Rust
-
never-say-never
The never type (the true one!) in stable Rust
-
vm6502
A 6502 virtual machine backend
-
unsafe-storage
Maintain invariants in macros without modules
-
advent_of_code_macro
An test generating macro for advent of code
-
readonly
Struct fields that are made read-only accessible to other modules
-
rayon-join-macro
A convenience n-nary macro around
rayon::join() -
tokio-tasks
Task managment for tokio
-
autoproto
Replacement derive macros for
prost::Message, and supporting traits and types to make implementing this trait easier -
lazy_transducer
Lazy, parallel, indexable, generic data iterators
-
cardseed
Pseudo-random numbers derived from playing cards using PBKDF2
-
element-ptr
A macro to make accessing elements through raw pointers easier
-
iter2
Iterator
chaining,cmping and more as free functions taking twoIntoIterators -
bitmatch
A macro to allow matching, binding, and packing the individual bits of integers
-
collected
Summation, product, maximum and more special collectors for Rust iterators
-
winrt_gen
Code generation for the winrt crate
-
enum-unit
Generates unit-variant enums from existing enums
-
cell-project
Safe interface for cell projection
-
generic-std
Experimental HKT framework and generic traits for the standard library
-
noders
NodeJS-like event loop environment for Rust
-
aspect-weave
An Aspect Toolkit for Rust
-
error_mancer
Quickly define custom error enums for a function
-
iter-diff
Differences between iterators
-
diffuser-edit
Edit diffuser models without GPU and Python
-
ordered_iter
Ordered iterators
-
tuple_utils
A set of utilities to enable higher level operations over tuples
-
shorter-macro
Shorter std macro names
-
enum_index_repr
EnumIndexRepr provides a small macro which allows getting the index on an enum
-
handy_macros
instead of annoyingly writing out .to_string() just do s!()
-
atruct
macros for anonymous structs in Rust
-
try-insert-ext
Extends various types with
try_insert_withmethods -
shkeleton
Skeleton rust project
-
compact
Store objects containing dynamic fields either compactly in consecutive memory or using traditional heap pointers
-
infinite-iterator
A trait for iterators that never end
-
makers
a POSIX-compatible make implemented in Rust
-
greattraits
My own collection for traits extending standard library types
-
instruct-macros-types
Instructor Macro Types are a collection of simple types that we export to work with the instruct-macros crate
-
cura
arc-lock-system that should clean up the code a lot
-
process-iterator
external process as an iterator (adaptor or consuer)
-
nias
closure generator library
-
gamo
A Range like struct for user defined types
-
object-safe
Implement object-unsafe traits for trait objects
-
mathelogos
as a functional programming language
-
serde_webgpu
Serialize WebGPU uniform buffer member layout
-
derive_enum
Enum derive macros for Rust 2018
-
rls-span
Types for identifying code spans/ranges
-
gandiva_rust_udf_common
A basic library for gandiva rust udf macro
-
snake_cased
snake_case for struct or enum
-
packed_streaming_iterator
Additions to streaming_iterator
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
yrt
Inverse try! macro
-
simple_scan
Iterator extensions for simple scan operation
-
winit_event_helper
Simplified winit event handling using callback functions
-
rust-iteratorcomprehensions
A comprehension syntax for iterators implemented as macros
-
transitive_from
Helper macros for creating hierarchies of transitive
Fromimplementations -
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… -
size_hint
A very simple library to provide a size_hint for an iterator which does not provide it's own
-
new_flattened
Macro to flatten nested calls of
news -
typebitset
Type-level bitset implementation
-
magic_static
Global singletons initialized at program start, an alternative to lazy initialization
-
davenport
Ergonomic thread-local workspaces for intermediate data
-
emplacable
Return unsized values from functions
-
errors_rust
Just a simple library for error mapping
-
try-drop
Batteries included error handling mechanisms for drops which can fail
-
unchained
Iteration
-
pisserror
A golden rip-off of thiserror
-
string-error
A minimal rust library to create errors out of strings
-
inline_default
Macro for inline Default implementation
-
metaprogramming
Port C++ metaprogramming to Rust
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
binread
helping read structs from binary data using ✨macro magic✨
-
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
-
trait-tactics
Macros that provide common patterns for implementing traits in terms of other traits
-
io-arrays
Random-access I/O
-
errify
Function error context provider
-
event-observer
observer pattern by rust
-
error-doc
proc macro to generate #[doc] comments from #[error] messages
-
py-comp
A macro implementing a Python-like generator expression
-
plectrum
An easy way to represent lookup tables in a db as rust enums
-
singleton-stepanov
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:…
-
derive-ctor
Adds
#[derive(ctor)]which allows for the auto-generation of struct, enum, and union constructors -
type_enum
Create tagged unions consisting of different types
-
retry_durations
generates a duration iterator for [retry] crates
-
traitobject
Unsafe helpers for working with raw trait objects
-
byteorder_slice
Byteorder like crate for &[u8]
-
specs_scene_graph
scene graph for specs
-
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
roopert_macro_common
object-oriented toolkit for Rust (common data)
-
legion-task
Fork-join multitasking for Legion ECS
-
generator_extensions
Basic extensions to Generator types to bring parity with Iterators
-
apply_attr
A syntax extension providing higher-order attributes to Rust
-
sh
Macro for easily running commands
-
htmxpress
Procedural macros for generating htmx strings
-
spans
Split an iterator into contiguous spans
-
packer
Pack static files into your binary at compile time
-
mintaka-utils
Mintaka Utils
-
take_mut
Take a T from a &mut T temporarily
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
escaped-delimiter
Iterator of delimited slices with escape characters
-
zkp-logging-allocator
Wrapper around the system allocator that logs large allocations
-
fastperm
A dead-simple, extreme fast permission flag system for Rust with no dependencies
-
core-nightly
Nightly build of libcore from the rust repo
-
cmacros
Rust lib for parsing macros from C header files and assisting with translation to Rust code
-
fake_inheritance
A little utility macro
-
slots-slice
manipulating slices of optional values
-
nopanick
No panic library for add, sub, mul, div operators in Rust
-
cor_iter
Correlate of two iterators
-
cex
Checked exception simulation
-
tocall
tries to provide useful tool modules in a more concise API
-
interior_mutability_pointer
A wrapper around
Rc<RefCell<T>>allowing immediate access to inner methods -
extrude
A macro for unwrapping an enum value into an Option
-
ark-algebra-bench-templates
A benchmark library for finite fields and elliptic curves
-
yolo-block
Like a
tryblock, but automatically unwraps the result -
sql_reverse_error
sql reverse error
-
polonius_workaround
Safe replacement for Polonius on stable Rust
-
join_to_string
Join a list of items to string/buffer
-
detach
helper type for being able to detach/reatach a member item
-
option_into_controlflow
Option into ControlFlow conversion
-
rudeboy
Rlua User Data Extension Boy - Derive/attr macros and traits for easily exporting user data to RLua
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
type-equals
Type equality trait for rust-lang/rust#20041
-
redb_model_trait
Redb model trait
-
anyhow_ext
Extension of anynow
-
near-safe-cell
A more ergonomic 'UnsafeCell' wrapper/replacement
-
common_regex_rs
Set of common regex for Rust
-
rovv
provide the anonymous row type (poor-man's row polymorphism) in rust
-
throws
A macro for easy creation per-function errors
-
powerfmt
powerfmtis a library that provides utilities for formatting values. This crate makes it significantly easier to support filling to a minimum width with alignment, avoid heap… -
ffi_types
C ABI compatible wrappers for cbindgen/bindgen
-
error_union
simplify error handling in Rust
-
warrant
A Swift-guard-like macro for Rust
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
atomic_non_null
An atomic wrapper around NonNull
-
specialize
Type specialization macros and helpers
-
oofs
Error handling library that generates and injects context for you
-
iterate
Support crate for
iterate -
ferrite-session
Session Types DSL for Rust
-
pflow-metamodel
Declarative Petri-nets using a rust DSL
-
namable_closures
types and macros to create namable closure types
-
errer
Flexible error management for Rust. An middle-ground between failure and SNAFU
-
bherror
TBTL's library for error handling in Rust
-
emstr
Helpers for working with string types for embedded devices
-
with-api
macro for shrinking scope
-
yansongda-utils
rust 中一些关于我自己的常用工具
-
soapy-shared
Custom types used by soapy macros
-
kappendlist
Append to a growable list in O(1) without needing &mut
-
axum-routing-htmx
Typed routing macros for HTMX on axum
-
project-uninit
Macros for safe references to and initialization of fields in MaybeUninit structs
-
introspectable
Basic introspection via the Introspectable trait
-
progress-token
tracking progress of long-running tasks
-
nom-fields
single function-like macro that removes some boilerplate from a common pattern when using nom
-
market_types
Common implementations of a market
-
seestr
pointer-wide nul-terminated strings with ownership semantics
-
mdo
Monadic do notation for rust using macro and duck typing
-
spawn_interval
Call a subroutine at a constant time interval
-
backon
Make retry like a built-in feature provided by Rust
-
displaydoc-lite
Implement the Display trait using your standard doc comments
-
transaction
abstraction library (a.k.a. transaction monad)
-
modular
arithmetic in rust
-
separable
trait for enums
-
arbintrary
Proof of concept for arbitrary integer sizes using generic const
-
zkp-macros-decl
Procedural macros
-
lens-rs
lens implemented in rust
-
ranged-num
A package for typing numbers in a compile-time known range
-
builder-pattern
A derivable macro for declaring a builder pattern
-
rustato-macros
Macros for the Rustato library
-
dev_bestia_string_utils
string manipulation
-
azucar
syntax sugar
-
niceowner
A stupid library that allows you to own a value, even if it comes from a reference. No cloning.
-
itsuki
macro that defines a simple zero-based sequential enum
-
rustitude-core
create and operate models for particle physics amplitude analyses
-
static_assert_macro
so-called
static_assert -
advance-iter
A small crate to help with "stepping through" iterators
-
is-same
A trait for comparing object equality
-
interpolate_idents_gnzlbg_fork
Useable macro identifier concatenation plugin
-
stackstack
A singly linked list intended to be chained along stack frames
-
tartan-bitfield
Define structures with accessors for particular bits or bit ranges
-
default_is_triple_underscore
Shorter syntax for Default::default() : ___()
-
set_slice
A macro for assigning values to slices
-
apply_conditionally
Chain and apply methods on objects conditionally
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
read-byte-slice
An iterator over chunks of bytes as slices from an underlying reader
-
should_match
Pass a test if the output matches a pattern
-
visit_diff
Efficiently finding differences between data structures
-
conditional
conditional! macro which lets you use the syntax of the conditional operator (also known as the ternary operator) in Rust
-
negative
impls in stable Rust
-
rustollens
A small and experimental library with a type-level representation of booleans with companion connectives for compile-time sort-of fun with logic
-
fallback-if
Fall back to an alternative given some predicate
-
oxymcts
general traits and default implementations for Monte Carlo Tree Search
-
transactional_iterator
Iterator that allows to commit or abort progress
-
extensor
the main extensor crate for building arbitrary valent tensors and more
-
std-io-peek
Peek trait
-
adrop
fast dedicated thread drop
-
clonable-iterator
Dependency-Free Library to make most non-Clonable Iterators in Rust into Clonable ones by use of shared ownership
-
destruct
structs and enums for simpler combinator implementation
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
flagged
Bitflag-based warning type
-
ambience
Lightweight library for passing ambient parameters
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
nanocl_error
Nanocl error types
-
ast2str-lib
pretty-printing ASTs and other recursive data structures
-
into-static
Upgrading to static lifetimes
-
takeable-option
A small wrapper around option
-
atomic_refcell
Threadsafe RefCell
-
noneifempty
Convert T to None if empty
-
intercom
writing COM visible Rust components
-
collections_macros
a collection of macros to make making collections easier
-
have_len
container empty ? (
is_empty()andis_not_empty()) -
intern-str
Efficient, compile-time string interning for Rust
-
lgio
Lightweight, generic, no_std IO
-
cmp_any
Comparison for &dyn types
-
select_indices
Iterators for taking multiple shared/exclusive references from a slice
-
pretty_assertions
Overwrite
assert_eq!andassert_ne!with drop-in replacements, adding colorful diffs -
unidok-to-html
Convert a parsed Unidok document to HTML
-
axmac
Readable indexing macros for 1-4 dimensional data structures
-
on_drop
on drop
-
diva
Opinionated convenience wrappers for
std::process::Commandand friends -
bump-into
a no_std bump allocator sourcing space from a user-provided slice
-
external_mixin_umbrella
Backing library for
rust_mixinandexternal_mixinto keep them DRY -
tartan-c-enum
Define FFI-safe enums that support unknown values
-
cgp-sync
Async-generic primitives to support both sync/async in context-generic programming
-
tokio-retry2
Extensible, asynchronous retry behaviours for futures/tokio
-
wedpr_ffi_macros
WeDPR ffi shared macros
-
quantified
Specify the universe: None, Some, Excluding, and All
-
even_bigger_s
Better String Literal
-
is_send_sync
Macro to tell if a type is Send/Sync
-
tany
Type-erased container with inline storage for small values
-
hatch_result
A result-like struct that returns on Ok, instead of on Err when ? operator is used
-
posix-errors
Posix error codes and handy functions for using them
-
sath
Toy math library
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
pub-iterator-type
Abstract an iterator implementation behind a struct tuple
-
summon
A logic engine designed to magically give you what you ask for
-
string_mac
A lazy man's String macro
-
shoggoth
Generic and type-level programming for Rust
-
ownit
Easily turn borrowed type into owned values
-
ambient-authority
Ambient Authority
-
then
bool::then functions but named properly
-
io-ensure
Prototype of the
std::io::ensurefamily of macros -
rmin
A minimal Rust lib for writting R extensions
-
proc_use
Semi-dynamic mod and use
-
plmap
Parallel pipelined map over iterators
-
predicate
Use enum to predicate something, support & and | operator
-
enum-to-types
Macro for generating pseudo-enums for type-level programming
-
error-context
Methods and types that help with adding additional context information to error types
-
fix_fn
Macro to create recursive closures (similar to the Y combinator)
-
fallible
operations
-
swahili-dsl
A Swahili-based DSL made for educational purposes
-
mods
Simpler module declaration
-
prefixes
Attribute-like macros imitating literal prefixes, e.g. #[f]"Hello, {world}"
-
pretty-panic
nicer panic messages
-
zkp-criterion-utils
Criterion helpers to benchmark over size and number of processors
-
iter-opt-filter
Adds an optional filter to iterators
-
doless
macro to simplify struct mapping and function utilities
-
ddi
Dynamic dependency injection library for rust
-
curri
Functional Programming Tools
-
bull-be-like-cow-mut
Cow’s non-clone-bearing counterpart with the power of mutation -
enum-rotate
Rotate and iterate your enums
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
sod-bus
Service Oriented Design - Single Producer Multi Consumer
-
self-reference
Helper
-
unique-type
Unique and anonymous types generation utilities
-
trait_adapters
newtype adapters for modifying interactions with traits
-
tyname
Retrieve type names during program execution on stable Rust
-
pipette
Polymorphic function pipelines without traits or macros
-
ioc
An Inversion-of-Control library in Rust
-
user-panic
Error messages
-
base64_type
type wrapper for Vec<u8> that uses base64 for serialization
-
brain_rust
A BF transpiler to rust written as a rust declarative macro
-
indenter
A formatter wrapper that indents the text, designed for error display impls
-
type-uuid
Safe, stable IDs for Rust types
-
assert-impl
Macro for static assert types implement a trait or not
-
call-once
A type that can only be called sucessfully once
-
string_iter
An overly designed &str iterator made with zero-copy parsing in mind
-
try_ops
try catc... ops macro
-
pipeop
Adding the pipe operator to Rust with a declarative macro
-
cosmian_ffi
Tools to build Foreign Function Interfaces at Cosmian
-
displaythis
derive(Display)
-
nclosure
composable, nameable closure types with separated states and functionality for use in APIs where anonymous types are unavailable
-
stable-pattern
Stable port of std::str::Pattern and friends
-
fstrings-rust
Python3 fstring interpolation in Rust
-
const_power_of_two
working with constant generics that are powers of two
-
sealed-typestate
macro for declaring typestates with 0 variant enums
-
min-specialization
Experimental implementation of specialization
-
drop_code
Macro for ensuring critical code execution on function return or panics in Rust, making it easy to include essential code for reliable operation
-
birds
Combinators using Rust macros
-
chn
Iterator chain-building macro
-
split-optional
It split from a source
strtoOption<&'a str>per an element -
rustring_builder
string builder
-
lazy_thread_local
Lazily initialised per-object thread-local storage
-
rangecutter
working with adjacent ranges
-
has_fields
Some macros helpful for processing forms with optional fields
-
struct_scheme
structure scheme display
-
pstr
Global String Intern Pool
-
constant
evaluation tools for Rust
-
try-unwrap
A revolutionary new crate that allows you to unwrap() without making your stupid software panic
-
fuzzypath
Quick & dirty fuzzy path comparison
-
transfer
that exposes a Transfer trait, that is to move what Clone is to copy
-
kaguya_rs
Functional Programming tools and ADTs
-
struct-builder
Derive a builder for your structs
-
checked-float
making invariant-enforcing floating point wrappers
-
derive_convert
Derives 'impl (Try)From for Self' and 'impl (Try)From<Self>'
-
batch_oper
some batch operation macro for some operations
-
shorten
A collection of convenience functions, macros and traits to shorten repetitive code
-
const_typed_builder
Compile-time type-checked builder derive using const generics
-
prim_int_kind
Enumeration whose variants represent kinds of primitive integers
-
error
A fancy error type for highly generic cases
-
from_int
A package to easily add a from_int method to enums with #[derive(FromInt)]
-
makero
A
macro_rules!macro to aid in the creation of complexmacro_rules!macros -
partial-default
PartialDefault, a trait similar to Default but with fewer guarantees
-
num_alias
macros to declare 'type checked' aliases for integers and floats
-
unreachable_checked
unreachable!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won't panic.
-
disfmt
Rust code disformatter
-
lithium
Lightweight exceptions
-
catch-unwind
Wrappers for catch_unwind that handle the edge case of the caught panic payload panicing
-
match_opt
A macro for turning a partial match into a full match returning an option
-
circomspect-circom-algebra
Support crate for the Circomspect static analyzer
-
hexhex
hexadecimal conversion 🪄
-
dyn_ord
Equality and ordering for trait objects
-
buco
A compile-time builder pattern implementation for Rust
-
makepad-internal-iter
Internal iterators
-
slid
labeled IDs
-
tylar
Type-Level Arithmetic in Rust
-
mould
Rust web-framework for websocket based web-apps
-
to_unit
ToUnit; Any type to () syntax sugar
-
hypermod
Automatically build the module tree from the src/ dir
-
dyn_traits
Magically derive non-object-safe traits
-
unwrap_let
macro for quickly unwrapping a refutable pattern
-
dmoj
providing helpful methods in online judging
-
duck
Like
Iterator::peekable, but can be stacked an arbitrary number of times -
xdi
Rust di containers system
-
spawn_timeout
Call a subroutine after a constant time interval
-
dirk_framework
Dependency Injection for Rust
-
fourcc
Syntax extension to generate FourCCs (four-character code)
-
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.
-
cargo-toml-builder
A builder for generating Cargo.toml files
-
checked_ops
Automatic checked arithmetic operations in Rust
-
anonymous-trait
Anonymous trait implementation with capturing the environment
-
resultit
Iterator adapters for iterators over results
-
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
take-static
Static items that provide mutable access only once
-
disown
Drop ownership via a method
-
xmt
Batteries-included CLI output library for Rust
-
pathsep
a small macro to enable easy path construction in other macro calls
-
gluesql-derive
Derive traits for GlueSQL
-
swamp-vm
Minimial virtual machine
-
fortraith
Compile-time compiler that compiles Forth to compile-time trait expressions
-
nix-compat-derive
Nix protocols and data formats
-
typedopts
Type aware command line parser
-
big_mac
A metamacro toolkit for writing complex macros
-
ident-mash
Mash idents together inside macro_rules!
-
jane-eyre
By Currer Bell
-
film_parser
application for parsing detailed film data from raw text, including information such as title, release year, director, screenwriter, cast, genre, and runtime, into a structured Film…
-
swiss-army-knife
Common utility code to support linux-support and other projects
-
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!
-
tuplify
Generic hlist/tuple library
-
cargo-toml-macros
Convinient macros for pulling fields from your Cargo.toml. Prettier than std::env
-
tensor-macros
A compile time optimised tensor library
-
dst
Data structures for DSTs
-
thiserror_core2
derive(Error) (no_std-enabled using core2)
-
thinnable
Thin references to unsized types
-
rustcomp
Adds vector, map, set, and iterator comprehensions to Rust
-
tlist
Type-level linked lists (of types) and type-level 'functions' to manipulate them. Because TList is implemented using GATs, usage is very ergonomic.
-
ferrum-plugin
Lazily evaluated, order-independent plugins for extensible types
-
query-range
This package provides an iterator which finds all ranges of a query within the searched content
-
injectables
procedural macro library that enables field injection between Rust structs through #[injectable] and #[inject_fields] attributes. The library handles visibility rules, generic type resolution…
-
bogdan_hello_macro
adds the method hello_macro that generates a greeting based on the name of the struct
-
litenum
minimal convertion utilities between literal and enum
-
pandet
A lightweight library to help act on panics of detached async tasks
-
fomat-macros
Alternative syntax for print/write/format-like macros with a small templating language
-
uninitialized
Opt-in unsafe uninitialized memory
-
pure_decimal
A decimal type with no NaN and Infinity
-
teloc
compile-time DI framework for Rust
-
thisisplural
#[derive(Plural)] for creating frictionless new types with any collection type like Vec or HashMap
-
racros
Collection of rust macros
-
ord_by
Conveniently attach a custom compare function to any type
-
always_equal
A wrapper for types that can't implement Eq
-
ironplc-dsl
Domain-specific language objects for IEC 61131 language elements
-
rust2fun_laws
Laws for rust2fun
-
lit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
beaver
setting up Rust objects inspired by factory_bot
-
box-iter
that provides an iterator for
Box<[T]>types -
sqlx-executor-alias-macro
SQLx Executor alias macro
-
m6stack
A Small Stack
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
cooked-waker
A safe interface for creating async Wakers
-
thiserror-nostd-notrait
derive(Error)
-
matrix_match
Macro to match on two values at the same time
-
tearor
Easily turn data races into data corruption!
-
compost
Adds a macro to decompose tuples into tuples containing a subset of their values
-
html5ever-atoms
Static strings for html5ever
-
cgp
Context-generic programming meta crate
-
cw-dsl
Resolve tag weights of cyber waifu
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
arr_ty
Macros for smart array initialization (best for trait object element types)
-
count_tts
macro for counting tokens
-
polimorphism
Function overloading via a procedural macro
-
intuple
Convert structs and enums into tuples (of refs) and back - recursive, ignore fields
-
hodgepodge
enums
-
int_range_set
Rangeset container based on tinyvec
-
turbostate
Finite State Machine
-
wasmer-bus-types
WebAssembly Bus Macros
-
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. -
lox_utils
General helpers used by Lox
-
oneoff
one-off types
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
nommy
Type based parser
-
miden-thiserror
derive(Error) with no-std support
-
thiserror_string_context
Adds context string to error enums generated with thiserror
-
os_str_bytes
Lossless functionality for platform-native strings
-
qwutils
some utilities
-
wdl-macros
Macros used within the
wdlcrate ecosystem -
enum_properties
A macro for declaring static properties on enum variants
-
mutify
Macro for coercing a
mut var: Torvar: &mut Tinto a&mut T -
step-count
Count items of an iterator with any Step type
-
scopefn
Scope functions for Rust
-
statenum
enabling enums in state-pattern logic
-
pod-enum
An enum which is also plain-old-data
-
try-traits
Alternatives to std lib traits that can fail
-
pi_any
attempt to downcast the triat object to a concrete type
-
opt2r
crate(library) that provides a way to convert Option to Result
-
det
Calculate the determinant using a macro
-
warned
struct Warned<T, W> { value: T, warnings: Vec<W> }, which represents a value with warnings
-
maflow
Flow macros: basically unwrap for return, continue and break
-
daml-macro
Helper macros for working with the Daml Ledger API
-
sorted
compile time guarantees for sorted sequences
-
typefun
Emulating various values at compile-time using types
-
outcome
A Success/Failure type for rust
-
bitty_write_macro
A drop-in
write!replacement that optimizes non-formatting writes for code size -
tap-trait
Inspect and mutate values without leaving the method chain
-
statum-core
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
strflags
A string-enum and string-flags with fixed variants that can also accept arbitrary data
-
typechain
Create chains of trait objects
-
merge2
Merge structs into single by values
-
derive-alias
Alias multiple derives as one
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
xcell-types
Types definition for xcell
-
writeable
A more efficient alternative to fmt::Display
-
transitive
derive macros for Rust
-
mapper-api
Api of the
mappercrate -
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
smart
dynamically-dispatched smart pointers
-
x-bow
Precise State Management Library
-
prompt-organizer
better manage AI prompts in your Rust code
-
mopa-maintained
My Own Personal Any: get your own Any with additional functionality
-
inner
The inner! macro descends into an enum variant. It's more flexible than try!() and unwrap(), and it works with your enum, too!
-
vec3
-
trait-bound-typemap
create typemaps with additional trait restrictions and implementations
-
map_for
macro that implements for comprehensions similar to Scala's
-
event_feed
Event systems implemented using event feeds
-
iter-flow
Functional programming utilities for Rust
-
ataraxy
Discord slash commands framework for Serenity
-
shared_error
SharedError wrapper for cloneable Error
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
oc-hook-macros
Some convenient macros for hooking Objective-C functions
-
awred
A convenient derive macro for actix_web::ResponseError trait
-
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
binjs_io
I/O component of the Binary AST reference implementation
-
iterware
middleware for iterators
-
rusty-value
Create a generic inspectable value from any rust type
-
envload
Automatically fill structs from env variables
-
instancebuilder
Convenient way of managing dependency injection
-
re_string_interner
string interning library
-
macro-while-mut
Macro that allows create while-cycle with mutable condition state
-
err_or
Small lib that helps converting
Option<E>intoResult<_, E> -
const-assert
Assert struct for const generics
-
typeinfo
Runtime type information for POD types
-
error-macro
error macro
-
block_effects
A macro to chain block effects
-
import_file_macro
Macro from compile-time file loading
-
iter-python
Python generator expressions and 'list' comprehensions
-
fluent_state_machine
A domain-specific language (DSL) for creating state machines in Rust
-
split_tokens
Split compound tokens in their individual parts
-
visita
Elegant implementation of the Visitor Pattern
-
html_compile
A template engine for generating HTML strings within Rust for use with static websites
-
type_at
trait to index type of Rust tuples
-
macro-stateful
help record state in a global scope
-
starchart
A database tool that allows for multiple backend implementations
-
ward
ward! macro which returns the contents of an Option<T> and otherwise returns early, and a guard! macro, which does the same, but with a syntax more similar to Swift's guard syntax
-
trait-gen
Trait implementation generator macro
-
multi_stream
Aggregate multiple streams of different types in a single stream with an item type that is a tuple of the incoming stream items
-
option_macro
a convenience macro
-
sc2-macro
Procedural macros for rust-sc2 API
-
stringish
A smaller and easier copy-on-write string
-
foreignc_util
error handling in foreignc
-
clonesure
A helper macro to create closures which will clone its environment
-
macroland
macro shorthands of various types in Rust
-
typederror
A wrapper around anyhow that allows for a primary error type
-
quick-error2
A macro which makes error types pleasant to write
-
maybe-owned-trait
Either an owned or borrowed value, with type known at compile time
-
read-primitives
traits to read primitive types from any type that implements std::io::Read
-
one-of
Macro to represent a type that can be converted either
FromorTryIntothe given types -
declarative_type_state
A collection of declarative macros to reduce boilerplate code when implementing type-state patterns
-
fast_delegate
delegate struct easy
-
contains
A Container trait
-
orfail
Error handling library for portable unrecoverable errors
-
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
with-thread-local
A micro crate that simplifies a bit the use of the std macro
thread_local! -
scrapmetal
Scrap Your Rust Boilerplate
-
arraytools
A variety of helpful methods for working with fixed-size arrays
-
deferrer
defer! macro for deferring functions
-
stable_borrow
A marker trait indicating that borrows are address-stable
-
core_float
based on the Rust Core Library and aims to provide an identical set of APIs for f32 and f64 floating-point types
-
literal
Literals for Rust's collections
-
vec_remove_if
Extract elements from a vector based on supplied criteria
-
hex-display
Display impl for byte slices which provides a hexdump
-
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…
-
type_utilities
Implementing more methods to rust type primitives
-
is-impl
Rust macro to check that a type conforms to an impl
-
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. -
bloc
A state management library
-
cassandra_macro
Create Cassandra tables and CRUD CQL prepared statements from Rust structs. (custom derive: cassandra_macro_derive)
-
to_vec
convenient to_vec, to_set and to_map methods on iterators
-
fn_name
Macros that produce the name of the function they're invoked within
-
validaten
Common validators for cryptocurrency, creditcards, domain, url, etc that can be used across projects
-
fancy-ip
Fanciest way to initialize IP addresses
-
borrowck_sacrifices
Necessary sacrifices to keep the Borrow Checker happy and developers sane
-
tca-rs
The Composable Architecture (TCA, for short) is a library for building applications in a consistent and understandable way, with composition, testing, and ergonomics in mind
-
zerror_core
A complete implementation of the zerror:Z trait
-
bos
Flexible Borrowed, Owned or Shared (B.O.S.) smart pointers. Like std's Cow but with Rc/Arc and without the ToOwned requirement
-
irox-enums
Traits for better Enumerated Types
-
remit
Rust generators implemented through async/await syntax
-
model_macro
traits collection
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
string-literal-const-replace
Proc macro for compile-time find/replace on string literals
-
orx-iterable
Defines and implements Iterable, Collection and CollectionMut traits to represent types that can be iterated over multiple times
-
ra_ap_tt
A
TokenTreedata structure for rust-analyzer -
global_var
macro for declaring a global variable
-
negative-impl
Negative trait implementations on stable Rust
-
metered
Fast, ergonomic metrics for Rust!
-
adana-std-process
Adana standard library
-
plutonium
Tools to avoid unnecessary use of safe code
-
unwrap_all
Unpack multiple levels of
Result<T, E>andOption<T>at once -
total_float_wrap
Floating point wrapper implementing Hash and Ord according to IEEE 754 totalOrd
-
prost-unwrap-core
A procedural macro implementation for prost-unwrap library
-
ifmt
Inline expression interpolation for Rust
-
ufcs
Helper trait to call free functions using method call syntax
-
push_mut
Push a value to the back of the vector, and return a mutable reference to it
-
pino_utils
general rust utility functions and macros
-
strdeser
A struct serializer for rust empowered with a macro
-
string-newtype
New Type idiom helper for string-like types
-
int_ranges
ranges tools for integer
-
steloc
compile-time DI framework for Rust
-
units
Measure for Rust. Easy to use, type-safe and customizable.
-
partial-borrow
Partially borrow a struct
-
anysafe
any safe
-
stats_traits
Traits for collection-like types to calculate statistics
-
safe
A
#[safe]attribute for explaining whyunsafe { ... }is OK. -
xpr
A general purpose generic expression template library
-
unify
Trait-based equality constraint for Rust
-
diatom-std-os
The diatom programming language
-
oxlex
lexer/tokenizer used in OxyScript
-
dynamic-cast
The fifth pillar of OOP: dynamic casting
-
trait-alias-macro
Trait Bound Alias using Macros
-
match-downcast
A set of downcasting matching Rust macros
-
error-utils
Some rust macros to simplify common error handling patterns
-
oi-unwrap
unwrap without unwrap
-
type-level-logic
Primitive types and operations for type-level logic
-
discord_typed_interactions
suppose you're working with discord slash commands and you want statically typed request types
-
dyn_struct2
Construct dynamically sized types safely. Supports arbitrary unsized types, not just slices
-
tt-call
Token tree calling convention
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
chainer
A cursed crate that allows for global call chaining with access to chained function results
-
uclicious-libucl-sys
Low-level bindings to libucl
-
regex_macros
statically compiled regular expressions for Rust. Unless you specifically need compile time regular expressions or a matching engine that is guaranteed not to allocate, you should temporarily prefer using…
-
conditional-assignment
very simple, small crate to help make conditional assignments more ergonomic
-
structural-convert
Derive conversion traits (From, Into, TryFrom, TryInto) when fields are structurally similar in enums or structs
-
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
generic_static
Generic static variables in generic functions
-
eieio
Error Implementing
Eq + Clonereplacingstd::io::Error -
merg
Merge multiple values into one
-
enum-tools
Automatically derive functions and trait implementations for enums
-
erroneous
Minimalistic helper for using errors
-
itemizer
Containing an itemizer to itemize structs
-
define_into_enum
Defines Into<T> on an enum where all variants wrap T
-
cfixed-string
Pass Rust strings to C with potentially not needing heap allocation
-
uncheck-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
generic_singleton
allowing for generic singleton patterns
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
guest_cell
Storage space for externally-owned private data
-
okey
Everything is Result::Ok
-
stdont
Kitchen sink of utils that I'd like to see in std
-
endian-num
Byte-order-aware numeric types
-
fastapi
Compile time generated OpenAPI documentation for Rust
-
pipe-chain
Combinators & parser library
-
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
untrusted_value_derive_internals
aim to provide a type-safe way to handle and sanitize potentially untrusted values like user input
-
rcrefcell
Wrapper type for Rc<RefCell<A>>
-
fallacy-clone
fallible clone
-
itermacros
Some useful macros related to iterators
-
display_container
implement Display
-
bounded_types
type representing bounded integers, implemented using const generics
-
zc_io
zero-copy I/O
-
actuate-core
A reactivity framework
-
u-plus
Pretty Unicode code point literals: U+12345 instead of '\u{12345}'
-
lifterr
A small set of adapters extending Rust's error-handling capabilities
-
consumable
Consume the value by replacing it with the default value and returning the previous value
-
selective_assertions
Macros for asserting equality of structs with the flexibility to exclude or focus on specific fields
-
munge_macro
Macro for custom destructuring
-
flat_vec
macro to flatten nested Vecs. Particularly useful when you want to write a rules of egg which contains rules both => and <=>.
-
array_ext
Extra functionality for Rust arrays
-
upget
Super simple trait that patterns the value "updae" and "get"
-
perthread
ThreadMap structure for accessing PerThread thread local variables form a static context
-
cgp-field
Context-generic programming field traits
-
arch-into
safe type conversions between pointer-sized types (usize/isize) and types with fixed size
-
sod-tungstenite
Service Oriented Design - Tungstenite
-
eq-float
Float wrappers with a total order (by setting NAN == NAN)
-
frunk_utils
working with frunk
-
addtwo_macro
My first macro, adds two to a number
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
type_eq
Tiny utils for type-level constraints and inference
-
display_with
Return opaque impl Display and/or impl Debug types via display_with and debug_with
-
newtype-enum
Traits to convert between enums and their variant types
-
method_shorthands
A set of convenient shorthands for commonly used methods
-
strong
Strongly typed String
-
i-codegen-code
Common tools supporting the
derive-codegencrate -
float-derive
that allows deriving Eq and Hash for types that contain floating points
-
verified
types to facilitate the development of verifiable rust
-
slicefields
Allows for data structures whose members are sub byte aligned (e.g. a one bit alignment)
-
slice-string
A String backed by a slice
-
drogue-bazaar
A place to find tools for building your Rust application
-
from_tup_macro
implement from tuple trait
-
rs_envflag_macros
An easy way to define flags by environment variables
-
slice_trait
A generic trait for any slice, with item as a type parameter
-
io-window
Seekable I/O adapter that limits operations to a byte range
-
erreur
A tiny crate that facilitates error handling, including tracing line numbers, customizing and propagating error messages
-
anyflux
Generic flux-like state management
-
async-event-dispatch
async event dispatcher that is not susceptible to the slow-receiver problem
-
n-functor
Faux-derive a
mapfunction for types with one or more type parameters -
index_vec
Newtype-style helpers for
Vecandusize -
usage
A convenient alternative to the newtype pattern
-
array-fu
Construct arrays using simple syntax
-
opcode-macros
Macros for opcodes encoded in bit fields
-
build-deftly
Derive custom builders, using the derive-deftly macro system
-
id-ish
Numeric ID types that can be swapped in & out
-
chain_tools
A set of traits allowing for more a erganomic style of chain programming
-
trait-set
Support for trait alias feature on stable Rust
-
trait-theories-std
A collection of invariants of Rust std traits
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
therror
derive(Error) with a twist (based on thiserror)
-
arcmutex
A convenience library for working with
Arc<Mutex<T>>s -
zconvertenumn
Convert number to enum
-
maparr
macro to build a static
Mapbased on const array -
polymorph
A set of utilities to better enable polymorphic behavior in Rust
-
better-as
Explicit type casting
-
stack-array
A data structure for storing and manipulating fixed number of elements of a specific type
-
get-field-by-type
Get a value of field, based on the type of a field
-
tor-basic-utils
General helpers used by Tor
-
tested-trait
Associate tests with traits
-
chained
lazily chaining functions
-
onechatsocial-result
Revolt Backend: Result and Error types
-
function-compose
lib to allow composition of sync and async rust functions
-
dynamic
A dyanmically typed value with fast downcasting
-
temp-stack
A data structure for contexts or similar stack structures that are allocated on the call stack, using the temp-inst crate for lifetime erasure
-
frust
Functional Programming in Rust
-
html_stack
A stack based dsl for writing html. This is not an html template!
-
typers
Type level programing
-
cflp
A context-free-language parser generated by procedural macros
-
slice-copy
Go style copying for slices
-
static-cond
Macro for performing comparisons during macro expansion
-
try-again
Retry synchronous and asynchronous operations
-
respan
Macros to erase scope information from tokens
-
delegatemethod
Delegate method calls to a field
-
init_cell
A safe-to-access, unsafely-initialized cell
-
identifiers
working with rust identifiers and keywords
-
io-arc
Proof of concept Arc with IO trait delegation
-
vec2
-
map-self
Map a value itself instead of its contained value in usual closure style
-
mixed_array
Construct arrays of mixed types
-
kimari
Universal DSL for writing rules against the context in Rust
-
symbolism
Unique symbols made from human readable tags
-
optional-index
Optional indexing operations
-
namedarg_rustc_macro
namedarg main package
-
fn-compose
A small macro for function composition
-
pretty_assertions_sorted
Wrapper around the
rust-pretty-assertionscrate that allows for the ability to sort the Debug output -
anyint
traits and structs for working with integers of any bit size
-
hashmap_macro
hashmap macro for creating hashmap from provided key/value pairs
-
sum_error
Derive macros for fast summing of error types into error enum
-
miette_helper
providing helper macros for miette
-
once-option
OnceOptiontype, similar toOption, with the constraint that once emptied it cannot be re-set to contain a value. Useful for members that need to be consumed on drop or cannot be re-set otherwise (e… -
qol
Quality Of Life functions and macros
-
bigerror
handle big errors ¯\_(ツ)_/¯
-
engineer
master builder!
-
array_init_macro
initialization macro for arrays
-
stringlit
A macro to convert from str to String
-
structural
Field accessor traits,and emulation of structural types
-
comptools
Create iterators using Python's list comprehesion style
-
js-source-scopes
extracting and dealing with scope information in JS code
-
cursor
A more free Rust-Iterator
-
zisvalidator
A validator for struct and enum
-
has_impl
Check if trait is implemented for type in compile time
-
array-lit
Macros for array and
Vecliterals with superpowers -
using
A macro for simpler builders with method cascading
-
status
Error container
-
loopcell
cell for multiple routes of access that are only used one-at-a-time in sequence
-
id_cache
A cache data structure which generates sequentially-assigned ids for unique values
-
raw
unsafely manipulating raw representations in Rust
-
explicit_cast
explicit widening, truncating, and sign casting of primitive integers
-
chandeliers-err
Internal error message generators for the Chandeliers project
-
e_num
Serialize enums to numbers
-
collections-fromstr
Derives FromStr for collection types like Vec<T> or HashSet<T>
-
cfg-or-panic
Replace function bodies with
unimplemented!()when condition is not met -
type-layout
Derivable trait to view the layout of a struct, useful for debugging
-
easyerr
easier creation and transformation of error types
-
structmap
Procedural macro library for converting between Rust structs and associative containers
-
place_macro
Macros you wish you had while you were writing your non-proc macro
-
tuple_length
determining the length of a tuple
-
archery
Abstract over the atomicity of reference-counting pointers
-
borrown
Borrowed or owned, simplified for no-std
-
arraylib
Tools for working with arrays
-
default_macro
My default!() macro
-
rubber_duck
Enables building functions that can be called with named arg syntax
-
auto-lsp-core
Core crate for
auto_lsp -
ngram_iter
An iterator of arbitrary N-grams of rust Copy types
-
integer-atomics
allows you to compile code that needs the unstable integer atomics types (Atomic{U,I}{8,16,32,64}) with the stable compiler
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
remarklib
The core of the Remark programming language
-
alternator
Tools for building effect system -like functionality by abusing async
-
funfun
Macros for working with closures
-
err-per-field
A more fine-grained control over field-level error handling
-
clone-into-box
cloning trait objects
-
bail_macros
Bail macros for Options, Results and more
-
collect-all
vec! for everything: easily make literals of any collection!
-
errloc_macros
Error location utility macros
-
rich-result
Rich result type differentiating between recoverable & fatal errors
-
arg_attr
Specify the accepted arguments depending on configuration conditional checks
-
scope-functions
Kotlin-inspired scope functions for use in almost any situation
-
error-trees
Fail with multiple errors, istead of only the first
-
pointer-identity
Wrapper type to treat the pointer address of types as identity rather than the value
-
postgres_extras
extentions and utilites for working with postgres
-
multiref
Multireferences: a safe way to do [&T] -> &[T]
-
mic
Facilitates answering to competitive programming problems
-
open-ambient
Open files and directories with constant paths
-
as_base
Cast trait objects to some base class
-
hash_table_datastruct
Adds a HashTable type, allowing to store values in a table with integer-indexed rows and hashable keys for columns
-
ama
Quasi-quotation system for designing procedural macros mixed with Rust code
-
chain_linq
.NET's LINQ in rust as a declarative macro
-
bointer
Assorted pointer-related utilities
-
tuple-fn
call functions and closures with tuple of arguments
-
strongly
A proc macro to create strongly-typed primitives
-
batbox-tuple-macros
Macro for calling your macro for all tuple sizes
-
exclusive_cell
A thread-safe, non-blocking, no-std cell that can only be accessed once
-
ref_clone
borrows as higher kinded types that can be used to prevent code duplication
-
structify
A procedural macro to transform functions into structs with state and execution dependencies
-
dstr
get string from Debug trait
-
const_num_bigint
const bigint
-
n_best
Convenient collection to gather the N highest elements, and discard the others
-
identity
A stable Rust implementation of an identity (a.k.a., “equality witness”) type
-
see-through
traits to provide access to internal fields of generic structs
-
box-macro
Literally just the macro
box_!which isBox::new -
iter_from_closure
Iterator<Item = Item> from FnMut() -> Option<Item>
-
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
lifelink
Erase covariant lifetime parameters from anything, with generic associated types
-
capture
A macro for adding explicit capture clauses to a (closure-) expression
-
ref-map
Helper trait for Option and Result to map references
-
forward-traits
A general trait-forwarding crate
-
index-fixed
convert slices into arrays using indexes ([T] -> [T;N])
-
fstrings
Python3 fstring interpolation in Rust
-
oneshot-fused-workaround
Fused wrapper for futures::channel::oneshot
-
authorized
struct's fields
-
what-i-want
Some tools to help with the return value
-
fmt_adapter
newtype adaptors to and from any formatting trait
-
fake-enum
creating FFI safe "fake" enum types
-
eso
Type machinery to build Cow-like containers
-
consume-iterator
Consume any iterator fully
-
bbtk
A collection of frequently used libraries that should be in stdlib
-
serde_extra
Various de/serialization methods
-
attr_alias
Reduce attribute repetition with aliases
-
swamp-vm-instr-build
builds opcodes for the swamp vm
-
smurf
SMall Useful Rust Functions
-
derive_default_builder
derives a builder implementation relying on all fields implementing Default
-
error-chain-mini
error-chain for minimalist
-
bongonet-error
Error types and error handling APIs for Bongonet
-
ghosts
Type-check non-existing
Phantomcode for Fun And Profit™ -
lazy_format
lazily formatting values for later
-
nightly2version
#[no_std]and fast crate a Rust version to a timestamp and vice-versa (along other things) -
map-to-const
Easily convert HashMap<K, V> to constant [(K, V); N] values
-
expect_macro
The expect! macro
-
shrinkwraprs
Auto-derive for Rust conversion traits -- make working with newtypes a breeze
-
any_ref
To capture and move things that are NOT 'static with memory safety
-
break-block-macro
A little syntactic sugar to tide us over until the
?operator can be used to exit try-catch scopes -
many-unzip
Unzip iterators into tuples of arbitrary length, surpassing the limitations of
Iterator::unzipanditertools::multiunzip -
keepops
Extension traits for keeping the input of mapping functions
-
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
sanitizeable
derive structs without certain fields
-
rand_macros
#[derive]-like functionality for therand::Randtrait -
dyncast
Downcasting made easy
-
simplerror
A zero-dep macro to declaratively define error enum types and their common trait implementations
-
array_builder
example for the ArrayBuilder RFC
-
option-cell
OptionCell: OnceCell but derivable from Option
-
rt-format
Fully-runtime equivalent of the format! macro
-
err-context
Lightweight context layers for stdandard library errors
-
perforate
A macro to generate variants of a struct to allow splitting fields for extended periods of time
-
arrcat
Array concatenation
-
enumex
Derive Macro for Plain Enum
-
sqlx-error
A wrapper around
sqlx::Errorto provide error path and additional context -
drop_ok
.drop_oksyntax sugar forResult. It’s instead of.map(|_|()). -
strser
A struct serializer for rust empowered with a macro
-
shpat
sasha's solution to common patterns
-
assert-cmp
Convenient assertion macros that print the failed expressions and their evaluated values
-
check-ends-macro
A couple of macros to simulate match with starts and ends of a string
-
async-anyhow-logger
An easy crate for catching anyhow errors from an asynchronous function, and passing them to your logger
-
take-if
A tiny utility for conditionally taking the contents of an option
-
canrun_basic
Basic goals constructors for the Canrun crate
-
rvs-c-api
C-API for Rvs - A library for defining and evaluating random variables using a simple DSL
-
optargs
Easily create macros for functions with optional arguments
-
ruva-core
Event Driven TEvent Handling
-
pin-projections
Declarative macro for creating projection functions for pinned objects
-
safe_math
Math without overflow, creates an enum and a macro to help mitigate any overflow while multiplying and adding
-
fast_fmt
faster, more flexible and more correct alternative to core::fmt
-
orx-selfref-col
SelfRefCol is a core data structure to conveniently build safe and efficient self referential collections, such as linked lists and trees
-
enum_delegate_lib
Internal macro implementations for enum_delegate - use to implement your own macros
-
sashay
Type-erased and lifetime-erased references and slices
-
eros
Context aware, ergonomic and precise error handling
-
generic
Higher level serialization of rust values to rust values
-
duplex
trait: interactive streams
-
cute
A macro for Python-esque comprehensions
-
assert_ok
A macro that asserts a Result is Ok
-
iterator-assertions
Assert something about an iterator in place
-
delay_init
Macro to declare lazily initialized types
-
bind_match
Convenience macro similar to
matches!but binds to variables in the pattern and returns anOptionof the result -
parametrized-macro
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
lang_extension
Rust Lang Extension
-
opera
Marker types that are easy to understand
-
io-extra
An extension trait for
std::io::Error, with shorthand constructors for variousstd::io::ErrorKinds -
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
sumtype-macro
Generate zerocost sumtype of iterators or closures
-
static-include-bytes
Like the built-in
include_bytes!macro but produces a static array definition -
onhtml
A dsl for writing html. This is not an html template! Not complete but easily extensible.
-
unsaferef
An unsafe reference without explicit lifetime
-
wrapped-list
Macro for wrapping elements of a list with an object, function, or another macro at compile time
-
temporary_enum_delegate_0_3_0
trait delegation functionality for enums and structs
-
bstringify
stringify! that yields byte string literals instead
-
parametrizer
safe crate for parsing properly-formatted math strings representing parametric functions into Rust functions
-
defew
A new() derive macro for structs
-
rocket-dependency-injection
Small experimental crate for adding dependency injection functionalities to rocket
-
minipre
Minimal C-preprocessor in Rust
-
errore
error handling and tracing
-
id-arena
id-based arena
-
assert_ne
assert not equals
-
pinpoint
pinned references
-
enum-utils-from-str
Code generation for mapping from strings to arbitrary values
-
specialize-call
A macro to invoke a function with type-arguments substituted according to a runtime value
-
from_map
that exposes the
FromMaptrait -
vec-unpack
Creates a Vec containing the arguments. vecu! unpacks iterable variables marked with @.
-
expecto-patronum
add beatiful animals to your panic outputs
-
defunctionalize
Defunctionalization as a proc-macro over modules
-
variante
Statically-verified enum variant names as strings
-
stack-trait
Stack trait with entry API for the LIFO element
-
builder_macro
A macro to generate structs and a corresponding builder
-
cow_arc
CowArc can be useful for decreasing memory allocations by sharing immutable memory
-
anxious
panic-free dialect of Rust
-
init-token
one-time safe initialization of static, without overhead
-
async-retry
Async Retry
-
with-macro
Syntactic sugar for calling methods
-
t_bang
macros for getting the type of a resource,
t!(variable)will return the type as &str -
relevant
A small utility type to emulate must-use types
-
isrepr
Generating validation from arbitrary memory to repr(C) types
-
rstring-builder
String builder type
-
heredom
Tuple notations to describe XML-like trees
-
bevy_cell
Attach Bevy's Handles/Entities statically to Types
-
derive_di
realized the dependency injection pattern
-
template-builder
making idiomatic, declarative, builder-like patterns that use the struct literal syntax
-
enumerare
working with enums
-
const_type
define enum-like const-types, but with aliases for variants
-
rs-utilities
Some utilities
-
rwtypes
Adds methods to read/write binary numbers to the Read and Write traits
-
adante
A versatile, small options parser for use in the command line
-
berusty
Me practicing Rust
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
model-mapper-macros
Macros for model-mapper crate
-
maplit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
number-types
A typenum clone I made for fun with some positive changes but much fewer features
-
scsys-core
scsys is a collection of primitives and utilities for use throughout the ecosystem
-
tagged_cell
Fast, initializable, and thread safe static variables
-
multizip
Zip 3, 4, 5 or more Rust iterators
-
libmw
constructing a pipeline of middleware functions
-
into_variant
Easily convert your types into the corresponding enum variant
-
pure_cell
Alternative to GhostCell that provides safe interior mutability via const expressions
-
goto
A safe but not complete implementation of the goto operator
-
championship
Generate championship fixtures using the round-robin tournament algorithm
-
own-ref
&own references with ergonomic macro construction
-
try-iterator
Adds a few fallible methods to iterators
-
podstru
Bureaucratic structs to speed up rust development
-
uuidcell
Ever needed Hash, not had it, and wanted a free implementation? Yes? Well this is probably not what you really want but enjoy
-
bisync
write async-generic code
-
array_manipulation
Methods for manipuling arrays in a Vec-like fashion. It will (probably) get into core once const expressions get less experimental.
-
anon_enum
Enum types with fully-generic variants
-
cartesian_array_product
Arrays of the cartesian product of a set of items
-
wherr
Enhance Rust errors with file and line details using the
#[wherr]macro for clearer debugging -
collect_array
Allows for collecting an Iterator into an exactly sized array
-
assert_into
For when writing .try_into().unwrap() feels too long
-
drop_some
.drop_somesyntax sugar forOption. It’s instead of.map(|_|()). -
constptr
NonNull without mutability
-
if-let-return
macro for
if let ... pattern -
mc-network-data-types
Minecraft network I/O data types
-
certain-map-macros
A typed map which can make sure item exist
-
fallible_map
fallible mapping over
Optionand iterators using functions that can returnResults -
macro_const
A macro for creating corresponding macro definitions for constants which evaluate to the same values
-
existential
quantification over lifetimes
-
newtype-derive-2018
macros for deriving common traits for newtype structures
-
session-keys-macros
GPL Session Macros
-
new_york
Home of the dollar slice
-
rust_io
Macro implementation for [rust_io] defining several operators to be used emulating Haskel [do notation]
-
lazier_static
A thin wrapper around
std::sync::OnceLockproviding cached, static, lazy initialization -
docgen
made for dynamically documenting Rust items created by a macro
-
kmacros_shim
Useful macros
-
tupiter
iterating over tuples
-
assert_cfg
static assertions for crate features, with descriptive errors
-
rustyinject
Zero-cost, compile-time DI framework for Rust
-
make_option
turns any type into an option, only if it is not already one
-
moveslice
A one-function crate to move chunks in a slice around
-
soft_assert
Non-panicking assertions
-
default_kwargs
The macro wich enables you to use default and keyword arguments in Rust
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
async_pipeline_for_lucas
Easy way to pipeline sync and async functions
-
mut_family
A GAT-based library for writing code that is generic over exterior/interior mutability and mutability of references
-
composing
Tools to compose functions
-
arraybox
A box with fixed capacity, backed by a byte array (it can be stored on the stack too). Implements fixed capacity
ArrayBox. -
generic-mutability
Allows the creation of APIs that are generic over mutability
-
no_error
an error library for no_std
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
pyo3_special_method_derive_0_21
Automatically derive Python dunder methods for your Rust code
-
vec_box
A single macro to create a vec of boxed elements, for trait objects
-
isnt
Inverted versions of boolean-valued stdlib functions
-
all-is-bytes
Because everything is just a bunch of bytes... right?
-
gpl-session-macros
GPL Session Macros
-
multi-trait-object
A type to store an object with all associated traits
-
exponential-backoff
An exponential backoff generator with jitter
-
lua-macros
Useful macros to join Lua with Rust
-
enum_index
Trait and macros for extracting Enum variant index
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
easy_errors
simplify and enhance error handling in Rust
-
ro_cell
A (mostly) readonly cell
-
utils-results
The easiest and most intuitive error handling solution
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
vecc
macro to create a vector of vector
-
nes
New Error System for rust
-
icee-container-rs
Container service for custom DI
-
same-types
Ensure that two types are the same
-
doublysure
Using types to make sure that you're sure, sure, and doubly sure
-
easy-conv
Cut down on trivial
impl From<A> for Bboilerplate code -
thin_delegate
Auto implementation of trivial delegation to inner types
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
dyngo
Type-safe dynamic (type-erased) generic outparams
-
scones
Generates simple constructors for structs
-
awint_internals
Internal utilities for the
awintsystem of crates -
generic_once_cell
A bring-your-own-mutex version of once_cell
-
untry
Kind of the opposite of the ? operator
-
unsaef
Macros to erase scope information from tokens
-
trait-variant
working with impl traits in Rust
-
aliri_braid_examples
Examples demonstrating usage of the
aliri_braidcrate -
my-ast
AST definition like general programming languages and S-expression macros
-
bool-mappings
Useful extensions to convert
boolto other Rust types -
dyn_safe
Take control of the Semver hazard of the
dynsafety of your traits! -
ocm
Outcome type for a value and its errors
-
dyn_struct
Construct dynamically sized types safely
-
on_demand
A macro to generate aux macros for on-demand usage
-
err-convert-macro
Errors converting macros
-
checked_array
A checked API for array types
-
tyfling
todo
-
const-it
const evaluation; slicing, error handling
-
cmd_error
print an error message and exit while unwrapping Options and Results
-
bidirectional_enum
Automatically generates conversions between an enum type and any other type
-
gemstone
collection of utilities
-
er
error
-
asserts-rs
Asserts utilliy macros for Rust
-
num-conv
num_convis a crate to convert between integer types without usingascasts. This provides better certainty when refactoring, makes the exact behavior of code more explicit, and allows using turbofish syntax. -
lazy_cat
Lazy concatenation of strings and other things in Rust
-
input-stream
IO streams similar to C++'s streams
-
container_literals
vec! like macros for creating maps and sets
-
ternary-rs
emulating the ternary operator from C/C++ (among other languages)
-
maller
that calls closures depending on the input data
-
struct-validation
trait and derive to validate structs and return a list of errors
-
iterr
Combinators for dealing with iterators of
Results -
orderless
Orderless/named functions in Rust.
add!(b = 2); // 4. -
fkl-dot
Feakin is a architecture design and visual collaboration tool. This is the parser for Feakin.
-
list_builder
Python-like list comprehensions in Rust
-
blue_typemap
A TypeMap Dependency Injection method for dynamic function parameters
-
macro-attr
macro_attr!macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derivecrate. -
arrutil
Functions for manipulating arrays from slices
-
not-so-fast
data validation with derive macro
-
bg
builder + generics
-
type-layout-syn2
Derivable trait to view the layout of a struct, useful for debugging. Patched for syn 2.
-
lisbeth-tuple-tools
A set of tools for tuple manipulation
-
ewe
Error-Wrapping Extensions (EWE): utilities for application-layer errors
-
statum-macros
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
generics2
macros for parsing generics (with optional where clause) in
macro_rules!- enhanced fork of generics -
rs_observable
observable pattern implementation
-
tidy-builder
builder generator that is compile-time correct
-
tuple-conv
Allows converting tuples of one element to vectors
-
inline-array
efficient immutable inlinable byte array
-
simple-di
dependency injection for Rust
-
io_err
serializable
std::io::Errorwith improved ergonomics -
cgp-component
Context-generic programming core component traits
-
ground-env
Parse env variables by defining a struct
-
result-inspect
Adds the missing Result::inspect() function
-
field-projection
Field projection experiment
-
bounded
numeric types
-
meticulous
Result extension to add more meaning to unwrapping
-
rev_slice
A newtype for operating on a reversed view of a slice
-
internal
fields in Rust
-
static_leak
Leak references with static lifetimes from static Mutexes and RwLocks
-
serde_closure
Serializable and debuggable closures. This library provides macros that wrap closures to make them serializable and debuggable
-
ret_ty_attr
Specify the return type depending on configuration conditional checks
-
if-none
Early break/continue/return if an optional expression evaluates to
None -
fn_chain
Helper macro/function to create function chaining
-
testkit
A DSL for testing. Starting with APIs and Browser automation.
-
dont_panic
panic!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won't panic.
-
as_tuple
View any struct as a tuple! ✨
-
anygma
makes it easy to define arrays containing different types
-
expand_array
Macro to convert a static array to a fixed-size array
-
typesafe-builders
Infallible compile-time checked builders for your structs
-
fused_error
working with composable errors
-
ferment-interfaces
Traits for FFI conversions and some helper methods
-
boow
Borrow Or oWnedsmart pointer. Alternative to Cow. -
typed-builder-macro
Compile-time type-checked builder derive
-
unnest
Macros for an unnested control flow
-
blk_count_macro
macro for counting a number of comma-separated tokens at compile time
-
closure_capture
Capture variables are moved into closure or async block
-
coe-rs
Type coercion
-
byte-slice
Byte slice manipulation macros
-
serde_str_helpers
Helpers for using serde with strings
-
rust-fsm-dsl
Macros for rust-fsm DSL
-
thisctx
Easily create error with contexts
-
generic_error
A package containing a generic error type that can be dropped in to simplify error handling
-
sod-log
Service Oriented Design - Log Integrations
-
bitbit
Bit-at-a-time reader/writer types
-
primitive-from
trait PrimitiveFrom that is what From is to Into for num_traits::AsPrimitive
-
leaky-cow
Leak the contents of a Clone-On-Write pointer
-
install-framework
lightweight cross-platform install framework written 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
-
into_index
Helper traits allowing indexing into vectors and similar types by other types than
usize -
debug-map-sorted
Sorted Debug impl for HashMap
-
okk
approach to replacing the
Ok(()) -
tosserror
derive(Toss)
-
typeful
A collection of helper derive macros for type patterns
-
new_type_derive
Combat primitive obsession by easily creating strongly-typed wrappers and reference types
-
useful_macros
My useful macros
-
rvs-parser
Parser for Rvs - A library for defining and evaluating random variables using a simple DSL
-
iter_mod
A macro for enumerating all the constants in a module
-
hash-that-set
Implements hashing for sets and maps themselves. Enables a map of maps to values, or a map of sets to values.
-
constany_blank
Convert any function to constant
-
into_inner_drop
A helper library for implementing into_inner method for drop types safely
-
unwrap_helpers
Helper macros for unwrapping
-
sssstd
🐍 - A better analogy for resizeable arrays
-
exun
Handle unexpected errors
-
intentionally-empty
An intentionally empty crate
-
array_iter_tools
Modify simple arrays
-
nestle
Encode/decode arbitrary nested tree-structured data with a single integer
-
anymap
A safe and convenient store for one value of each type
-
byte-array-struct
Macro to create a byte-array backed struct
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
rustility
A collection of utilities I often find myself using in Rust
-
tia
tia; trait, impl, accessors | automatic
-
dioptre
Struct field projection tools
-
roxygen
Seamlessly document function parameters with rustdoc
-
rusty_state
state machine for rust
-
partial-context
Partial Context Types
-
negative-type-bound
negative type bound
-
dynerr
Macros for dynamic error handling
-
disjoint-borrow
Disjoint mutable borrows of slices
-
convertable
Non-reflexive version of From and Into
-
rustcane
Rust macros for general-purpose syntax sugar
-
failchain
Ergonomic companion library for failure
-
fancy-default
A better
derive(Default)implementation -
lazy-pinned
lazily pinned data
-
test-macro
macro for writing Rust test code in an easy way
-
snoot
The best s-expression parser this side of the Mississippi!
-
cfg_matrix
Procedural macro to generate permutations of supertraits based on cfg flags
-
default-ext
extension methods for the
Defaulttrait -
bounded-integer-plugin
Bounded integers compiler plugin
-
result
Helpers for dealing with nested Result and Option types
-
nutype_macros
The newtype with guarantees
-
abi_stable_derive_lib
detail of abi_stable
-
generic-lexer
A generic lexer using a simple match function
-
zkp-macros-lib
procedural macros implemented using
proc_macro2 -
rust-strictmath
Rust portable strict math implemention
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
eirproject/libeir_syntax_erl
Erlang ecosystem common IR
-
async-pipeline
Easy way to pipeline sync and async functions
-
hobo_css_macros_decl
hobo is a Rust frontend framework
-
to_debug
An alternative to the ToString trait that uses the Debug trait
-
jealousy
A wrapper arount the envy crate, providing an easily implementable trait
-
assert-json-diff
Easily compare two JSON values and get great output
-
ferrunix
A lightweight run-time dependency injection framework for Rust
-
serde-struct-tuple-enum
Procedural macro for deserializing an enum of structs from tuples
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
no-std-thiserror
thiserror but no_std compatible
-
stack-vec
Ad-hoc compile-time sized
Vec<T>like types on the stack -
onlyerror
Obsessively tiny error derive macro
-
runtime_injector
Runtime dependency injection container
-
eraserhead
erase the lifetimes from types
-
rustato-core
Core functionality for the Rustato library
-
rawslice
Reimplementation of the slice iterators, with extra features. For example creation from raw pointers and start, end pointer accessors.
-
koption_macros
Some macros that are useful for working with
Options -
into-result
convenience trait for converting something into a
ResultorOption -
struple
Convert structures from and to tuples
-
md_match
A macro to support md-match syntax
-
cgp-async
Async-generic primitives to support both sync/async in context-generic programming
-
field_iterator
A derivable trait for iterating over the fields of a struct
-
injectify
impl Trait in structs
-
asserter
New assertion library for rust
-
algtype
Conversion between data and its representation, like Haskell Generic
-
array_ex
Easy and powerful compile-time array initialization
-
sub-array
Extract a sub-array out of an array
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
process-results
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.
-
kv-derive
Derive struct conversions from and to key-value vectors
-
boxed-array
Allows constructing boxed arrays directly onto the heap
-
futures-signals-structs
Derives mutable versions of structs for the futures-signals crate
-
pawn
An unchecked borrow-like operation for Cells
-
turbonone
macro for calling functions with Option<T> arguments
-
downcast-trait
Allow casting between traits
-
partial_eq_dyn
Two traits to enable PartialEq for types with trait objects as fields. Best used with the derives in partial_eq_dyn_derive
-
sugar
Rust syntax sugar collections
-
static_slice
Macro for creating static slices of arbitrary types
-
necessist-core
-
multiple_errors
Propagate multiple errors instead of just the first one
-
trace-error
Extensions to Rust's error system to automatically include backtraces
-
snaptest
Dead simple snapshot testing
-
into_ext
Extension trait for the “Into” trait, offering a method “.into_::<T>()” to specify the target type of conversion
-
scoped-callback
Register scoped functions with local references to 'static lifetime callbacks in a safe manner
-
write-only
References/slices that provide write-access, but no read-access
-
piping
Pipeline syntax in Rust.
4isize |> double(__) |> __ as usize. -
default-test
A default trait that can be used in tests
-
rubbl_core
Core types and traits for Rubbl, a Rust package for astrophysics
-
threadbound
Make any value Sync but only available on its original thread
-
vet
Arbitrary type validation
-
eiffel-macros
Eiffel is a library for Eiffel language inspired guard clauses with Rust macros. This is the macro rules part of the library.
-
cast_trait_object_macros
Cast between trait objects using only safe Rust
-
collect_array_ext_trait
Collect an iterator into an array
-
integer-result
Convert primitive and non-zero integer types to a Result
-
saturate
Rust traits for saturating conversion between numeric types
-
larc
Lazy Arc/Weak pointers
-
random-number-macro-impl
Generate random numbers quickly
-
apply_method
Allows you to apply any function given as a parameter to the object
-
join-lazy-fmt
Lazy
separator.join(iterable)method andlazy_format!for Rust -
json-toolkit
providing pointer facilities and extending 3rd-parties JSON types
-
async-rusqlite
A tiny executor agnostic wrapper around rusqlite to make calls to it async
-
tuple-arity
Get the arity (number of elements) of tuple types with 0-12 elements
-
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.
-
unborrow
Macro for calling a &mut self method with transient &-borrows of self in the parameters
-
ara_reporting
A Reporting library for for Ara Programming Language 📃
-
config-docs
A trait and derive macro to generate documentation for your structs
-
graphfind-rs
finding patterns in graphs
-
gatherr
Helpers for collecting values and errors from result iterators
-
disp_array
This adds a wrapper for arrays to give the 'Display' trait
-
newtype_derive
macros for deriving common traits for newtype structures
-
static_assertions
Compile-time assertions to ensure that invariants are met
-
include_data_uri
include a file as a data uri
-
static-events
creating zero-cost event systems
-
typify
JSON schema to rust type code generator
-
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. -
generic-statics
generic statics for rust
-
dispatchtable
Small library used to specify function dispatch tables HashMap<K, Box<Fn(..)>>
-
parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
exclusive
Place code into an exclusive context that won't collide with another context
-
boulder
Like a builder, but heavier
-
code-sandwich-crates-io-release-test
outer crate test releaase
-
negate
Attribute macro that generates negated versions of functions that return booleans
-
structinator_traits
traits allowing transfer of data from iterators to structs
-
canpack
Canpack Rust utilities
-
test_eq
assert_eq!-like macros that return a Result instead
-
typestr
type-level strings and slices
-
once_self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
case_iterable
A procedural macro to iterate over enum variants, ala Swift's CaseIterable
-
idealist
non-empty wrappers for standard list types
-
nested-struct
Create nested structs using a macro
-
stated-scope-guard
A more flexible RAII pattern for stated resouce management
-
set_field
Set fields on structs by string
-
elicit_macro
SmartPointer-like structure for polymorphism
-
mutslices
ability to create many mutable slices of a vector
-
layout-lib
view the data layout of a struct
-
libsugar
syntactic sugar in the form of a library
-
macaroni
The missing macro std library for Rust
-
dmutil
A collection of utility macros to ease the creation of other macros
-
try_tup_to_arr_macro
implement from tuple trait
-
quixutils
Common helpers and utils
-
precisej-printable-errno
Printable system call errors for nix
-
iterext
Padding and separation extensions to iterators
-
databend_educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits, temporarily used in databend
-
valido
An extensible Rust validation library that actually encourages the "Parse, don't validate" philosophy
-
derive-ex
Improved version of the macro to implement the traits defined in the standard library
-
merge-hashmap
Merge multiple values into one
-
macro-vis
Attribute for defining
macro_rules!macros with proper visibility and scoping -
asteroids
set of macros
-
destruct-drop
Macro for dropping the fields of a struct or enum without dropping the container
-
struct-variant
Minimal helper macro to generate an enum out of a list of structs
-
const-anonymous-functions
macro to create const anonymous functions
-
retour-utils
creating hooks with
retour -
errorcon
A small crate for scoping errors and easier error conversion
-
validated_newtype
newtypes with checked predicates (primarily for serde)
-
descriptive_toml_derive
Procedural derive macro for serializing a struct into a TOML template with field descriptions that is easily edited and deserialized
-
subset
Various subsets of slice's items that are able to iterate over references to selected items
-
debug-tag
Debug-only tagging for tracking values
-
thistermination
add the Termination trait to error enums inspired by thiserror
-
enum_derive
macros for deriving additional functionality for enums
-
inline_newtype
newtype macro inspired by kotlin's inline class
-
sql-functions
dialect specific SQL Functions
-
replace_err
Adds a
replace_errmethod toResultwhich throws away the current error and replaces it -
easy_ffi
An unwind-safe ergonomic ffi wrapper generator for Rust
-
wrap
Generic function wrapping
-
is_option
Tell you if your type is an
Option<_> -
kozo
syntax sugars for structs
-
offsetter
Macro for creating structs with fields at specified offsets, by automatically inserting padding
-
wrapped_enum
Useful macro to wrap existing types in an enum (common use for quick error handling)
-
kizuna
service locator
-
value
Type-level constants for generic contexts
-
zerocopy
makes zero-cost memory manipulation effortless. We write "unsafe" so you don't have to.
-
generic-global-variables
tools for implement generic global variables
-
struct_cache_field
Proc macro for caching method to struct field
-
unbox-box
“Wait why did I put a
*in front of that variable yesterday?” - Ifvaris a Box, usevar.unbox_ref()instead of&*varfor better readability