-
bitflags
A macro to generate structures which behave like bitflags
-
anyhow
Flexible concrete Error type built on std::error::Error
-
derive_more
Adds #[derive(x)] macros for more traits
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
ordered-float
Wrappers for total ordering on floats
-
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
-
thiserror
derive(Error)
-
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
-
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…
-
pin-project
safe and ergonomic pin-projection
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
bytes
Types and traits for working with bytes
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
shellexpand
Shell-like expansions in strings
-
snafu
An ergonomic error handling library
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
inventory
Typed distributed plugin registration
-
smol_str
small-string optimized string type with O(1) clone
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
similar-asserts
assert_eq! like macros with colorized diff output
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
approx
Approximate floating point equality comparisons and assertions
-
dyn-clone
Clone trait that is dyn-compatible
-
enum-map
A map with C-like enum keys represented internally as an array
-
macro_rules_attribute
Use declarative macros in attribute or derive position
-
human-panic
Panic messages for humans
-
frunk
developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
ouroboros
Easy, safe self-referential struct generation
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
generic-array
Generic types implementing functionality of arrays
-
typed-builder
Compile-time type-checked builder derive
-
zerovec
Zero-copy vector backed by a byte array
-
tap
Generic extensions for tapping values in Rust
-
io-lifetimes
A low-level I/O ownership and borrowing library
-
bon
Next-gen compile-time-checked builder generator, named function's arguments, and more!
-
memoffset
offset_of functionality for Rust structs
-
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… -
az
Casts and checked casts
-
nonempty
Correct by construction non-empty vector
-
bitfield
macros to generate bitfield-like struct
-
cap-std
Capability-based version of the Rust standard library
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
rustlings
Small exercises to get you used to reading and writing Rust code!
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
float-cmp
Floating point approximate comparison traits
-
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
-
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 -
error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
backon
Make retry like a built-in feature provided by Rust
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
counter
package to count generic iterables
-
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
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
-
nutype
The newtype with guarantees
-
volatile
wrapper types for raw pointers
-
arrayref
Macros to take array references of slices
-
dlopen2
opening and operating on dynamic link libraries (also known as shared objects or shared libraries)
-
rustdoc-types
Types for rustdoc's json output
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
constcat
concat! with support for const variables and expressions
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
assertables
assert macros for better testing, debugging, quality assurance, and runtime reliability
-
email_address
providing an implementation of an RFC-compliant
EmailAddressnewtype -
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.
-
educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits
-
enclose
A convenient macro, for cloning values into a closure
-
beef
More compact Cow
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
bit_field
bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
if_chain
Macro for writing nested
if letexpressions -
float-ord
A total ordering for floating-point numbers
-
derive-where
Deriving with custom trait bounds
-
async-once-cell
Async single assignment cells and lazy values
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
speculoos
Fluent test assertions
-
easy-cast
Type conversions which are expected to succeed
-
dlib
Helper macros for handling manually loading optional system libraries
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
bounded-integer
Bounded integers
-
konst
Const equivalents of std functions, compile-time comparison, and parsing
-
lazy_format
lazily formatting values for later
-
orchestra
Generate an orchestra of subsystems from a single struct
-
assert_matches
Asserts that a value matches a pattern
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
tynm
Returns type names in shorter form
-
unwinding
in Rust and for Rust
-
aide
A code-first API documentation library
-
by_address
Wrapper for comparing and hashing pointers by address
-
axum-valid
validation extractors for your Axum application, allowing you to validate data using validator, garde, validify or all of them
-
testresult
type for concise and precise test failures
-
stdext
Extensions for the Rust standard library structures
-
fragile
wrapper types for sending non-send values to other threads
-
all_asserts
multiple types of asserts that don't exist in the standard library
-
async-trait
Type erasure for async trait methods
-
erasable
Type-erased thin pointers
-
indenter
A formatter wrapper that indents the text, designed for error display impls
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
fallible_collections
adds fallible allocation api to std collections
-
failsafe
A circuit breaker implementation
-
inlinable_string
inlinable_stringcrate provides theInlinableStringtype – an owned, grow-able UTF-8 string that stores small strings inline and avoids heap-allocation – and theStringExttrait… -
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
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
ptr_meta
A radioactive stabilization of the ptr_meta rfc
-
arrow-buffer
Buffer abstractions for Apache Arrow
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
field-offset
Safe pointer-to-member implementation
-
comparable
comparing data structures in Rust, oriented toward testing
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
tuples
many useful tools related to tuples
-
buffered-reader
A super-powered Reader
-
bounded-collections
Bounded types and their supporting traits
-
recursion
cache-aware stack safe recursion
-
aws-smithy-types-convert
Conversion of types from aws-smithy-types to other libraries
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
error-code
Error code
-
array-init-cursor
help keep track of arrays of MaybeUninit
-
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… -
tiny-fn
Type erased closures on stack
-
valico
JSON Schema validator and JSON coercer
-
indoc
Indented document literals
-
fallible-streaming-iterator
Fallible streaming iteration
-
const-gen
generating (relatively) complex compile-time constants in rust
-
resman
Runtime managed resource borrowing
-
calendrical_calculations
Calendrical calculations in Rust
-
fatality
extension to
thiserror::Error -
custom_debug
Derive Debug with a custom format per field
-
merge
multiple values into one
-
dynosaur
Dynamic dispatch for return position impl traits and async in Rust
-
terrors
ergonomic and precise error handling built atop type-level set arithmetic
-
lender
A lending-iterator trait based on higher-rank trait bounds, with full std::iter::Iterator functionality
-
soa_derive
Automatic Struct of Array generation
-
rustrict
profanity filter for Rust
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
version-sync
ensuring that version numbers in README files and other files are kept in sync with the crate version
-
oxc_index
Newtype-style helpers for
Vecandusize -
fallible-iterator
Fallible iterator traits
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
lending-iterator
Fully general lending iterators in stable rust: windows_mut!
-
anymap3
A safe and convenient store for one value of each type
-
try_match
Fallible pattern matching with a function-like syntax
-
shaku
Compile Time Dependency Injection for Rust
-
tryhard
Easily retry futures
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
strck
Checked owned and borrowed strings
-
cascade
Dart-like cascade macro for Rust
-
debug-ignore
A newtype wrapper that causes a field to be skipped while printing out Debug output
-
overload
macro to simplify operator overloading
-
impl-more
Concise, declarative trait implementation macros
-
pusherator
Push-based version of Rust iterators
-
pretty_assertions_sorted
Wrapper around the
rust-pretty-assertionscrate that allows for the ability to sort the Debug output -
deriving_via
DerivingVia
-
concat-with
Extend the function of the
concat!macro instd -
as_variant
macro to convert enums with newtype variants to
Options -
deno_error
Error representation to JavaScript for deno
-
sptr
Strict Provenance Polyfill
-
reborrow
Emulate reborrowing for user types
-
joinery
A small crate for generically joining iterators with a separator
-
oxc-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
o2o
Object to Object mapper for Rust. Derive '(Try)From' and '(Try)Into' traits.
-
dupe
Marker for types which are cheap to clone
-
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.
-
ra_ap_hir_ty
The type system for rust-analyzer
-
outref
Out reference
-
lazy_errors
Effortlessly create, group, and nest arbitrary errors, and defer error handling ergonomically
-
const_soft_float
Const Soft Float Point
-
cap-std-ext
Extension APIs for cap-std
-
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. -
retry-error
An error type for an operation that can fail more than once
-
halo2-base
Embedded domain specific language (eDSL) for writing circuits with the
halo2API. It simplifies circuit programming to declaring constraints… -
capacity_builder
Builders where the code to calculate the capacity is the same as the code to write what's being built
-
core_extensions
Extensions for core/std library types, and other miscelaneous features
-
thiserror-no-std
derive(Error)
-
stak-sac
Stand-Alone Complex for Stak Scheme
-
dypdl
Libarary for Dynamic Programming Description Language (DyPDL)
-
simple-error
error type backed by a string
-
cast_trait_object
Cast between trait objects using only safe Rust
-
with_locals
Function attribute to return references to locals by using CPS
-
elain
Set a type's minimum alignment with const generics
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
culpa
error-handling syntax in Rust
-
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…
-
rc-box
Known unique versions of Rc and Arc
-
yazi-macro
Yazi macros
-
condtype
Choose types at compile-time via boolean constants
-
dec
A decimal arithmetic library providing high-level, safe bindings to libdecnumber
-
inline-python
Inline Python code directly in your Rust code
-
dync
An efficient alternative to
dyn Traitfor containerized types -
uniplate
boilerplate-free operations on tree-shaped data types
-
flex-error
Flexible error definitions using macros and traits
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
core_maths
Extension trait for full float functionality in
#[no_std]backed bylibm -
hax-frontend-exporter-options
The options the
hax-frontend-exportercrate is sensible to -
facet-reflect
Allows peeking (reading from) and poking (writing to) types that implement Facet
-
void
The uninhabited void type for use in statically impossible cases
-
moveit
safe, in-place construction of Rust (and C++!) objects
-
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
open-enum
An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
macro-machines
State machine macros with logging and graphviz DOT file generation
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator -
exhaust
Trait and derive macro for working with all possible values of a type (exhaustive enumeration)
-
stdio-override
overriding Stdin/Stdout/Stderr with a different stream
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
sealed
Macro for sealing traits and structures
-
devela
A development layer
-
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 -
andex
Safe, strongly typed array indexes and wrappers for rust with zero dependencies
-
panic-halt
Set panicking behavior to halt
-
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.
-
as-any
provide the AsAny trait
-
data-rw
io buffer write reader
-
freecs
A high-performance, archetype-based Entity Component System (ECS) written in Rust
-
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… -
retry
retrying operations that can fail
-
dispose
wrapper for values that must be consumed on drop
-
fixnum
Fixed-point numbers with explicit rounding
-
copyless
Ways to eliminate memcpy calls when using the standard library
-
lowdash
A Lodash inspired utility library to manipulate array and object for Rust
-
async-fn-stream
Lightweight implementation of
async-streamwithout macros -
parsable
A trait to easily parse data structures
-
devise
devising derives and other procedural macros
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
rust_info
Extracts the current rust compiler information
-
valitron
ergonomics, functional and configurable validator
-
tstr
Type-level strings
-
openapiv3-extended
data structures that represent the OpenAPI v3.0.x specification easily deserializable with serde
-
orion-error
Struct Error for Large Project
-
sugars
An useful collection of macros to make tasks easier
-
socketpair
Cross-platform socketpair functionality
-
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
ra-ap-rustc_pattern_analysis
Automatically published version of the package
rustc_pattern_analysisin the rust-lang/rust repository from commit 8fb32ab8e563124fe0968a2878b7f5b5d0e8d722 The publishing script for this crate lives at:… -
nshare
Conversion between n-dimensional types in different Rust crates
-
lazycell
providing a lazily filled Cell struct
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_partsandVec::into_raw_parts -
munge
Macro for custom destructuring
-
metered
Fast, ergonomic metrics for Rust!
-
autofolder
Single-element folding wrapper
-
ownedbytes
Expose data as static slice
-
tuple
Element-wise operations on tuples
-
k8-client
Core Kubernetes metadata traits
-
entrait
Loosely coupled Rust application design made easy
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
likely_stable
likely and unlikely compiler hints in stable rust
-
nunny
the definitive non-empty slice/array/vec library for Rust
-
wallee
Flexible concrete Error type built on std::error::Error with caller location tracking
-
beekeeper
A full-featured worker pool library for parallelizing tasks
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
thiserror-context
A wrapper around thiserror, giving you the ability to add context
-
iced_anim
creating animations in Iced
-
tuplex
Rust tuple extension
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
funty
Trait generalization over the primitive types
-
random-number
Generate random numbers quickly
-
refined_type
imbuing rules into types and elevating them to more robust types
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
auto_enums
allow multiple return types by automatically generated enum
-
lazy-static-include
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
fixed-hash
Macros to define custom fixed-size hash types
-
async-recursion
Recursion for async functions
-
metastruct
Abstractions for iterating and mapping over struct fields
-
delegation
Macro-based delegation for enums and structs
-
didp-yaml
YAML interface for Dynamic Programming Description Language (DyPDL) and DyPDL solvers
-
display-error-chain
Formats a standard error and its sources
-
miden-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
loft
embedded scripting language
-
fun_run
The fun way to run your Rust Comand
-
orx-pseudo-default
PseudoDefault trait allows to create a cheap default instance of a type, which does not claim to be useful
-
TSPL
The Simplest Parser Library
-
nom-supreme
A collection of excellent utilities for nom
-
smarterr
Smart error handling library
-
components-arena
creating complex domain-specific self-referential data structures
-
redis-macros
macros and wrappers to redis-rs to automatically serialize and deserialize structs with serde
-
racer
Code completion for Rust
-
redb_model
Redb model derive macro and DTO type conversion
-
leptos-mview
A concise view macro for Leptos
-
renege
Tracking cache validity using fast concurrent invalidation propogation
-
dynamic-plugin
Write compile-time-checked, dynamically-loaded plugin libraries for your Rust software
-
tracerr
Custom compile-time captured error tracing
-
istring
A replacement for String that allows storing short strings of length up to sizeof<String>() - 1 without a heap allocation
-
tinyvec_macros
Some macros for tiny containers
-
tighterror
A minimalistic error representation framework
-
doku
A framework for documenting Rust data structures
-
ufotofu
Abstractions for lazily consuming and producing sequences
-
relib_internal_shared
relib is a framework for reloadable dynamic libraries
-
emboss
Macros to embed metadata as an ELF/Mach-O section in your final binary
-
mownstr
Maybe Owned String
-
mechylang
toy language created for learning purposes
-
ffi_helpers
help make working with FFI easier
-
conv
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
mydi
MyDI. Dependency Injection library
-
parsel
Zero-code parser generation by using AST node types as the grammar
-
indices
macros and methods for safely retrieving multiple mutable elements from a mutable slice, addressing scenarios where slice elements would typically require
RefCellorCell(interior mutability approach) -
qualifier_attr
Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items
-
type-safe-id
A type-safe, K-sortable, globally unique identifier
-
macro-asm-builder
macro-assemblers
-
many-unzip
Unzip iterators into tuples of arbitrary length, surpassing the limitations of
Iterator::unzipanditertools::multiunzip -
downcast
Trait for downcasting trait objects back to their original types
-
resiter
Helper crate for handling iterators over result
-
stringleton
Extremely fast string interning library
-
as-is
An abstraction over ownership
-
fn_meta
Returns metadata about a function at runtime
-
type_reflect
Extensible runtime reflection through a Derive macro
-
garnish_lang_traits
Shared traits for garnish core libraries
-
statum
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
const-field-offset
Wrapper around field-offset crate and const-field-offset-macro
-
rust_writer
useful for editing a Rust file from Rust code
-
endian-writer
[no_std] Methods for efficient reading and writing of structures to raw pointers in a stream-like fashion
-
sod-actix-web
Service Oriented Design - Actix Web
-
oxrdf
providing basic data structures related to RDF
-
direction
Representations of directions
-
serialization
encode and decode your struct
-
macon
builder macro-based generator with its own idioms
-
rc-borrow
Borrowed forms of Rc and Arc
-
ext-trait
Annotation to easily define ad-hoc / one-shot extension traits
-
pretty-error-debug
If the process ends with an
Error, write out theErrormessage and chain -
familiar
reserve
-
strong-type
Procedural macros for naming and strong-typing pritimives and strings
-
match_cfg
A convenience macro to ergonomically define an item depending on a large number of
#[cfg]parameters. Structured like match statement, the first matching branch is the item that gets emitted. -
one_err
OneErr to rule them all
-
dtype_variant
Enables type-safe enum variants with shared type tokens across multiple enums, allowing for synchronized variant types and powerful downcasting capabilities between related enums
-
swamp-script-error-report
Swamp script error report
-
corlib
A various ideas library
-
enum-derived
Generate random instances of your enums and structs
-
aerosol
dependency injection for Rust
-
assert_approx_eq
assert approximately equal
-
diagnosticism
Miscellaneous discrete and simple diagnostics facilities (for Rust)
-
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…
-
documented
Derive and attribute macros for accessing your type's documentation at runtime
-
zed
A minimal, Redux-like state management library for Rust with advanced features
-
comlexr
Dynamically build Command objects with conditional expressions
-
nar_dev_utils
用于NARS相关项目开发的实用工具包
-
derive_tools
A collection of derive macros designed to enhance STD
-
regex-macro
A macro to generate a lazy regex expression
-
validify
struct validation and modification functionality through the use of derive macros
-
auto_ops
Macros for easy operator overloading
-
model-mapper
Derive macro to map between different types
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
ijzer
Main crate for IJzer. Provides a macro for using IJzer in a rust project, and a prelude with dependencies..
-
wincent
handling windows quick access
-
const_fn
A lightweight attribute for easy generation of const functions with conditional compilations
-
rustversion
Conditional compilation according to rustc compiler version
-
impls
Determine if a type implements a logical trait expression
-
thiserror-core
derive(Error)
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
cursive-extras
Extra views for the Cursive TUI library as well some helper functions and macros
-
drying_paint
observer pattern for Rust
-
kindest
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
portrait
Fills an
implwith the associated items required by the trait -
show-option
displaying Options
-
reflectapi
code-first web service API declaration and corresponding clients code generation tools
-
trait-cast
Get your own Any with support for casting to trait objects
-
derive_destructure2
Destructure structs that implement Drop
-
drop_bomb
A runtime guard for implementing linear types
-
certain-map
A typed map which can make sure item exist
-
taurpc
A type-safe IPC layer for tauri commands
-
enum-assoc
Procedural macro to associate constants with enum variants
-
scaffolding-core
A software development kit that provides the scaffolding for building applications and services using OOP
-
binmarshal
Pack and unpack structs and enums into and out of binary data streams
-
re_arrow2
Unofficial implementation of Apache Arrow spec in safe Rust
-
backtrace-error
wrap errors with automatic backtrace capture and print-on-result-unwrap
-
bool_ext
defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
hlist2
Compile-time heterogeneous list implementation
-
include-utils
mdBook-like include macro as the powerful replacement for the standard
include_strmacro -
sumtype
Generate zerocost sumtype of iterators or closures
-
marauders
A work-in-progress code mutation tool
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
dialogue-macro
An extension to dialoguer that simplifies command-line interaction interfaces
-
traitsequence
Traits to abstract over sequences
-
dyn-context
mechanism for lifetimes erasing
-
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
nameof
macro to determine the string name of a binding, type, const, or function
-
human-errors
An error library focused on providing your users with relevant advice for any problem
-
unsafe-fields
unsafe to access or modify fields with safety invariants
-
culprit
error crate with the goal of identifying precisely where and in which context an error occurs
-
enumeration
An extension to rust enum
-
allow
Alias/label lints (to disable) with your intentions. Reexported from allow_prefixed, grouped under rustc::, clippy:: and rustdoc:: modules.
-
stackerror
A pragmatic error handling library for Rust that provides helpful strings for debugging, and structured data for runtime error handling
-
clone_cell
A Cell that works with a restrictive form of Clone
-
steckrs
A lightweight, trait-based plugin system for Rust applications and libraries
-
assert-eq-float
assert_eq_float!macros that support floats -
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
mimium-lang
mimium(minimal-musical-medium) an infrastructural programming language for sound and music
-
service-builder
A lightweight, type-safe service construction library for Rust that provides compile-time dependency injection through builder pattern
-
dioxus-class
Dioxus class
-
alternating-iter
Provide an iterator adaptor which alternate between two iterators
-
case_insensitive_string
A case insensitive string struct
-
pipe-trait
possible to chain regular functions
-
rancor
Scalable and efficient error handling without type composition
-
tokenlock
cell types that decouple permissions from data
-
rudi
out-of-the-box dependency injection framework for Rust
-
dogma
Dogma.rs
-
concat_const
const
&[u8]and&strconcatenation -
ref_iter
Dynamic borrowing iterator
-
fp_rust
Implement fp features for Rust
-
px-wsdom-macros-decl
wsdom crate
-
asmov-common-traitenum
using fieldless enums as schema definitions
-
structz
Anonymous struct implementation in rust
-
hermit-sync
Synchronization primitives for kernels
-
empty-fallback-chain
Iterator adaptor like chain, but conditional on empty first iterator
-
bigerror
handle big errors ¯\_(ツ)_/¯
-
better_option_result
A better Option/Result alternative
-
state-department
state management and dependency injection in Rust
-
cooked-waker
A safe interface for creating async Wakers
-
text-block-macros
Create a multiline string literal
-
float_plus
Additional features for float values
-
linux-errnos
A list of error numbers
-
error-graph
Allows non-fatal errors in a tree of subfunctions to easily be collected by a caller
-
cl-format
Use Common Lisp format in Rust
-
hyperlight-guest
build guest applications for hyperlight
-
aws-sdk-s3tables
AWS SDK for Amazon S3 Tables
-
recursive
Easy recursion without stack overflows
-
collect-with
enhanced collection operations with capacity control
-
static-keys
Reimplement Linux kernel static keys for Rust userland applications
-
string_more
Extension traits for
Stringand&strtypes -
type-toppings
Opinionated extensions to standard types
-
nnn
Generate your newtypes from a single macro
-
no-unwrap
-
display_full_error
Minimal display formatter for error chains
-
hierr
RUST Error
-
defer
excecution of code, inspired by go's defer statement
-
binf
that adds utilities for dealing with binary flags
-
urlquerystring
A high-performance, zero-allocation URL query string parser
-
relend
A generalized reborrowing mechanism that extends beyond simple references. It also allows for implementing traits that work with reborrowing for custom types.
-
scout-parser
A web crawling programming language
-
kago
custom-width signed and unsigned integers
-
flexcell
A flexible cell that allows safe circumvention of double borrow issues
-
buildstructor
Macro to derive a builder from a constructor function
-
railsgun
Excessive tooling for Result handling - If you want rails you got RAILS!
-
flarrow-api
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
rst-common
A shortcut to common Rust crates
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
path_scan
A lightweight Rust procedural macro for parsing path patterns (URLs, routes) with variable capturing, static binding, and compile-time checks
-
macro-toolset
Some useful macros
-
htmf
hypertext markup functions: functions for generating HTML
-
salsa-macro-rules
Declarative macros for the salsa crate
-
structx
Simulating anonymous struct and named arguments in Rust
-
swamp-script-eval-loader
load swamp-scripts
-
pingora-error
Error types and error handling APIs for Pingora
-
stak-dynamic
Dynamic primitives for Stak Scheme
-
tupletools
functions for tuples
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
enum-ptr
Ergonomic tagged pointer
-
implementation
The implementation crate
-
borrowme
The missing compound borrowing for Rust
-
clamp_to
Clamp integer and float values to the values that fit within both the original number type and the receiving type
-
undo_stack
A minimal undo stack for user defined types
-
rshyper
focuses on hypergraphs
-
expect-exit
Result.expected(): display an error message and exit without a panic
-
copyvec
A contiguous growable array type, with a fixed, stack-alllocated capacity that implements Copy
-
crustal
generating C/C++ code
-
evcxr_repl
A REPL for Rust
-
semval
Semantic validation
-
yield-return
Implement a coroutine like C#‘s
yield returnusing Rust’sasync,await -
pike
A macro collection to pipe |> your functions calls, like in functional languages such as F#, Elixir and OCamel
-
radicle-std-ext
Monkey patches of std types
-
globals
Painless global variables in Rust
-
tamago
generating C code
-
fmt-cmp
Traits and utilities for lexicographically comparing values in their
Displayrepresentations -
elicit
SmartPointer-like structure for polymorphism
-
cfg-elif
Formatter-friendly conditional compilation at item and expression positions
-
tatl
in-process alerting
-
hex_lit
Hex macro literals without use of hex macros
-
qcl
A Query Check Language written in Rust
-
cgp-error
Context-generic programming error components
-
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)
-
mstr
2-word, immutable Cow<str>
-
rust-box
odd set of tools for Rust programming
-
easy-err
An easy Error wrapper
-
file_rw
high-performance, memory-mapped file I/O utilities
-
option_trait
Helper traits for more generalized options
-
relax
Derive Partial<T>
-
linear_type
Linear types for rust
-
fmt-interspersed
write an iterator's items, interspersed with a separator, to a destination
-
is-odd
Returns true if the given number is odd
-
anyerr
Dynamic error library with rich error wrapping and context support
-
ux2
Non-standard integer types like
u7,u9,u10,u63,i7,i9etc -
supertrait
enables default associated types and const fn trait items in stable Rust
-
spade-hir
Helper crate for https://spade-lang.org/
-
static_file_util
generating and managing static files in Rust applications
-
error_mancer
Quickly define custom error enums for a function
-
hlua
Zero-cost high-level wrapper for Lua
-
transpose-future
Transpose Option<impl Future>
-
typeid
Const TypeId and non-'static TypeId
-
maybe-uninit-ext
Extended maybe-uninit types
-
safecast
Traits to define safe casting between types
-
cache_diff
Generate clean, human readable diffs between two cache structs
-
portable-io
“ A subset of Rust
std::iofunctionality supported forno-std -
type_cell
Attach values statically to a type using static get/set methods
-
univec
A vector that can hold elements of any single type
-
parametrized
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
flat_string
FlatString is fixed allocated size String that that can be created direcly on the stack
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
orx-closure
An explicit closure with absolute seperation of the captured data from the function
-
numeric_cast
Safely cast between numbers
-
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
-
clsx
A flexible class name composition utility for Rust, inspired by clsx and tailwind-merge
-
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
-
wipe-on-fork
A replacement to OnceCell, LazyCell, Once, OnceLock, LazyLock that wipes itself when being forked in Unix
-
either_of
working with enumerated types that contain one of 2..n other types
-
axum-openapi3
Facilitate the generation of OpenAPI 3.0 documentation for axum applications
-
non_structural_derive
nonstructural derives for auto traits
-
ferment
Traits for FFI conversions and some helper methods
-
prima_bridge
implement the bridge pattern
-
cove
Casts Of Varying Elegance (COVE): extension traits for casting numerical types
-
rs_envflag
An easy way to define flags by environment variables
-
fnrs
some useful functions i like
-
pilgrimage
A Kafka-like message broker in Rust
-
wiwi
Stuff™
-
cortex-ai
An asynchronous flow-based processing framework for building flexible data pipelines with conditional branching and error handling
-
game_inventory
An inventory system independant of item data
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
pair
Safe API for generic self-referential pairs of owner and dependent
-
codegen
generating Rust code
-
pareg
useful tools for command line argument parsing
-
hash-db
Trait for hash-keyed databases
-
flat-drop
Wrapper that drops recursive objects iteratively to avoid stack overflows
-
handled
error handling library
-
visibility
Attribute to override the visibility of items (useful in conjunction with cfg_attr)
-
sovran-typemap
A thread-safe heterogeneous container with type-safety
-
steel-core
Core compiler and VM implementation for steel
-
pipa
Pipe Operator Library for Rust
-
locate-error
Add location info to errors
-
iterstats
Statistics for rust iterators
-
wrap-match
A procedural macro to wrap a function in match statement to make error logging super easy
-
maybe-borrow
Macros for conditionally returning borrowed data
-
re_error
Helpers for handling errors
-
ownable
Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more
-
baxe
that simplifies error handling in Axum
-
failed-result
A small crate for converting various failed value to result with corresponding error type
-
barexp
that automatically generates mod.rs files for your project
-
degeneric-macros
Hides struct generics into trait associated types
-
dyn-hash
Hash trait that is dyn-compatible
-
simfony-as-rust
Tools for working with Simfony as literal Rust
-
linked_list_r4l
Linked lists that supports arbitrary removal in constant time
-
entity_data
A container for entity component data
-
enum_cycling
Small macro for working with enums
-
droppy
Friendlier dropwatch
-
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. -
list_tools
一个自己研发的Vec<T>
-
struct-field-names-as-array
generating the field names of named structs as constants
-
oma-pm
APT package manager API abstraction library
-
jkcenum
Rust enum library
-
quick-error
A macro which makes error types pleasant to write
-
polyvalue
A weak-typed analog for rust
-
branch_hints
that provides likely and unlikely branch hint functions in stable Rust
-
backtrace-ext
minor conveniences on top of the backtrace crate
-
optfield
A macro that generates structs with optional fields
-
mayheap
An abtraction over alloc & heapless
-
flarrow-layout
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
chainerror
Make chaining errors easy
-
std-next
Opinionated utilities and polyfills
-
anyhow-http
Customizable HTTP errors built on anyhow
-
copy_from_str
An extension trait to copy a string into another string
-
try-specialize
Zero-cost specialization in generic context on stable Rust
-
ordes
treating arrays and tuples a little bit more like vectors
-
ra-ap-rustc_next_trait_solver
Automatically published version of the package
rustc_next_trait_solverin the rust-lang/rust repository from commit 8fb32ab8e563124fe0968a2878b7f5b5d0e8d722 The publishing script for this crate lives at:… -
mago-span
Tracks exact character positions in source code, making it easier to report precise errors, warnings, and other diagnostics
-
conerror
macro that automatically adds context to errors
-
error_status
Model common error context with HTTP 4xx and 5xx code
-
prost-unwrap
A procedural macro for prost-generated structs validation and type-casting
-
padder
Highly efficient data and string formatting library for Rust
-
typle
Generic tuple bounds and transformations
-
pisserror
A golden rip-off of thiserror
-
inline-c
Write and execute C code inside Rust
-
code-path
A code path macro
-
io-streams
Unbuffered and unlocked I/O streams
-
pyo3-error
Unified error causality chains across Rust and Python
-
sod
Service Oriented Design
-
var_num
Variable length number implementation that can be used as a drop in replacement for any number primitive
-
nohashmap
Use HashMap syntax in Rust for non-hashable types
-
fluent-asserter
write tests assertions with a fluent interface
-
despatma
Design Pattern Macro like Loki
-
restructed
Quickly derive subsets of your structs
-
swamp-error-report
Swamp error report
-
generativity
Generation of unique invariant lifetimes
-
nix-compat-derive-tests
Nix protocols and data formats
-
random_variant
To be used with all variant, contains the derive macro
-
ty-tag
TypeId for lifetime containing types via type tags
-
non-empty-str
Non-empty strings
-
fx-callback
A subscription based callback to inform subscribers about relevant data events within structs
-
gesha-rust-types
Rust types for Gesha proejct
-
with_drop
Nostd wrapper for using a closure as a custom drop function
-
gen_ops
Macros for operator overloading for generic types
-
strprintf
Provide a way to interpolate printf-style format strings using native Rust types. Part of libnewsboat lib dependencies
-
bisync
write async-generic code
-
path-dsl
DSL and macro to help deal with Paths and PathBufs
-
superstruct
Versioned data types with minimal boilerplate
-
blanket
macro to derive blanket implementations for your traits
-
bherror
TBTL's library for error handling in Rust
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
mod_use
pub mod xxx; use xxx::*;
-
blf_lib
Multi-purpose Blam-File library
-
tisel
Effective type-based pseudodynamic dispatch to impls, enums and typeid
-
string_capacity
Moved to capacity_builder
-
odesign
optimal design of experiments library written in pure rust
-
libgpg-error-sys
Raw bindings for libgpg-error
-
naan
A fast, easy, and tasty functional programming prelude
-
anthill-di
Rust di containers system
-
take-until
A take_until extension for iterators
-
problem
Error handling for command line applications or prototypes
-
vtid
generating volatile type IDs
-
rt-format
Fully-runtime equivalent of the format! macro
-
assert_matches2
A version of the assert_matches! macro that brings variables from the pattern into scope
-
orfail
Error handling library for portable unrecoverable errors
-
fallthrough
Pattern match with fallthrough, in the style of C switch
-
unchecked_wrap
Convenient UncheckedSync/Send wrapper types
-
precomputed-hash
intending to be a base dependency to expose a precomputed hash
-
nz
Collection of 100% safe macros for creating non-zero integers more easily
-
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… -
famedly_rust_utils
Random rust utility functions and types
-
deptypes
Dependent types
-
result-like
Option/Result-like monad interface for your own enum
-
restd
A re-implementation of various std features
-
deltoid
calculate and apply deltas to structs and enums
-
re_tuid
128-bit Time-based Unique Identifier
-
lithium
Lightweight exceptions
-
surreal_devl
Contains core logic of surreal derive
-
round
your floats with precision from 1 to 10
-
steepen
Create multiple iterators from a single iterator by separating elements
-
sitrep
Frontend-agnostic progress reporting
-
thiserror-nostd-notrait
derive(Error)
-
tomldoc
generate documentation for toml configs defined with serde-derive
-
selfie
Experimental, macro-free and allocation-free self-referential structs
-
libgraphql
building GraphQL tools, clients, and servers
-
refinement-types
Refinement types
-
prange2
Parse numeric ranges for indexing
-
graphql-starter
GraphQL starter kit
-
availability
describing availability of items
-
animatron
Animation state management
-
thiserror-ext
Useful extension utilities for
thiserror -
getopts-macro
Using macros to concisely define the getopts
-
error2
error handle library for Rust
-
concat-string
macros for concatenating string slices into owned strings
-
should
Postfix assertion library for Rust
-
truc_runtime
Rust code generator for safe, fixed size, evolving records - runtime
-
cew
Personal Rust utility library
-
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
-
maybe_path
Zero overhead static initializer for Path
-
trackr
Track changes on a struct as bitflags
-
command-error
Detailed error messages and status checking for
std::process::Command -
shadow_counted
An iterator that counts every iteration in a hidden counter, nested iterators may commit the count to parents
-
borrow-or-share
Traits for either borrowing or sharing data
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
bitstructs
Defining type-safe bitfield structures that can be used in both
stdandno_stdenvironments -
instability-example
Example crate demonstrating instablity usage
-
mode
A behavioral state machine library written in Rust
-
syllogism
allow for some specialization using stable Rust
-
typederror
A wrapper around anyhow that allows for a primary error type
-
value-box
Allows developers to pass Rust-allocated structures over ffi
-
add_macro
more additional macros to help you write code faster!
-
axum-routes
Create an axum Router from an enum and resolve routes
-
named-tup
Create named tuples using the tup!() macro
-
catboost
inference library for Rust
-
single-instance
single instance application
-
hs-bindgen
Handy macro to generate C-FFI bindings to Rust for Haskell
-
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. -
abstract-impl
Create abstract implementations for traits
-
eoe
exiting processes on errors gracefully
-
ffizz-passby
FFI helpers for implementing pass-by-value and pass-by-pointer
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
slice-utils
A collection of slice utils, like itertools
-
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
-
fromage
A cheesy Rust hack for converting between non-local types
-
partial_derive2
makes all the properties of a struct type an optional property
-
cloneable_errors
similar to anyhow, that allows the errors to be cloned, shared, cached and even sent over the network
-
scorched
logging library for scorching all those pesky bugs
-
isolator
A lightweight library for isolating Rust functions
-
processmanager
manage process lifecycles, graceful shutdown and process faults
-
menva
Manage environment variables
-
easy_node
Smart pointer for graph nodes
-
std-traits
Traits for types in the standard library
-
columnation
Unsafe columnar containers for native Rust types
-
indexed_valued_enums
Create enums resolving into values, and get their variants back through their values or their discriminant, inspired by Java
-
nanvm-lib
NaNVM library
-
variadiz
Variadic function support for rust
-
facet-poke
Build and alter arbitrary Facet types
-
never
A stable version of the unstable never type (!)
-
xacro
A xml preprocessor for xacro files to generate URDF files
-
variadics_please
Implement things as if rust had variadics
-
sfo-result
Result type for Rust
-
assemblist
Define your builder patterns as you use them
-
circomspect-program-analysis
Support crate for the Circomspect static analyzer
-
constptr
NonNull without mutability
-
deterministic_default_hasher
A deterministic initialisation of the stdlib default hasher
-
intertrait
Allow for inter-trait casting
-
should_match
Pass a test if the output matches a pattern
-
kix
A result type for testing that supports to eliminate using of Result::unwrap
-
doc-comment
Macro to generate doc comments
-
rukt
dialect for token-based compile-time scripting
-
bellframe
Fast and idiomatic primitives for Change Ringing
-
gan
Just do it! A small tool provides ergonomic value handling with ignore/ ok/ some semantics
-
olis_string
Small-string optimization for Rust, aims to replace std::string::String
-
cmp
convenience macros and function for comparing
-
tacit
macro to make newtypes easier to create
-
sentry-contexts
Sentry integration for os, device, and rust contexts
-
suika_mime
handling MIME types in the suika web stack
-
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
-
overloaded_literals
Overloaded Literals to construct your datatypes without boilerplate and with compile-time validation
-
default-constructor
Macros for creating pseudo-dsls that constructs structs through default construction and field conversion
-
sigmut
a state management framework designed to be used as a foundation for UI frameworks
-
conflate
Merge multiple values into one
-
transitive
derive macros for Rust
-
anywho
Anyhow, but cloneable
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
iterator-sorted
Stable functions for checking iterator sorting
-
native_messaging
Async implementation of MDN native messaging. Provides the ability to install host manifest.
-
fast-concat
Fastest macro for concatenating strings
-
panic-message
Get a panic message from a panic payload
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
fastpeek
A different way to peek iterators
-
no-break
Typesafe extraction of continuation values from unbreakable control flows
-
unsafe_cell_slice
A microlibrary for creating multiple mutable references to a slice
-
bint
Bounded Integer in Rust
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
enumtrait
macros for polymorphism using enums
-
dowhile_rs
Do while macro for rust with labels and nesting support
-
dyn_std
Dynamic (object-safe) version of std traits
-
kind
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
derail
An alternative to
core::error::Error -
wrapnum
Ever wanted to make easy arbitrary number wraparounds? Now you can
-
fn-traits
function traits like the standard library ones, but can be used in stable Rust
-
onlyerror
Obsessively tiny error derive macro
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
dynamic-dispatch
Allows compiling generic functions that do not have generic parameters inside a library, specifying all the possible specializations for each generic type
-
iter-scan
Iterator scan methods that don't suck
-
checked-rs
encoding validation semantics into the type system
-
asn1obj
Rust Asn1 format decode/encode
-
validated
The cumulative sibling of
ResultandEither -
iter-index
More flexible alternative to Iterator's enumerate() method
-
iced_af
The iced application framework project
-
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
-
mac
A collection of great and ubiqutitous macros
-
ltptr
Checked raw pointers
-
copstr
COpy STRing module
-
static-id
A memory-efficient library for handling interned identifiers
-
threadporter
First aid kit for !Send + !Sync values ⛑️
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
nyar-error
Error types for valkyrie language
-
primitive-from-enum
macros for get primitive enum from complex
-
argcall
Enables enums and structs to be callable by associating functions with their variants or fields
-
blue_typemap
A TypeMap Dependency Injection method for dynamic function parameters
-
impl-rlp
RLP serialization support for uint and fixed hash
-
kti_cqrs_rs
CQRS pattern in Rust
-
maybe-single
A singleton. Maybe.
-
pyo3_special_method_derive
Automatically derive Python dunder methods for your Rust code
-
generics
macros for parsing generics (with optional where clause) in
macro_rules! -
elvish
Overengineered Advent of Code framework - not quite Santa's elves
-
tantivy-derive
Generate code to converts struct from and to tantivy documents
-
struct-metadata
Macros for attaching metadata to structs
-
iter_variants
A way to iterate over all variants of a rust struct/enum
-
assert_has_field
macro for checking if a struct has a specific field
-
zirv-macros
A collection of useful macros for everyday programming
-
autofloat
Pure Rust library for efficient automatic differentiation
-
rama-error
error types and utilities for rama
-
sourceannot
render snippets of source code with annotations
-
rust-code-analysis-web
Run a web service to compute and export code metrics
-
slugify-rs
generate slugs from strings
-
pgde
A macro library for consuming PostgreSQL row data into structs
-
first-err
Find the first Err in Iterator<Item = Result<T, E>> and allow iterating continuously
-
v8_derive
Derive macros and helpers for Rusty v8
-
enumcapsulate
Safe casting for newtype enums and their variants
-
patched
Macro for patch like structure
-
minlin
minimal linear algebra made to be as convinient as possible
-
discriminant-rs
Convert enum to integer type
-
map_range_int
map a value from one range to another
-
scoped_thread_local
Highly flexible Scoped thread local with HKT builtin
-
assume
Macro for stating unsafe assumptions in Rust
-
misfortunate
Perverse implementations of safe Rust traits
-
abcgen
A procedural macro to generate boilerplate code for objects implementing the 'Actor' pattern
-
oofs
Error handling library that generates and injects context for you
-
iter_fixed
Iterator of fixed length
-
wherr
Enhance Rust errors with file and line details using the
#[wherr]macro for clearer debugging -
null-pointer
0x0.st file uploader
-
thiserror_string_context
Adds context string to error enums generated with thiserror
-
crate-inspector
inspect the public APIs of Rust crates
-
akvakulturregisteret_rs
API for det nye offentlige Akvakulturregisteret
-
array_trait
A generic trait for any array, with item as type and length as const parameter
-
better-as-any
Automatically makes your trait objects downcasting-capable
-
ocl-macros
Macros for easier/faster working with the ocl crate
-
partial_application
partial function application via the partial! macro
-
limnus-local-resource
local resource storage
-
bounded-vector
Vec wrapper that guarantees upper and lower bounds on type level
-
niloecl
axum handler pattern for twilight interactions
-
ser_mapper
Mapped DTO serialzation wrapper for DBO/Model
-
docsplay
A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc
-
apply
A tiny library for chaining free functions into method call chains
-
trybuild-internals-api
A fork of trybuild with the internals exposed as a public API
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
oxiderr
Streamlining Error Handling in Rust
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
dims_macro
Macros for Generating Systems of Units
-
cell_wrappers
set of macros for ergonomically working with TCells and TLCells from the qcell crate
-
buggy
A less panicky replacement for unreachable!() and unwrap
-
lucene_query_builder
A procmacro derive crate to generate lucene query builder for Rust structs :
-
try_hard
Malleable error handling for rust
-
asm_block
Translate tokens to string for Rust inline assembly
-
to-display
A trait that is Display or can be converted to Display
-
yoylib
simpler
-
proguard
Basic proguard mapping file handling for Rust
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
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
-
arrcomp
Python-style list comprehension syntax for contiguous memory Rust arrays
-
bash-builtins
implement loadable builtins for bash
-
smt-str
working with SMT-LIB strings in Rust
-
guard-clause
Syntactic sugar for writing simple guard clauses
-
ombrac-macros
Safe, fast, small TCP tunnel using Rust
-
async-iterator
An async version of iterator
-
self-rust-tokenize
Turns instances of Rust structures into a token stream that creates the instance
-
transitionable
A no_std compatible type to transition
T -> Twhere you have an&mut T -
dilib
A dependency injection library for Rust
-
derive-insert
GetOrInserttrait for enums and its derive macro -
approxim
Approximate floating point equality comparisons and assertions
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
shive
lightweight IOC service container writen for the Rust applications
-
runestr
User-perceived characters related types and data structures
-
tuple_list
macro-free variadic tuple metaprogramming
-
cdumay_error_standard
define standard errors
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
iter-identify_first_last
A helper iterator, flagging first and last elements
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
cgp-error-eyre
Context-generic programming error handlers implemented using eyre
-
mago-interner
A string interning library that stores and reuses identical strings efficiently, improving memory use in large codebases or tools
-
murrelet_livecode_macros
livecode macros for murrelet, a livecode framework
-
crony
cron runner that spawns another thread to run your cron jobs
-
composable
Easy composition of functional traits, functions or closures
-
impl-opaque
Macro for declaring complex struct and initializer
-
rust_examples
rust 的学习中的一些例子
-
therror
derive(Error) with a twist (based on thiserror)
-
gravitron_macro_utils
Gravitron's Macro Utils
-
safelog
Conditionally suppress confidential information from logs
-
wutil
A lightweight library that contains useful functions, wrappers, and macros
-
adjacent-pair-iterator
An iterator over adjacent pairs in another iterator
-
nonany
Integer types with customizable niche values
-
rust2fun
functional programming in Rust
-
result_logger
aux functions for Results to log errors
-
rw-exact-ext
Extension of std::io to read and write data types with exact amounts of bytes
-
range_checker
derive-macro crate aimed to provide declarative bounds checking and filtering for structure
-
azalia-config
🐻❄️🪚 Defines traits, types, and utilities for dealing with application configuration
-
tri_ton
A Macro for Handling Exceptions
-
newer-type
Support defining newtype wrapper with inheriting trait implementations
-
partial_function
A clean way to define function as a set of subfunctions where each has defined start and end bounds
-
pyderive
Derive macro of Python special methods and a class attributes for PyO3
-
flagger
Enum flag generator
-
typed_index
A strongly typed Index that know what it is indexing
-
funcmap
Derivable functorial mappings for Rust
-
tor-basic-utils
General helpers used by Tor
-
qcontext
One-time initializable static state with statically-checked zero-cost interior mutability
-
nil
Noxmore's Ixperimental Lutilities
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
wiwi-macro-decl
declarative macros for wiwi, a library, of, Stuff™ (implementation detail; do not depend on this crate directly)
-
supply
Provider API for arbitrary number of lifetimes
-
newstr
macros for declaring String-base new types
-
io-adapters
Adapters to convert between different writable APIs
-
tracked
A stringly-typed Error that includes
#[track_caller]information -
lazy-init
Lazy initialization
-
hexga_map_on
Define the map_on! macro that can be used to impl a lot of trait quickly using macros
-
strtod
A high precision floating point parser implementation for Rust
-
vec-of-enum
Helper macros for a Vec of enum values
-
unwinder
Call stack spoofing for Rust
-
defer-heavy
A versatile and easy to use defer statement for Rust. Similar to Go's or Zig's defer.
-
cast_checks
A procedural macro to check for invalid casts
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
map
map!macro andmap_insert!macro, to create a HashMap collection and insert key-value pairs. Inspired by thevec!macro. -
structmapper
help you generate code that mapped one struct to another
-
sudo_plugin
Macros to easily write custom sudo plugins
-
stratagem
A trait library that enables state management and command execution with built-in undo support, inspired by the Command design pattern
-
ebnsf
A CLI to generate railroad (syntax) diagrams from EBNF specs
-
qwreey-utility-rs
Qwreey's shared rust codes
-
type-sig
Ever needed to inspect types more precisely? Then this crate is for you!
-
yugen
Writing rust like python
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
shared-type
Shared type alias and several traits to simplify working with Arc<Mutex<T>>
-
ffi-enum
Simply write and use
enums like rust native enums, freely passing through ffi -
pit-rust-externref
Portal Interface Types
-
deep_safe_drop
Safe dropping of deep trees that otherwise could cause stack overflow
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
kutil-std
std utilities from Kutil
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
ghost
Define your own PhantomData
-
once_cell_serde
Single assignment cells and lazy values
-
shame
Commonly used utilities to trade performance and compilation time for development velocity
-
has-some
The opposite of is_empty (and is_empty for filters)
-
sai
IoC/DI framework for Rust
-
unzip_iter
Unzip an iterator to iterators
-
nolife
open a scope and then freeze it in time for future access
-
sealed_trait
making sealed traits more accessible
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
simple-logging
logger for the log facade
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
cowstr
Copy-on-Write shared strings
-
seal-the-deal
Attribute to use on the
traitmethods (or associated functions) that you wish to “seal”, a.k.a., render themfinal -
gazebo
A collection of well-tested utilities
-
windows-helpers
Helpers for the windows crate
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
yukon
trait for the ability to cheaply duplicate an object
-
flowstdlib
The standard library of functions and flows for 'flow' programs
-
msgpck
A no-std and async compatible msgpck de/serializer
-
rs42
collection of utilities to make programming in Rust more enjoyable
-
emboss_common
Common types and constants for emboss
-
os_type
Detect the operating system type
-
defmac
A macro to define lambda-like macros inline
-
openapi_type
OpenAPI type information for Rust structs and enums
-
const_str_slice_concat
const concatenation of string slices
-
const-macros
Various macros for const contexts
-
destructure_traitobject
Unsafe helpers for working with raw trait objects. (Forked from traitobject)
-
zero_v
implementing iterators over function outputs for collections of types implementing a common trait, without using vtables/ dynamic polymorphism
-
friperms
framework for creating typed permission models for whatever system you could phatom
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
externcfn
macro_rules for define correct extern 'C' functions with an normal syntax
-
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
-
sayaka
some simple colorful debugging functions
-
mapper
Mapping macro to help to reduce mapping boilerplate
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
libikarus
The core functionality of Ikarus wrapped neatly in a rust library
-
eros
Context aware, ergonomic and precise error handling
-
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.
-
ir_aquila
personal utility library, not for public use(yet)
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
progress-streams
Progress callbacks for types which implement Read/Write
-
early_returns
Macros to make early returns easier to work with in Rust
-
twine-core
framework for functional and composable system modeling
-
entrypoint
opinionated application framework/wrapper that eliminates main function boilerplate
-
str-macro
The str!() macro, similar to vec![] but for strings
-
the-string-macro
The missing
string!macro to constructStringvalue from string literal -
vector3d
3D vector type
-
rhai-rusp
Rhai bindings for the Rust USP toolkit
-
lazyinit
Initialize a static value lazily
-
fungus
reduce code verbosity
-
tuple_split
An extension for the tupleops crate which adds a trait for splitting tuples
-
implicit-fn
A macro that adds support for implicit closures to Rust
-
home-prelude
Prelude library to support home applications
-
poison-guard
maintaining sane state in the presence of panics and failures
-
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
nype
Newtype helper macros for Rust
-
parameterx
flexible and type-safe parameter management system for Rust applications. This library provides multiple ways to store and retrieve typed values using a key-value structure, with support…
-
golangify
published at 01.04.2024 this crate brings familiar flavor for newcomers from golang
-
rsor
Reusable slice of references
-
typestate
A proc macro DSL for typestates
-
inline-option
A memory-efficient alternative to Option that uses a pre-defined value to represent None
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
proc-easy
Macros to make writing proc-macro crates easy
-
succinct
data structures for Rust
-
hook
A filtering mechanism where functions (filters) can be registered, prioritized, and applied sequentially to values associated with named hooks. In Rust.
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
option-like
Create your own Option-like enum
-
ffxiv_types_cn
Useful types for FFXIV-related projects
-
enum-unitary
Trait and macro for unitary enums
-
errore
error handling and tracing
-
collect_exact
Allows zero-cost collection into exact-size arrays and tuples
-
elor
Base generic implementation of an Either type
-
marker_trait
Implement a blanket implementation for a marker trait
-
tardar
Extensions for diagnostic error handling with
miette -
anyreader-walker
reading streams of compressed and uncompressed data without knowing the format in advance
-
manifest-dir-macros
function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
singleton-manager
A programatical singleton manager
-
vcell
Cellwith volatile read / write operations -
makepad-error-log
Makepad error logging
-
send-future
Ergonomic and performant fix for https://github.com/rust-lang/rust/issues/96865
-
easy-error
error utilities
-
plain_hasher
Hasher for 32-byte keys
-
errata
Ergonomic pretty error handling for binaries
-
strum-lite
Lightweight declarative macro for sets of strings
-
unwrap_or
Four easy unwrap Result and Option macros that allow for any inline-scoped code for things like return, continue, and break
-
goof
A reusable, composable, aggregate and
no_std-friendly error library -
konst_macro_rules
detail of the konst crate
-
ref_wrapper
Wrapper of dynamically borrowed data
-
easy_errors
simplify and enhance error handling in Rust
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
chalk-macros
Macros for Chalk
-
dataflow
data processing library, primarily for machine learning
-
rtoolbox
functions for other crates, no backwards compatibility guarantees
-
as_num
Checked conversions between Rust's numeric types
-
err_mac
no dependency macro for creating error enums with automatic
Fromimplementations -
coercible_errors
Zero-cost error handling for generic traits
-
stub-macro
stub!() is a better version of todo!() that can be assigned to a variable
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
nzliteral
Macro simplifying use of NonZero literals
-
hb_error
Useful macros and traits for creating and handling errors
-
typeables
type aliases. By SixArm.com.
-
rustato
A global state management library for Rust applications
-
forgy
Derive macro for building dependency graphs
-
datafusion-functions-window-common
Common functions for implementing user-defined window functions for the DataFusion query engine
-
declarative_enum_dispatch
Declarative macro generating boilerplate for enum dispatch
-
assert_hex
display assert panics in hexadecimal {:#x?} format
-
plectrum
An easy way to represent lookup tables in a db as rust enums
-
isr-macros
Macros for ISR
-
thin_cstr
An experimental crate which provides a truly thin std::ffi::CStr
-
fused_error
working with composable errors
-
set_derive
Using Macros to Implement List comprehension Similar to Python Language
-
trybox
stable,
no_std-compatible, fallible heap allocation -
coded
concrete error type with an
ErrorKindenum matching Google’s “canonical error codes” -
variant_counter
Rust's Enum variant counter
-
std_utils
Standard utilities for Rust
-
cve-rs
Blazingly fast memory vulnerabilities, written in 100% safe Rust
-
effing-mad
The hottest algebraic effects library in Rust
-
chassis
Compile-time dependency injection framework
-
scoped-writer
Scoped writer utility
-
bongonet-error
Error types and error handling APIs for Bongonet
-
enum_index
Trait and macros for extracting Enum variant index
-
xmacro_lib
macro engine for producing multiple expansions
-
softfloat-sys
Rust bindings for Berkeley SoftFloat 3
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
okapi-response-mac
A macro for creating response code based on responses structs rather than typing and implementing OkapiRocketResponseInner manually
-
enum_discriminant
Procedural macro to add functions on enum types to get discrimnant value from variant or create unit variant from discriminant value
-
methods-enum
Two macros for easy implementation of 'state' design pattern and other dynamic polymorphism using enum instead of dyn Trait
-
macro_error
A macro to display error message
-
getfn
generating function pairs to refer to functions via custom expressions
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
ioc
An Inversion-of-Control library in Rust
-
const-exhaustive
Enumerate all values of a type at compile time
-
b-x
The stupidest boxed error ever
-
fluent-string
Fluent versions of String mutation methods
-
nougat
(lifetime) GATs on stable Rust
-
tl_list_lib
Type-level kinded heterogeneous list for type-level programming in Rust
-
compiler_base_error
-
hexga_generational
GenVec, ideal for MAS (Multi-Agent System), where each agent can be removed at any time and has references to other agents
-
debug-fn
A function adapter that implements Display and Debug
-
diatom-std-core
Diatom core standard library
-
single_thread_cell
Create a cell that can only be accessed by a single thread
-
match-commutative
Match on patterns commutatively, reducing the use of duplicated patterns. ↔️
-
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
zerror_full
macro for implementing helpful errors
-
squeak
providing types allowing execution of callbacks in response to values being broadcast or mutated
-
isbn
handling ISBNs
-
market
Infrastructure for producers and consumers
-
podio
Additional trait for Read and Write to read and write Plain Old Data
-
summum-types
A sum-type macro crate with all the conversions, accessors, and support for abstract methods across variants, and interoperability between sum-types
-
serde_table
Write structs in an easy table format
-
enum_handler
A macro to generate a handler trait for enums variants
-
microtype
simplify the creation of microtypes
-
eventually
using Event Sourcing in Rust applications
-
tryiter
functions for Iterators of Results
-
incomplete
incomplete!(), a compile-time checked version of unimplemented!()
-
ident-util
macro to determine the string name of a binding, type, const, or function
-
ai_iter_utils
A short description of my package
-
own
Wraps an owned or borrowed value
-
async-safe-defer
Minimal async- and sync-capable
defercrate -
throw
Efficiently add statically-calculated stack traces to errors
-
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)
-
annasul_macro
annasul: macro library
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
comparable_test
comparing data structures in Rust, oriented toward testing
-
singlemap
rust single map a macro
-
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
kstring
Key String: optimized for map keys
-
coc
A useful macro collections for struct
-
named-block
Macro implementing early-exit-from-any-block
-
dyn-dyn
Flexible trait object downcasting using ptr_metadata
-
proto-mapper
A Macro library for easier mapping between custom models and proto generated code
-
rt_map
Runtime managed mutable borrowing from a map
-
fixed-macro-types
Macro aliases used in the
fixed-macrocrate -
check
Convenience assert!-like macros which return instead of panicking
-
catalyser
A comprehensive collection of extensions to simplify and enhane rust development
-
jnt
full of just neat things
-
tuplemagic
manipulating tuples through various operations like mapping, filtering, nesting, and reducing
-
limbo_ext
Limbo extensions core
-
lsp-ty
type definitons for LSP
-
lucchetto
easily call a rust function without holding the GVL lock
-
pond
scoped and cached threadpools that keep a state
-
macro-attr-2018
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
yadi
Dependency Injection framework for writing applications with Rust programming language
-
rs-std-ext
An extension for the standard library
-
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 -
option-ext
Extends
Optionwith additional operations -
min-max
max! and min! macros
-
pl-lens
support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
shorter-bounds
Write shorter bounds with a trait alias macro
-
char-device
Character Device I/O
-
useful_macro
Collections of useful macros
-
utility-macros
emulate Utility Types and Unions from TypeScript
-
ra-ap-rustc_type_ir
Automatically published version of the package
rustc_type_irin the rust-lang/rust repository from commit 8fb32ab8e563124fe0968a2878b7f5b5d0e8d722 The publishing script for this crate lives at:… -
iter-comprehensions
iterator comprehensions
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
prev-iter
Iterator which allows you to view the previous element
-
type_enum
Create tagged unions consisting of different types
-
custom-format
Custom formatting for Rust
-
tiny-input
Tiny input macros
-
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.
-
hkt-pin-list
Self managed HKT intrusive linked list
-
mapcomp
Python-like list comprehensions for standard containers
-
adhesion
A set of macros for design by contact in Rust. The design of this library was inspired by D's contract programming facilities.
-
ryu_floating_decimal
Fast floating point to floating decimal conversion. See the crate 'ryu' for more details
-
our-string
Customizable shared strings with inlining
-
extend-fn
Use arbitrary FnMut when something that must implement Extend is needed
-
bty
Streamlined definition and usage of branded types in Rust
-
rtlola-reporting
An error reporting crate for RTLola-related crates
-
unwrap_todo
Option::todo and Result::todo methods
-
bit_roles
Granular role management based on bit flags
-
nest-guard
working with nested guard-type APIs
-
matr
A metaprogramming library for Rust
-
enum_downcast
Safe downcasting for enums
-
defer-lite
A lightweight high-performance implementation of Go's defer statement
-
tc-error
TinyChain's generic error struct
-
load_file
Macros to help conveniently load the contents of files during development
-
nade
Adding named and default arguments to Rust functions
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
extended-primitives
providing primitive-like types for use
-
cifg
A macro for defining #[cfg] if/else blocks; alternate to cfg-if
-
almost
comparing floating point numbers
-
dirty-fsm
A quick and dirty state machine library
-
cond
Rust macro to use a match-like syntax as an elegant alternative to nesting if-else statements
-
type_ulid
Trait for associating ULIDs with Rust types
-
medi-rs
mediator library for Rust
-
easy-ext
A lightweight attribute macro for easily writing extension trait pattern
-
rusty-cmd
creating custom line-oriented command interpreters in Rust
-
seesaw
generate traits from C header files
-
safe-discriminant
A minimalistic,
no_stdcompatible trait and procedural macro for extracting discriminants from enums at zero cost -
combin-iterator
Some usefull facilities for combining iterators
-
hexga
include all other console hexga crate in one !
-
swamp-script-derive-tests
tests for swamp macro
-
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.
-
oneline-eyre
A fork of
simple-eyrewhich outputs errors on a single line -
panicking
std::thread::panickinganalog available in theno_stdcontext -
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
entwine
Generic slice-like interface for operating on multiple slices at the same time
-
control-flow
A hack to control control-flow outside closures
-
emplacable
Return unsized values from functions
-
laxcow
Clone-on-write smart pointer with relaxed trait constraints
-
plain_enum
Mimicing Java's enum::values() and EnumMap
-
tosserror
derive(Toss)
-
inline_dyn
A container type for storing dynamically-sized types inline
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
macon_api
builder macro-based generator with its own idioms
-
ref-ops
An escape hatch for implementing
opstraits for references to newtypes -
field33_rdftk_names_temporary_fork
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. -
const_struct
macro that allows const structures to be passed as const generics
-
namewise
Derived trivial name-wise conversions for Rust types
-
hado
Monadic do notation using a macro
-
enum_delegate
Easily replace dynamic dispatch with an enum, for speed and serialization
-
state-shift
Macros for implementing Type-State-Pattern on your structs and methods
-
yadir
Dependency Injection Registry for Rust
-
retrying
General-purpose retrying library for Rust with macros and functions
-
error-iter
Error::sources on stable Rust
-
type-uuid
Safe, stable IDs for Rust types
-
sod-crossbeam
Service Oriented Design - Crossbeam
-
isclose
A collection of trait and macros for comparing approximate equality
-
dungeon-cell
Store (almost) any value as one type without dynamic memory
-
multer-derive
derive for constructign type from multer Multipart
-
wrapp
Add additional functionality to Rust errors using a wrapper
-
gur
A undo-redo framework
-
netcdf3
A pure Rust library for reading and writing NetCDF-3 files
-
interpolate
form of string interpolation
-
dyn-ptr
A box that stores types like pointers, forgetting everything besides
Self: Unsize<dyn Trait> -
data_models
used to lookup the sizes of various C-types of historical data models
-
serde-textual
derive Display/FromStr by using serde
-
tectonic_errors
A boxed error type for Tectonic, with supporting utilities
-
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
thread-scoped-ref
that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
rcss
Rust CSS embedding library
-
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
-
lup
A custom indexed loop macro library for Rust
-
reax
A reactivity system for Rust that infers dependencies between functions
-
collar
easy array collection
-
cryo
Extend the lifetime of a reference. Safely.
-
fn_zip
zip trait for functions, allowing two functions to be combined before being called
-
unwrap-macros
Convenience macro for unwrapping result and option
-
pin-macros
primarly used to simplify the proccess of working with self-referencial structures
-
cfgenius
Conditional compilation with macro support in Rust
-
sly_static
Seamless Rust Static Initialization: Effortless and Efficient
-
captur
Macro to capture whole structs from disjoint fields in a closure
-
aspect
Toolkit for Rust
-
thiserror_core2
derive(Error) (no_std-enabled using core2)
-
copy_impl
Macro for effortlessly duplicating impl block code across various types in Rust
-
tl_str_list
Type-level string (tl list of chars)
-
smart-string
A collection of string types and traits designed for enhanced string manipulation
-
interning
Thread-Lcoal and Global Interning Library
-
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
const-type-layout
Derivable const trait to view and compare the layout of a struct, union, or enum
-
typemap-meta
compile-time macro to create type-to-value maps
-
hello-world-in-rust
Hello World!
-
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…
-
kti_cqrs_provider_rs
CQRS provider with ioc container
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
enumx
Ad-hoc enum extension
-
functor_derive
A derive macro to derive a functor for a type
-
syscall_encode_traits
Traits and macros to help define a syscall interface for a kernel
-
fuck-backslash
replace the backslash with slash in-place in your PathBuf
-
except
The only one
Error -
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
not-found-error
Convert Option to Result using convenient functions
-
iceyee_error
Error Message
-
typesafe-builders
Infallible compile-time checked builders for your structs
-
flexi_func_declarative
exposes the fb! macro to create a function with a flexible signature
-
koute/nes
emulator written in Rust
-
is_slice
Macro to answer the question: is it a slice?
-
irox-types
Enums and structs to describe Rust's basic type system
-
log_limit
A rate limiting logging crate
-
dare
daring flexible data representation
-
kmacros
Useful macros
-
veho
a iterable toolset
-
sirena
Digital audio signal processing primitives
-
advent-of-rust
Advent of Code utility macro for Rust
-
stylish-core
The semver-stable subset of
stylish -
genztools
Tools for readability of Result and Option types for zoomers
-
meticulous
Result extension to add more meaning to unwrapping
-
chasa
A parser combinator with
manytaking iterator, conditional branching, and method chain -
core-nightly
Nightly build of libcore from the rust repo
-
advancer
Helper for advancing over mutable slices
-
error_def
syntax extension for generating error-handling boilerplate code
-
bilk
Miscellaneous convenience functions and traits
-
tangu
language
-
variant_count
Derive macro for enum which adds to it the count of variants
-
as-result
Traits for converting types which may be interpreted as or into a result
-
warnalyzer
Show unused code from multi-crate Rust projects
-
query_interface
Dynamically query a type-erased object for any trait implementation
-
high_mem_utils
bunch of mem safe abstractions,some involving transmute
-
ddi
Dynamic dependency injection library for rust
-
facet-spez
Auto-deref specialization helpers for the Facet reflection system
-
imgref-iter
A small crate for iterating over the rows or columns of
imgrefbuffers -
rust_kafka_like
A Kafka-like message broker in Rust
-
shoggoth
Generic and type-level programming for Rust
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
pipeop
Adding the pipe operator to Rust with a declarative macro
-
string-literals
Rust macros to more easily create String types
-
kube-core
Kube shared types, traits and client-less behavior
-
simple_detailed_error
Stack and specify errors explainations saying what happened, why, how, where, how to solve it and its causes
-
delegare
delegate struct easy
-
xxlib
Rust xxlib
-
ref_kind
Different reference kinds
-
vnum
Create enums with a constant value associated to every variant
-
projecture
Easy arbitrary type projections without proc macros
-
scientisto
A light-weight Rust implementation of the github/scientist library used for careful refactoring of critical code paths
-
buffer
Safe, write-only, generics-free buffer abstraction
-
butcher
An easy way to interact with structs and enums wrapped in Cows
-
dyn-error
Error-related utilites for Rust
-
yikes-intenum
Augment integer-based enums with an unknown variant; a macro that makes you say "yikes!"
-
rual
A slim, embeddable language
-
atomic_non_null
An atomic wrapper around NonNull
-
pre
Compile-time assistance for working with unsafe code
-
romap
A trait for read-only-maps
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
ffizz-header
FFI helpers to generate a C header for your library
-
accursed-unutterable-type-id
A worse version of std::any::TypeId
-
sized-dst
Owned container for dynamically-sized types backed by inline memory
-
pin-init
Safe pinned-initialization in Rust
-
lyneate
beautiful code underlining and error reporting
-
lsp-document
Helpers to convert between LSP documents and Rust strings
-
ebacktrace
error wrapper which captures a backtrace and can carry an optional textual description
-
hip-runtime-sys
Bindings for the HIP runtime
-
tailsome
Blanket traits providing
.into_ok(),.into_err(), and.into_some()for happier method chaining -
pluck
Extract values conveniently
-
algar
Algebraic structures, higher-kinded types and other category theory bad ideas
-
itemizer
Containing an itemizer to itemize structs
-
size
expressing, formatting, and interacting with file sizes
-
ad-hoc-iter
Ad-hoc exact size owning iterator macro and other optional utils
-
custom_derive
(Note: superseded by
macro-attr) This crate provides a macro that enables the use of custom derive attributes -
sdml-core
Core Model for Simple Domain Modeling Language (SDML)
-
regexm
macro for writing regex pattern matching
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
clap-doc
Create markdown descriptions for
clap::Commands -
wx-core
微信数据解析工具
-
cgp-extra
Context-generic programming extra meta-crate
-
fsm_gen
FSM (finite state machine) DSL for code generation (c++ at the moment)
-
coi
Dependency Injection library
-
pass_by_catastrophe
Please do not use this
-
bruteforce
no_std-compatible brute force/string generation rust-nightly library
-
illicit
An implicit thread-local environment which is indexed by type
-
backyard-nodes
Nodes representing PHP code AST
-
null-terminated
slices and UTF-8-encoded strings with thin references
-
internship
Interned string and more
-
read-restrict
Restrict the number of bytes read from a reader
-
ez-err
error handling library with support for ergonomic and fast error handling
-
exun
Handle unexpected errors
-
numtest
Unit testing for numerical methods
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
posix-errors
Posix error codes and handy functions for using them
-
throwing
Create explicit errors easily with a handy macro
-
result-ext
Extends
Resultwith additional operations -
should_error
The test should fail with Err
-
anon_enum
Enum types with fully-generic variants
-
range-split
splitting sequences with range parameters
-
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… -
better_any
Type id and Any for non static types
-
notzero
macro for constructing
std::num::NonZero*from constants -
shared_singleton
trait provides singleton pattern state management with shared container
-
nonicle
Tools for type-safe, canonical data representations
-
valq
macros for querying and extracting value from structured data by JavaScript-like syntax
-
ruschm
Scheme(R7RS-small) interpretor/compiler rust implementation
-
private-gemm-x86
x86 matmul impl
-
std_io_iterators
An iterator for
STDINand a wrapper forSTDOUT. Allows easy piping, and graceful closing of application if pipe breaks -
fast-rustc-ap-rustc_errors
Automatically published version of the package
rustc_errorsin the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
desaturate
This package aims to makes it easier to maintain a single code base for both regular and async functions
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
collapse
Trim and collapse consecutive whitespace to a single space
-
simple_parse
A declarative converter for Rust type to and from binary
-
recursive_reference
way to walk on recursive structures easily and safely
-
seventy
Newtype sanitization and validation
-
nonasync
A set of utilities useful for building a non-blocking non-async APIs
-
escher
Self-referencial structs using the async/await transformation
-
swift-rs-hatter-fork
Call Swift from Rust with ease!
-
flow-control
Declarative macros for common flow-control use cases such as break, continue, and return
-
multiple_errors
Propagate multiple errors instead of just the first one
-
peeking-iter
An iterator adapter that allows infinitely-deep peeking
-
defaultdict
A hashmap implementation that mirrors the python defaultdict
-
axerrno
Generic error code representation
-
cantor
A general toolkit for working with types that have a small number of values
-
docpos
Compact-document items after defining them (fn, struct, enum) + document fn parameters with rustdoc (⑂roxygen)
-
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
-
zipped
recursively unzipping tuples, Options of tuples and Results of tuples
-
head-tail-iter
An iterator that repeatedly splits head & tail
-
open-vaf
A compiler frontend for VerilogA aimed predominently at compact modelling
-
defer-rs
Deferred execution Rust utilities
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
r-ex
Zero-bloat Rust core library extensions
-
ffd
Fast Function Dispatch: Improving the performance of Rust's dynamic function calls
-
failchain
Ergonomic companion library for failure
-
pubserve
generic observer trait
-
anony
Anonymous struct
-
string_error_wrap
providing a macro for an error type wrapping a String
-
benri
Convenient macros wrapping the standard library
-
standback
New standard library, old compiler
-
enum_pipeline
way to use enums to describe and execute ordered data pipelines
-
simplicio
Gets rid of the boilerplate in rust
-
cause
A generic [std::error::Error] implementation
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
roopert
object-oriented toolkit for Rust
-
objid
Generate a random object identifier
-
inout
Custom reference types for code generic over in-place and buffer-to-buffer modes of operation
-
uwuizer
Rust Macro to UwUize your text. UwU.
-
zhi_enum
derive macros to easily use enum
-
resplus
attaching messages to results
-
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
-
any-fn
Dynamically-typed functions to represent any functions in Rust
-
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
teloc
compile-time DI framework for Rust
-
shorten
A collection of convenience functions, macros and traits to shorten repetitive code
-
boost-rs
boosting your develop productivity on Rust
-
brain_flak_macro
Brain-Flak macro
-
shallowclone
Traits for working with copy-on-write types more efficiently
-
tupl
Perform generic operations on tuples
-
cgp-error-std
Context-generic programming error handlers implemented using
std::error::Error -
brazier
A mediator implementation in Rust, heavily inspired by the .NET MediatR package (https://github.com/jbogard/MediatR)
-
kust
Kotlin-like APIs for Rust
-
okk
approach to replacing the
Ok(()) -
lurk-ipld-macro
lurk-ipld macro
-
simple-life
async lifecycle trait and convenient macros
-
dec-number
Decimal Floating Point Arithmetic for Rust
-
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!,include!, orconcat_idents!) -
tryvial
Small crate for ok-wrapping and try blocks
-
kurtbuilds_user_backtrace
A very small library for smaller backtraces that only contain user relevant information
-
crashreport
Automatic GitHub crash reporting system for any Rust crate
-
sqnc
Traits and adaptors for sequences
-
curerr
easy error handling
-
holium-rs-sdk
Holium Rust SDK
-
enum_primitive
Macro to generate num::FromPrimitive instances for enum that works in Rust 1.0
-
derive_constructors
Deriving From, TryFrom and create new_with_*args* functions
-
facet-opaque
Type-erased pointer helpers for Facet types
-
ptrplus
Additional funtionality for pointer types
-
asar-snes
Rust bindings for Asar (https://github.com/RPGHacker/asar)
-
sylt-typechecker
Typechecker for programs in the Sylt programming language
-
devela_depend
Optional external dependencies for
devela -
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
common_macros
common macros like
hash_map!orhash_set!(WIP) -
unwrap_none
Implements the
unwrap_noneandexpect_nonemethods removed by https://github.com/rust-lang/rust/pull/83349 -
zkp-macros-decl
Procedural macros
-
isnt
Inverted versions of boolean-valued stdlib functions
-
rewrap
Result<Result<T, E>, F>->Result<T, F> -
bbtk
A collection of frequently used libraries that should be in stdlib
-
permeable
A permission-demand trait. Decouples the permission-demander from the permission / auth provider.
-
parametrizer
safe crate for parsing properly-formatted math strings representing parametric functions into Rust functions
-
audi
Generic listener abstraction
-
nonminmax
Primitives types which cannot be their minimum/maximum value
-
enum_macro
Useful macro for enum
-
setjmp
/ longjmp support
-
sensulator
sensor simulator, provides noisy readings of ideal measurements
-
commandspec
Rust macro to build std::process::Command objects with shell syntax. Uses macro_rules! and works on stable.
-
dbg_unreachable
Switch between unreachable! and unreachable_unchecked with a single macro
-
cubiomes-sys
Raw ff binding for the cubiomes library
-
wrapping-macro
wrapping macro
-
oc-hook-macros
Some convenient macros for hooking Objective-C functions
-
gesha-macros
Macors for Gesha proejct
-
libccp
Rust bindings for libccp, a library for implementing CCP-compatible datapaths
-
core-ext
Useful extensions to core::convert library
-
fold-license
Folding licenses from multiple dirs with
cargo/Cargo.toml andyarn/package.json -
impl_ops
Macros for easy operator overloading
-
accompany
with-like macro for Rust -
endian_trait
A trait for Endianness conversions that can be implemented on most types
-
ddd-rs
Domain-Driven Design (DDD) building blocks, for Rust applications
-
merge-rs
A small library that cuts down on the amount of code required to merge two arbitrary structs into a new struct
-
lifterr
A small set of adapters extending Rust's error-handling capabilities
-
tapir
Adding tapping functionality to rust
-
haz
A thin abstraction over polymorphic environments
-
int-to-c-enum
TryFromInt - A convenient derive macro for converting an integer to an enum
-
containerof
Macros and traits facilitating the use of intrusive structures in Rust
-
description
like Display, but 'static
-
id_sys
data structures which can be marked such that they only work with similarly marked integer data types
-
jsi
Write React Native JSI modules in Rust
-
efmt_core
Core library for efmt crate
-
serde_fs
[De]serializing data structures as files
-
color-core
Color shared definition
-
assert_unordered
A direct replacement for
assert_eqfor unordered collections -
string_from
A three-letter macro for String::from
-
close
Trait + smart pointer for manual object destruction
-
chunk_iter
Chunked iterator generic over any iterator
-
free-wrap
Provide a easy way to define NewType Wrapper
-
tlbf
Type level bitflags
-
unused
Allows for unused generic parameters that do not act like they are owned
-
oop
Object-Oriented Inheritence in Rust
-
globiter
Replace with description
-
intfloat
Fast and simple hashable float alternative using ints
-
ownref
Provide the smart pointer type that bundles the data with its owner
-
dyn-eq
Test equality between trait objects
-
rigz_error
Includes the definition of the RigzError enum
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
will_exit
work on program will exit
-
tlist
Type-level linked lists (of types) and type-level 'functions' to manipulate them. Because TList is implemented using GATs, usage is very ergonomic.
-
unroll_range
Repeats a block of code for each number in a specified range
-
async_fn_traits
Trait synonyms for “Fn[…]”-trait bounds returning futures
-
intercom
writing COM visible Rust components
-
discord_typed_interactions
suppose you're working with discord slash commands and you want statically typed request types
-
dev_bestia_url_utf8
url utf8 encode/decode
-
ghost-lite
custom PhantomData types
-
yansongda-utils
rust 中一些关于我自己的常用工具
-
g-str
una librería desarrollada en rust, que evita la duplicación de cadenas en tu codigo
-
sim_connect_rs
An easy to use, opinionated API for SimConnect
-
chandeliers-err
Internal error message generators for the Chandeliers project
-
precisej-printable-errno
Printable system call errors for nix
-
poolite
A lite threadpool library
-
sbse
skylar's simple errors
-
inherent
Make trait methods callable without the trait in scope
-
num-sign
enum Sign { Positive = 1, Negative = -1 }
-
radix-ecmascript
Convert floating-point types to string representation as defined in ECMAScript Language Specification Section 9.8.1
-
typestate-builder
Derive-macro-based generator that combines
TypestateandBuilderpatterns -
plugin-interface
Plugin interface definitions for the plugrs system
-
sod-mpsc
Service Oriented Design - Multi Producer Single Consumer
-
prae
that aims to provide a better way to define types that require validation
-
handlevec
Small abstraction over index-style iteration over a vector, with deletion, insertion, and other operations on the vector while iterating
-
freedesktop-file-parser
Freedesktop Desktop Entry Parser
-
doc-image-embed
Embed images in Rust documentation
-
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
phantasm
Small lib that helps with variance
-
try-lazy-init
Fallible lazy initialization
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
iri-string
IRI as string types
-
into-static
Upgrading to static lifetimes
-
selfref
Semi-pain-free self-referential pinned types
-
big_s
Rust’s missing
Stringliteral -
cbsk_mut_data
ref mut tool
-
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
tracel
SDK
-
higher-kinded-types
"Generic generics" / higher-kinded APIs in stable Rust
-
funlib
Rust functional library
-
error-ex
designed for those who desire clear, explicit, and easy-to-use error creation and handling
-
partialdebug
Derive Debug partially
-
aorist_primitives
Primitive macros for the aorist project
-
bit
helpers to manipulate bits and bit ranges
-
codespan-derive
derive(IntoDiagnostic) for easy codespan integration
-
fluid-macro
Write long method chains as a series of steps instead, and more!
-
postfix-macros
Postfix macros on stable Rust, today
-
wurm
Non-fatal, strongly typed errors
-
iterator-ext
An extension to Rust's Iterator
-
rusty-hkt
Higher-kinded types for Rust
-
repeated
Allows you to repeat a block of code a number of times
-
thin-boxed-slice
ThinBoxedSlicestores the size of the slice before the content of the slice, so thatsize_of::<ThinBoxedSlice>is only the size of a pointer -
anyhow-std
Wrap std APIs with anyhow error context
-
u16cstr
A macro for creating c-style u16 wide strings at compile time
-
ara_reporting
A Reporting library for for Ara Programming Language 📃
-
portaldi-core
Core functionalities for portaldi
-
vec2
-
unwind_safe
Readable unwind-safe code thanks to a try-finally-looking builder pattern
-
ratelimit_rs
The ratelimit package provides an efficient token bucket implementation
-
namewise-common
Derived trivial name-wise conversions for Rust types
-
chain_from_last
Iterator adaptor for chaining from last item
-
replace_err
Adds a
replace_errmethod toResultwhich throws away the current error and replaces it -
taker
Option-like taking for everyting with a default value
-
string-builder
string builder type
-
diffuser-edit
Edit diffuser models without GPU and Python
-
applying
Apply functions in method-position
-
type-variance
Marker traits for subtype variance
-
no-std-thiserror
thiserror but no_std compatible
-
er
error
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
box-dyn
Macro to derive the implementation of Trait for Box<T: Trait>
-
init_with
Helper trait to initilize an array with a function
-
birds
Combinators using Rust macros
-
state_maschine
A State Machine Framework written in Rust
-
thiserror_lite
Almost drop-in replacement for thiserror, implemented using 100% declarative macros
-
peekable-fwd-bwd
Iterator Peekable with multi-forward-peek and multi-backward-peek
-
eager
macro expansion
-
smartcow
a cow for smartstrings
-
classes
Dependency-free macro that simplifies the process of building class strings for DOM elements
-
pnet_macros_support_bandwhich_fork
Support library for libpnet_macros
-
audiotags-macro
macros used during the development of audiotags
-
s-string
s!() macro for quick String::from()
-
err-per-field
A more fine-grained control over field-level error handling
-
ah-macro
工具宏
-
valid
Validate custom types by composing primitive validation functions. Use one common API for validating all kind of business rules including aspects of the application state. One common error type for all…
-
rvs-c-api
C-API for Rvs - A library for defining and evaluating random variables using a simple DSL
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the *relative* difference
-
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) -
fallible-option
Fallible is an Option with inverted Try-semantics
-
enum-rotate
Rotate and iterate your enums
-
smallint
optimized arbitrary precision integers
-
bytify
macro that can write given const-expr values into a continuous byte array
-
ov
a collection of traits that allow you to chain off of anything
-
phantom-enum
macro library for creating phantom enums
-
redox_simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
typed_macros
Adds typing to your macro's arguments, making it a lot less of a pain to deal with them
-
tuplify
Generic hlist/tuple library
-
trait-union
Stack-allocated trait objects
-
ctjs
compile time javascript as a rust proc macro
-
spanned_error_message
Pretty error messages with spans outside of proc macros
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
errling
A collection of intrinsically useful errors
-
scanfmt
easy to use macro for parsing a string
-
todo_using
A super small crate only exporting a single macro to "use" parameters
-
macro_clap
Command-line argument parsing to its simplest
-
ftkit
A small set of utilities for newcomers learning Rust
-
rust-enum-derive
(and program) for generating rust enums and associated traits from text files
-
wrappr
A libary for some useful wrapping traits
-
typesets
Enables generating subtypes and supertypes of a given type via derive macros
-
kinded
Generate enums with same variants, but without data
-
ngram_iter
An iterator of arbitrary N-grams of rust Copy types
-
borked
convienient error handling library for rust
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
ex3-node-error
Underlying error types used over ex3 crates
-
axmac
Readable indexing macros for 1-4 dimensional data structures
-
thisslime
Error utilities for slimebot
-
check-ends-macro
A couple of macros to simulate match with starts and ends of a string
-
crete
Ergonomic, thread-safe & flexible state management
-
zachs18-stdx
My commonly used extensions to std APIs
-
tailwag_macro_inline
The logic for A collection of macros to support the tailwag crate
-
staticbitset
A container like std::collections::BitSet but static storage + Copy trait
-
chandeliers-sem
Semantics of Candle, a shallow embedding of Lustre in Rust
-
splop
Helper functions to determine the first/last repetition of something
-
valued
Describe your data in terms of basic data structures. Get serialization and other facilities for free
-
nias
closure generator library
-
tiny-ordered-float
Tiny version of OrderedFloat
-
wadm-types
Types and validators for the wadm API
-
concat_strs
Macro for quickly building a String from components
-
beard
Handy macro to generate formatted text in rust
-
bitrange
plugin to map bits in integer values to fields
-
circomspect-parser
Support crate for the Circomspect static analyzer
-
sha2-derive
exporting a derivable
Hashabletrait that works withsha2 -
kommons_macros
a set of macros with utils
-
liftor
Functors for Rust lifetimes
-
read_buffer
ReadBuffer, a wrapper to safely read into a buffer from a Read
-
assertive
Collection of assertions
-
propositional_logic
generate truth tables for compound propositions
-
simple-undo
Easy to use undo-redo library
-
r3bl_redux
Redux library built using Tokio, concurrent & parallel
-
enum-extract-error
A companion crate for
enum-extractthat exports an error type -
aranya-buggy
A less panicky replacement for unreachable!() and unwrap
-
esync
This package contains some useful synchronization primitives
-
transient
Reimplementation of
std::any::Anywith support for non-'statictypes -
rust_study0
First study project of RUST
-
signrel
Trait expressing relationship between integers of different signedness
-
rexpr
Rust Json Object access Runtime
-
cron_macro
cron macro
-
json_extract
This macro reduces boilerplate when using serde_json::Value variants when trying to get into a nested property
-
letr
The macro for the lazy
-
core_float
based on the Rust Core Library and aims to provide an identical set of APIs for f32 and f64 floating-point types
-
dmx-struct
A struct that holds a DMX Addresse with parsing capabilities
-
german-str
small-string optimized string type with fast comparisons
-
arc_macro
A macro wrapper around Arc::new() for convenience
-
dbg_mac
Handy debug only macros
-
print_typewriter
easy way to print strings on character at a time
-
derive
providing a minimal example of a derivable trait (via companion crate derive-derive) for testing and illustration
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
dynerr
Macros for dynamic error handling
-
swamp-vm-types
Low-level types for memory layout, addresses, and instructions used by the Swamp Virtual Machine (VM)
-
convertnumber
illustrate number conversion from float to integer, I was trying out
implandtraitsand thought it was cool to build something from it -
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
-
pattern_code
Given a path patterm matched source code
-
combine_traits
A Macro to create Traits wich are just a combination of existing ones
-
materially
A macro for material implication
-
anythingy
dynamic typing
-
stated-scope-guard
A more flexible RAII pattern for stated resouce management
-
derive_variants
derives an additional enum from a nested enum that contains only variants and no nested fields
-
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…
-
look_inside
Look inside structs, enums, and unions!
-
xx
A collection of useful Rust macros and small functions
-
helper
provided some useful proc macros for Rust
-
size-trait
Traits for restricting the size of type parameters
-
c8str
String types that are both utf-8 and null terminated
-
iter_accumulate
An iterator adaptor that accumulates the elements and yields the current accumulated value for each iteration
-
peak-result
trait that extends the standard Result enum to allow you to run some code in case of error or success
-
actix-web-error
Derive ResponseError for your errors
-
xstd
eXtended STandarD library
-
fieldfilter
trait that lets you filter stuff!
-
lazy_bastard
A helpfull macro because writeing a seperate Default function is too much effort
-
kathy
Const-evaluated swift-style keypaths
-
chomp
A fast monadic-style parser combinator designed to work on stable Rust
-
esvc-traits
Traits for ESVC
-
oxidd-core
Core traits and types of the OxiDD decision diagram framework
-
microparsec
parser combinator crate for Rust
-
enum_ext
procedural macro that enhances enums with additional methods and conversions
-
typestring
String constants lifted into types. This is a stopgap until const generics support strings.
-
moosicbox_task
MoosicBox task utilities package
-
md_match
A macro to support md-match syntax
-
for-loop-iterator
Iterators like traditional for loops
-
collected
Summation, product, maximum and more special collectors for Rust iterators
-
aranya-trouble
A wrapper to implement the Error trait
-
sync_stream
Aggregate multiple streams by polling stream items in order, keeping the consumption of multiple streams in sync
-
scope-guard
RAII scope guard
-
unsafe-any
Traits and implementations for unchecked downcasting
-
arcerror
thin wrappers around Arc<T> and Rc<T> where T: Error. Impls Error for both of these types. No unsafe, no dependencies.
-
namable_closures
types and macros to create namable closure types
-
conventus
Traits for assembling and disassembling items
-
cstr-argument
A trait for converting function arguments to null terminated strings
-
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.
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
pyo3_special_method_derive_lib
Automatically derive Python dunder methods for your Rust code
-
unwind-unsafe
Zero-sized marker types which do not implement UnwindSafe or RefUnwindSafe
-
noders
NodeJS-like event loop environment for Rust
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
persian_str_rs
functions for working with Persian strings in Rust
-
boundnum
Bounded number type
-
rustils
Utilities for rust
-
type-registry
Static type registration
-
atomic_refcell
Threadsafe RefCell
-
lazy_link
proc macro for dynamic runtime lookup of external functions, supporting custom resolvers, caching and no_std environments
-
name-it
Give a name to async fn return types
-
diva
Opinionated convenience wrappers for
std::process::Commandand friends -
rusty_utils
package that provides utility functions inspired by or ported from other programming languages
-
linq
Language Integrated Query in Rust
-
crossdylib
Cross-platform shared state across shared libraries/modules
-
for_each_repeat
Iterator::for_eachthat can repeat current iteration -
easy-ffi-wrapper
Types and utilities to enable writing C FFI wrappers easily
-
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
ename
get name of enum variant by enum value
-
dynstack
A stack for trait objects that minimizes allocations
-
transmute_guard
Transmute between types that have been marked as safe by the marker type
-
match_to_str
match pattern to str
-
lock-free-freelist
A fast lock free limited length free list for multiple producer and consumer
-
extrust
intended as an extension of the standard library
-
infix_macro
macro that generates the neccesary boilerplate to use "*operator*" infix functions
-
from_variant
Automatically derive From impls for enums
-
retry-policy
Retry Policy
-
crosstrait
Cast from
dyn Anyto other trait objects, with no_std, no alloc support -
dto_derive
Derive for automatic mapping DTOs to Entities and vice versa
-
enum-code
derive(Code) simplifies error handling by providing an easy-to-use enumeration of error codes
-
enum-display
A macro to derive Display for enums
-
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
rubber_duck
Enables building functions that can be called with named arg syntax
-
krenz
collection of my frequently used functions and macros
-
flat_vec
macro to flatten nested Vecs. Particularly useful when you want to write a rules of egg which contains rules both => and <=>.
-
base1112031
way to represent numbers using all Unicode characters except ASCII control characters
-
rstgen
Even simpler code generation for Rust
-
urlqstring
A URL query string for rust
-
async-convert
Async TryFrom/TryInto traits
-
rusty-typesh
A flexible type pattern matching system for Rust
-
bitmatch
A macro to allow matching, binding, and packing the individual bits of integers
-
string-eyre
Convenience traits for dealing with errors that don't want to eyre
-
pending_unwind
converting unwindings into
pending -
veccell
variant of Vec with interior mutability
-
hexga_tools
miscellaneous stuff, when somethings will be too big it will be on a separate crate
-
crates-io-macro-crate
An example macros-by-example crate for demonstrating a regression
-
curmacro
usefull macros like struct getters and setters creation macros
-
dom_renderer
rendering html (or other DOMs) strings
-
peg-runtime
Runtime support for rust-peg grammars. To use rust-peg, see the
pegcrate. -
label
functions and iterate over them
-
fastperm
A dead-simple, extreme fast permission flag system for Rust with no dependencies
-
retryable
Automatic function retry macro
-
pin-utils
pinning
-
kaboom
Intuitive library for Next-Gen application exiting
-
thin-slice
An owned slice that packs the slice storage into a single word when possible
-
io-arrays
Random-access I/O
-
slazy
small, no-std, macro-based lazy static library for Rust
-
fluent_builder
builder API
-
phantomdrop
Go-like deferring of function calls
-
psl-types
Common types for the public suffix implementation crates
-
messages
Runtime-agnostic actor library
-
srce
Self-Ref Cell Environments
-
inline-const
Inline consts implemented as a macro
-
traitreg
Create a registry of implementations of a trait
-
puruspe
Pure Rust Special function library
-
fallible_map
fallible mapping over
Optionand iterators using functions that can returnResults -
spore-types
Spore Protocol types serilization/deserilize utilities (based on molecule)
-
noticeable
lazy observables
-
ctrl_macros
Control flow macros for Option and Result
-
repr-trait
Traits to represent Rust reprs
-
const_power_of_two
working with constant generics that are powers of two
-
ferrite-session
Session Types DSL for Rust
-
trait_enum
Easy enum wrapper that implements all traits that the wrapped objects implement
-
libmw
constructing a pipeline of middleware functions
-
enum_variant_macros
Macros to generate From & TryFrom for enums
-
bitty_write_macro
A drop-in
write!replacement that optimizes non-formatting writes for code size -
edisp
Dispatch-on-collect for Rust enums
-
tracing-assert-macros
A macro for capturing trace logs
-
discard-while
Get the first non-matching element, and the amount of discarded elements
-
citadel
-
try_buf
no-panic API for bytes::Buf
-
type-census
Track the number of extant instances of your types
-
enum_to_enum
Derives possibly effectful conversions between enums
-
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
rerast_macros
Macros for use in Rerast rules
-
ndless-static-vars
storing static, program-wide parameters for Ndless
-
algebloat_macros
RustAlgebloat utility macros
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
vec3
-
big_mac
A metamacro toolkit for writing complex macros
-
error-chain-mini
error-chain for minimalist
-
adventurous
A companion crate for solving Advent of Code puzzles
-
try_utils
The try! macro descends into an enum variant. It's more flexible than ? and unwrap(), and it works with your enum, too!
-
xkcd_unreachable
macro xkcd_unreachable!() inspired by https://xkcd.com/2200/
-
rustructure
Run-time introspection on compile-time flagged structures
-
mcurry
Macros for creating curried functions
-
common_regex_rs
Set of common regex for Rust
-
loop-let
An immutable loop structure that can be used as an expression
-
stuff
Stuffing things into pointers
-
qol
Quality Of Life functions and macros
-
raise
yeet!all the things -
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.
-
closure_attr
An attribute macro to simplify closure captures
-
bestbefore
A procedural macro for marking code with expiration dates
-
io-ensure
Prototype of the
std::io::ensurefamily of macros -
filters
Build filters/predicates with the builder pattern
-
rollercoaster
Extra iterators for grouping, sorting, arithmetic, and more
-
iterator-endiate
Extension method for (exact size) iterators which yields tuple containing whether item is last in iterator
-
love_rust
so I don't have to re-write the same thing everytime
-
hazmat
A collection of helpers for working with hazardous materials in Rust crates
-
fatal-error
Differentiate errors and fatal errors
-
tensor-macros
A compile time optimised tensor library
-
stable-step
Step for stable rust
-
trait-set
Support for trait alias feature on stable Rust
-
checked_clamp
Clamp alternative that returns a result instead of panicking
-
substrs
substring functionality for the str type in Rust
-
resultit
Iterator adapters for iterators over results
-
foreign-types-shared
An internal crate used by foreign-types
-
tracers-macros
Macros which generate tracers and the code that fires the tracers. See the 'tracers' crate for further instructions
-
hold-macro
extended todo!() macro that can suppress unused value warnings
-
rustkell
haskell like functions in rust
-
breakable-block
A shim library for a stable implementation of what is proposed in RFC 2046
-
loop_chain
Macro for writing nested Loop expressions
-
destruct
structs and enums for simpler combinator implementation
-
source-location
Container struct for source location data + construction macro
-
mini-macro-magic
Export tokens to other modules and crates. Now with 100% less proc macros!
-
stackpin
data that should be pinned to the stack at the point of declaration
-
twinsies
Smart pointer providing 2-way joint ownership of an object
-
beetle-nonzero
Combines the std
NonZerostructs into one struct -
len-trait
Len trait for collectons
-
uzero
UZero
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
bail_macros
Bail macros for Options, Results and more
-
jget
Rust tools
-
politeness-macro
Isn't it time to be a bit nicer to rustc?
-
impl-converter-helper
declarative macro library to help you implement the
FromorTryFromtrait for your type -
splitbits
Concise bit field extraction
-
cell-project
Safe interface for cell projection
-
derive_destructure2_examples
Examples for crate derive_destructure2
-
into_index
Helper traits allowing indexing into vectors and similar types by other types than
usize -
binreader-internal-macros
Internal macros used by binreader
-
zip_clone
Zip an iterator to a repeately cloned object
-
is_empty
Easily check if the struct is empty
-
rhizomedb
RhizomeDB
-
arbintrary
Proof of concept for arbitrary integer sizes using generic const
-
cart_prod
Cartesian product of iterators
-
zen-parser
Zen expression language parser
-
asserteq_pretty
An assert_eq macro that prints more helpful diffs on mismatch
-
rust_bridge
The rust_bridge
-
to_any
Auto derive ToAny trait for any structure
-
dyn-any
An Any trait that works for arbitrary lifetimes
-
bytebuff
usefull derive macro for serializing data to send ower network
-
pfn
Provide fn_trait’s
call,call_mut, andcall_onceon Stable Rust -
arrays
Construct an array from an iterator
-
include_glob
embed files into an executable via glob patterns
-
edres_core
Internals for the edres crate
-
finte
convert between integer and Rust enum
-
grit-junk-drawer
Collection of small utilities, types, traits, helpers, etc
-
cmp_macro
This macro allows you to write a summary comparison, just like in Python
-
validus
A string validation library
-
unwrap_or_log
adding two functions to all std::resut::Result to log errors using the log crate
-
dependent_ghost
Matt Noonan's 'Ghosts of Departed Proofs'
-
uri-routes
URI building library
-
cronjob
scheduling your methods
-
traverse
Proof-of-concept trait for internal iterators called traversals
-
ordered_iter
Ordered iterators
-
checked-float
making invariant-enforcing floating point wrappers
-
i-codegen-code
Common tools supporting the
derive-codegencrate -
easy_switch
A macro for traditional C-style switch statements
-
vm6502
A 6502 virtual machine backend
-
magic_static
Global singletons initialized at program start, an alternative to lazy initialization
-
cp_tricks
Tricks for competitive programming. Do not use this crate.
-
bail-out
Macros to help keep code clean for validations and error handling
-
include-flate-codegen-exports
Macro codegen for the include-flate crate
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
en
The easiest numeric traits!
-
token-ref-cell
Interior mutability cell using an external token to synchronize accesses
-
comparator
A Java-like Comparator type
-
goodnight
executing code upon exit
-
wrapping_macros
A macro for wrapping arithmetic
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
itsuki
macro that defines a simple zero-based sequential enum
-
menv
Pulling in arguments from environment variables
-
rich-phantoms
Phantom types with control over variance and sync/sync inheritance
-
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
-
context-rs
Pass values down the async call stack, with no_std and no_alloc support
-
consume_on_drop
A zero-cost abstraction that allows Drop::drop to consume self by value
-
shkeleton
Skeleton rust project
-
atruct
macros for anonymous structs in Rust
-
fieldx_plus
Design patterns built on top of fieldx crate
-
log_err
Log error messages from Unwrap and Expect with log crate
-
escaped-delimiter
Iterator of delimited slices with escape characters
-
tiny_fail
Fail type
-
bufstream
Buffered I/O for streams where each read/write half is separately buffered
-
arcmutex
A convenience library for working with
Arc<Mutex<T>>s -
input-macro
No-nonsense input!(...) macro for Rust
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
emmylua_code_analysis
analyzing lua code
-
very-bad-error-propagation
Using the panic system to implement error propagation (please don't actually use this)
-
std_prelude
prelude that the rust stdlib should have always had
-
offer-cell
that defines a pattern for providing a reference to stored data, and optionally transferring ownership of that data
-
boh
A holder of many things
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
advance-iter
A small crate to help with "stepping through" iterators
-
shared-expiry-get
concurrent async get with expiration for Rust
-
actify
An intutive actor model with minimal boilerplate
-
enum-derive-2018
macros for deriving additional functionality for enums
-
fractran_macros
A compiler plugin that converts Fractran code into Rust at compile time, letting your Fractran programs be optimised by LLVM to super-fast native code
-
typeon
metaprogramming
-
futures-macro-await-preview
Definition of the
await!macro for thefuturescrate -
gbparser
providing a representation of a GenBank sequence records file, a reader for such files implementing Iterator
-
padded-iterator
An iterator that can be padded to a specified length
-
advent_of_code_macro
An test generating macro for advent of code
-
truthy
Check if a value is "truthy"
-
custom_enum_traits
A set of traits for dealing with enums
-
macro-utils
Some macros to make code writing more elegant and funny
-
derive_struct_fields
way to work with struct fields programmatically
-
dry-mods
Macros to make your module management DRY
-
fat_type
A type which permits thin references to arrays and dynamic types
-
targets
Some helpers to get you started with declarative programming in Rust
-
fullypeek
Peek forward in an iterator as far as you'd like, memory allowing!
-
hexga_array
that impl trait / new functions for array
-
let_clone
Declarative macro to clone multiple values at once
-
binjs_es6
ES6 component of the Binary AST reference implementation
-
ataraxy
Discord slash commands framework for Serenity
-
iter2
Iterator
chaining,cmping and more as free functions taking twoIntoIterators -
win-events
A poor attempt to implement WaitForMultipleObjects and the ManualReset, AutoReset and Pulse types
-
iter_from_fn
Create iterator from repeatedly aplying a function that takes no parameters
-
entrance
A command line argument parser library which provides type assisted tools
-
giveup
User-geared error messages and hints
-
xdi
Rust di containers system
-
inline_default
Macro for inline Default implementation
-
list_comprehension
A macro for Haskell-like list comprehensions in Rust
-
anyhow-loc
anyhow with location
-
nb-from-env
A convenient way to construct structrual configuration from environment variables
-
byteflags
A macro to generate bitflag-like structures with u8 flag values
-
borrow_channel
A channel for borrows
-
source-chain
Formats StdError with it's source chain
-
infinite-iterator
A trait for iterators that never end
-
extension-eyre
Re-export of color-eyre that introduces Extensions (type-map) to eyre::Report
-
generator_extensions
Basic extensions to Generator types to bring parity with Iterators
-
tartan-bitfield
Define structures with accessors for particular bits or bit ranges
-
bp3d-util
OS independant Rust language utilities
-
sh
Macro for easily running commands
-
iex
Idiomatic exceptions
-
picostring
A stack allocated string that requires no extra space to store length
-
utfx
-
mini-intern
A small string interner for interning strings. The strings don't have to be small.
-
steloc
compile-time DI framework for Rust
-
awint_internals
Internal utilities for the
awintsystem of crates -
invade
reflect on Rust types and generate code
-
lambdas
defining domain specific languages in a polymorphic lambda calculus
-
size_hint
A very simple library to provide a size_hint for an iterator which does not provide it's own
-
bittorrent-primitives
collections of basic types for BitTorrent projects
-
futwaiter
The container of Future's that has the ability to complete them all at once
-
cardseed
Pseudo-random numbers derived from playing cards using PBKDF2
-
easy_error_core
Core error type for easy_error
-
match_any
declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
lisbeth-error
Span handling, error generation and reporting crate
-
libpy
imports functions from the python standard library
-
sod-bus
Service Oriented Design - Single Producer Multi Consumer
-
abort_on_panic
Intercept panic! from unsafe locations and abort the process
-
comp_input
Input library for competitive programming
-
number-types
A typenum clone I made for fun with some positive changes but much fewer features
-
pi_print_any
print any value without trait bounds using specialization (Rust nightly channel)
-
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
rust_hawktracer_normal_macro
helper crate for hawktracer profiling library
-
raw_struct
procedural macro for easily declaring C-style structs that reference local or external memory, based on your memory implementation. It generates appropiate getter methods for easy access.
-
enum-tryfrom
Error types and traits for use with enum-tryfrom-derive
-
iter-n
functions returning impl Iterator to return one of several distinct types
-
simple_scan
Iterator extensions for simple scan operation
-
nested-ref
References to data contained in one or more nested RefCells
-
trait-alias-macro
Trait Bound Alias using Macros
-
traitobject
Unsafe helpers for working with raw trait objects
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
byte-order
reading and writing numbers in big-endian and little-endian
-
switch_statement
switch statement macro
-
superfusion
A general purpose project merger library
-
cereal
data serialisation library
-
rewind
Strong exception guarentee support types
-
const_typed_builder
Compile-time type-checked builder derive using const generics
-
random-trait
random trait meant to produce random generic types
-
spans
Split an iterator into contiguous spans
-
tupleops
work with tuples
-
unsafe-any-ors
Traits and implementations for unchecked downcasting
-
pennereq
Port of the Penner easing equations to rust
-
easyerr
easier creation and transformation of error types
-
first_crate
dealing with vectors calculations more convenient
-
rmin
A minimal Rust lib for writting R extensions
-
global_placeholders
magic placeholders
-
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… -
zkp-criterion-utils
Criterion helpers to benchmark over size and number of processors
-
zerror_core
A complete implementation of the zerror:Z trait
-
new_flattened
Macro to flatten nested calls of
news -
utils-results
The easiest and most intuitive error handling solution
-
maybe_null
A pointer type for handling potentially null values without accidental dereference
-
readonly
Struct fields that are made read-only accessible to other modules
-
anxious
panic-free dialect of Rust
-
rust-fp-categories
A Functional Programming Library in Rust, Category
-
anyhow_ext
Extension of anynow
-
quantified
Specify the universe: None, Some, Excluding, and All
-
detach
helper type for being able to detach/reatach a member item
-
transitive_from
Helper macros for creating hierarchies of transitive
Fromimplementations -
safemem
Safe wrappers for memory-accessing functions, like
std::ptr::copy() -
adrop
fast dedicated thread drop
-
await_macros
Macros that expand to
(expr).await -
dev_bestia_string_utils
string manipulation
-
slip
A hassle-free utility to encrypt error handling strings in your public binaries to protect your business logic
-
eliza_error
“Times are bad. Children no longer obey their parents, and everyone is writing an error handling library.” — Cicero
-
rovv
provide the anonymous row type (poor-man's row polymorphism) in rust
-
embed_it_utils
The utils for [
embed_it] -
iota-rs
macro for other Go refuges who miss const blocks and iota
-
takeable-option
A small wrapper around option
-
set_slice
A macro for assigning values to slices
-
error_union
simplify error handling in Rust
-
ser_raw
fast serializer
-
error_log
struct-based Error-Handling
-
scoped-sleep
RAII sleep
-
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
singleton-trait
Singleton trait for types with unique values and Erased type for zero-sized ownership proofs
-
prost-uuid
ProstUuid new-type wrapper around uuid::Uuid with prost::Message implemented for it
-
oi
📍 Location-annotated io::Errors
-
zkp-error-utils
Assertion like macros for returning
Result::Err -
with-api
macro for shrinking scope
-
closure_example
A short description of my package
-
okey
Everything is Result::Ok
-
sentry-error-chain
Sentry integration that allows capturing error-chain errors
-
fallback-if
Fall back to an alternative given some predicate
-
qed
Compile-time assertions
-
lvy-lib
Common code used by my projects
-
components-arena-traits
Does not intend for direct use
-
rustcomp
Adds vector, map, set, and iterator comprehensions to Rust
-
re_types_core
The core traits and types that power Rerun's data model
-
sylt-machine
VM for running programs in the Sylt programming language
-
doxed
making Rust doc strings available at runtime
-
mdo
Monadic do notation for rust using macro and duck typing
-
the-newtype
The Newtype trait
-
static_assert_macro
so-called
static_assert -
qwutils
some utilities
-
extract-variant
Destructure expressions into, and return assignments from, a single pattern
-
once
assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
kaguya_rs
Functional Programming tools and ADTs
-
chalk-ir
Chalk's internal representation of types, goals, and clauses
-
slice-copy
Go style copying for slices
-
topdown-rs
A top-down parsing library
-
multindex
Index slices with multiple const indices/ranges
-
option_into_controlflow
Option into ControlFlow conversion
-
chn
Iterator chain-building macro
-
modular
arithmetic in rust
-
partial-borrow
Partially borrow a struct
-
warrant
A Swift-guard-like macro for Rust
-
fast_delegate
delegate struct easy
-
read-byte-slice
An iterator over chunks of bytes as slices from an underlying reader
-
kind-derive
Derive generator the kind compiler
-
lens-rs
lens implemented in rust
-
rustitude-core
create and operate models for particle physics amplitude analyses
-
select_indices
Iterators for taking multiple shared/exclusive references from a slice
-
is_send_sync
Macro to tell if a type is Send/Sync
-
visit_diff
Efficiently finding differences between data structures
-
bevy_cell
Attach Bevy's Handles/Entities statically to Types
-
statenum
enabling enums in state-pattern logic
-
rls-span
Types for identifying code spans/ranges
-
partially
Partial trait, and an optional macro to mirror a struct, wrapping each field in an Option
-
azucar
syntax sugar
-
cismute
Safely transmute type to itself in generic contexts
-
spawn_interval
Call a subroutine at a constant time interval
-
stringy
A tiny Rust crate for generating byte-sized enums that represent a fixed, ordered set of &str data
-
cgp-sync
Async-generic primitives to support both sync/async in context-generic programming
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
static_str_ops
A package allows using static strings with non-trivial operations, e.g.,
concat!,format!,call_once, and more -
cex
Checked exception simulation
-
string_mac
A lazy man's String macro
-
macro-while-mut
Macro that allows create while-cycle with mutable condition state
-
roxy_core
transforming a readable input
-
split-optional
It split from a source
strtoOption<&'a str>per an element -
fstrings-rust
Python3 fstring interpolation in Rust
-
monomo
Explicit trait monomorphization
-
scope-functions
Kotlin-inspired scope functions for use in almost any situation
-
transaction
abstraction library (a.k.a. transaction monad)
-
index-fixed
convert slices into arrays using indexes ([T] -> [T;N])
-
bool-mappings
Useful extensions to convert
boolto other Rust types -
std-io-peek
Peek trait
-
vesta
Extensible pattern matching
-
substrace_utils
subcrate for substrace
-
iter_peek_end
current element the last one of a peekable iterator ? (
is_last()andis_not_last()) -
aggregate
attributes of structs for runtime
-
try-drop
Batteries included error handling mechanisms for drops which can fail
-
interior_mutability_pointer
A wrapper around
Rc<RefCell<T>>allowing immediate access to inner methods -
phtm
Re-exports for common uses of
PhantomData -
ambient-authority
Ambient Authority
-
nanoval
A nan-tagged value for representing f64, i32, u32, booleans, null and arbitrary pointers
-
rsb_derive
An opinionated macro implementation for Rust struct builder pattern with compile-time validation
-
progress-token
tracking progress of long-running tasks
-
hex-serde-util
A helper crate for manipulating hex strings with serde
-
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
-
thread-id
Get a unique thread ID
-
proclock
cross-process locking API
-
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:…
-
strflags
A string-enum and string-flags with fixed variants that can also accept arbitrary data
-
ironplc-dsl
Domain-specific language objects for IEC 61131 language elements
-
kwarg_macros
Keyword argument plugin
-
apply_attr
A syntax extension providing higher-order attributes to Rust
-
self-reference
Helper
-
negative
impls in stable Rust
-
remit
Rust generators implemented through async/await syntax
-
join_to_string
Join a list of items to string/buffer
-
gamo
A Range like struct for user defined types
-
stringx
Traits for often used functionality when generating or modifying strings
-
tagname
get the name of a variant in your enum as a string
-
tylar
Type-Level Arithmetic in Rust
-
mods
Simpler module declaration
-
ouroboros_examples
Examples for the ouroboros crate
-
filecmp
comparing files and directories, the rust implementation for CPython filecmp module
-
easy-plugin
A compiler plugin that makes it easier to write compiler plugins
-
retry_durations
generates a duration iterator for [retry] crates
-
fix_me
A very simple macro that lets you write temporary code that WILL NOT build in release mode
-
lazy_transducer
Lazy, parallel, indexable, generic data iterators
-
dyngo
Type-safe dynamic (type-erased) generic outparams
-
phantom_newtype
Lightweight newtypes without macros
-
partial-default
PartialDefault, a trait similar to Default but with fewer guarantees
-
extracterr
helper type and traits for passing context through dyn Error trait objects
-
xylem
Building context-sensitive type conversion
-
kappendlist
Append to a growable list in O(1) without needing &mut
-
abi_stable_shared
detail of abi_stable
-
nopanick
No panic library for add, sub, mul, div operators in Rust
-
errer
Flexible error management for Rust. An middle-ground between failure and SNAFU
-
bumpalo
A fast bump allocation arena for Rust
-
proc_use
Semi-dynamic mod and use
-
usize_cast
Compile time checked cast from and to
usize/isize -
homm5-types
contains data stuctures useful for Homm5 mods development
-
kind-pass
A lot of compiler passes for the kind compiler
-
safe_unwrap
allows unwrapping and annotating that the unwrap will never fail. Does not require
std. -
take_mut
Take a T from a &mut T temporarily
-
enum-to-types
Macro for generating pseudo-enums for type-level programming
-
yui
An attribute reader generator for Rust
-
noneifempty
Convert T to None if empty
-
swahili-dsl
A Swahili-based DSL made for educational purposes
-
call-once
A type that can only be called sucessfully once
-
babygiant-alt-bn128
implementing a multi-threaded version of the baby-step giant-step algorithm on the Baby Jubjub curve (it is the curve whose base field is the scalar field of alt-bn-128 aka bn254) to decrypt u40 integers…
-
zonbi
Type-Erase tools for non-
'statictypes -
surprise-me
Derive macro to generate random type instances
-
fuzzypath
Quick & dirty fuzzy path comparison
-
error_hook
error hook
-
separable
trait for enums
-
cor_iter
Correlate of two iterators
-
pretty-panic
nicer panic messages
-
unwrap-enum
generate methods to access enum variants
-
lifted
Higher-kinded types in Rust
-
transcendent
-
jsonerr
macro and builder
-
zkp-logging-allocator
Wrapper around the system allocator that logs large allocations
-
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…
-
vercomp
comparing versions
-
bogdan_hello_macro
adds the method hello_macro that generates a greeting based on the name of the struct
-
levitate
Just works solution to numbers, mainly aimed at floats and mathematical use cases
-
cargo-manifest
Helper crate to parse and manipulate manifests -
Cargo.tomlfiles -
on_drop
on drop
-
brain_rust
A BF transpiler to rust written as a rust declarative macro
-
enum-tags-traits
Traits for enum-tags crate
-
roopert_macro_common
object-oriented toolkit for Rust (common data)
-
vk_method
Standart of VK Method
-
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… -
extensor
the main extensor crate for building arbitrary valent tensors and more
-
thisctx
Easily create error with contexts
-
hashed-type-def-core
hash based type identifier: hash code is computed on the basis of type definition
-
py-comp
A macro implementing a Python-like generator expression
-
flagged
Bitflag-based warning type
-
fmttools
Tools for modifying text without allocating any intermediate buffers or unsafe code
-
yauuid
generate and parse UUIDs
-
ps-util
aims to provide generally helpful utility functions and traits
-
min-specialization
Experimental implementation of specialization
-
try-ref
AsRef/AsMut version of TryFrom
-
snoot
The best s-expression parser this side of the Mississippi!
-
ternop
A tiny macro that implements a ternary operator for Rust
-
event-observer
observer pattern by rust
-
step-count
Count items of an iterator with any Step type
-
always_equal
A wrapper for types that can't implement Eq
-
pure_decimal
A decimal type with no NaN and Infinity
-
frust
Functional Programming in Rust
-
rustato-macros
Macros for the Rustato library
-
derive-ctor
Adds
#[derive(ctor)]which allows for the auto-generation of struct, enum, and union constructors -
ident-mash
Mash idents together inside macro_rules!
-
rstring-builder
String builder type
-
anyint
traits and structs for working with integers of any bit size
-
quick-error2
A macro which makes error types pleasant to write
-
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
-
mudra
Currencies as distinct structs
-
conflagrate
A framework for building applications from control flow graphs
-
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!
-
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
-
more_collection_macros
Adds new macros to rust for creating collections
-
hatch_result
A result-like struct that returns on Ok, instead of on Err when ? operator is used
-
plmap
Parallel pipelined map over iterators
-
enstream
Conversion from Future to Stream
-
html5ever_macros
High-performance browser-grade HTML5 parser − compiler plugins
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
pathsep
a small macro to enable easy path construction in other macro calls
-
lit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
conditional
conditional! macro which lets you use the syntax of the conditional operator (also known as the ternary operator) in Rust
-
warned
struct Warned<T, W> { value: T, warnings: Vec<W> }, which represents a value with warnings
-
lgio
Lightweight, generic, no_std IO
-
tao-of-rust
《Rust编程之道》随书源码
-
hex-display
Display impl for byte slices which provides a hexdump
-
errify
Function error context provider
-
is-same
A trait for comparing object equality
-
rust2fun_laws
Laws for rust2fun
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
error-doc
proc macro to generate #[doc] comments from #[error] messages
-
vec_vec
When dealing with
Vec<Vec<T>>is unavoidable -
stable-pattern
Stable port of std::str::Pattern and friends
-
swamp-script-ast
ast types for swamp script
-
generic-mutability
Allows the creation of APIs that are generic over mutability
-
collections_macros
a collection of macros to make making collections easier
-
extrude
A macro for unwrapping an enum value into an Option
-
throws
A macro for easy creation per-function errors
-
rustbench
A lightweight Rust procedural macro for benchmarking function execution time
-
rusty-peg
A macro for defining PEG parsers
-
fallible
operations
-
rustollens
A small and experimental library with a type-level representation of booleans with companion connectives for compile-time sort-of fun with logic
-
dyn_traits
Magically derive non-object-safe traits
-
aspect-weave
An Aspect Toolkit for Rust
-
locate-error-core
Types and utilities for locate-error
-
iter-opt-filter
Adds an optional filter to iterators
-
see-through
traits to provide access to internal fields of generic structs
-
enum-to-string-traits
EnumToStringderive macro which implements the methodsas_str()andas_dbg()to enums with no associated values -
unsafe-storage
Maintain invariants in macros without modules
-
derive_environment
modifying structs via environment variables
-
intuple
Convert structs and enums into tuples (of refs) and back - recursive, ignore fields
-
enum_properties
A macro for declaring static properties on enum variants
-
tuple-traits
Additional tuple traits to enable ergonomic types
-
niceowner
A stupid library that allows you to own a value, even if it comes from a reference. No cloning.
-
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. -
strunemix
allows to build a struct with a form of its fields, by deriving enums of them
-
total_float_wrap
Floating point wrapper implementing Hash and Ord according to IEEE 754 totalOrd
-
trust_me
Just replace unsafe keyword to
safe!macro. Always trust programmers. -
optargs
Easily create macros for functions with optional arguments
-
formy
derive macro to turn structs into html forms
-
catch-unwind
Wrappers for catch_unwind that handle the edge case of the caught panic payload panicing
-
bindgen-cfg
Specify bindgen settings using yaml
-
itermap
Iterator tools for maps (
HashMap,BTreeMap, etc.) -
hetseq
Defines traits and types to work with heterogenous sequences
-
then
bool::then functions but named properly
-
cosmian_ffi
Tools to build Foreign Function Interfaces at Cosmian
-
rs_state_machine
A business-oriented state machine library
-
project-uninit
Macros for safe references to and initialization of fields in MaybeUninit structs
-
swiss-army-knife
Common utility code to support linux-support and other projects
-
x-bow
Precise State Management Library
-
match_opt
A macro for turning a partial match into a full match returning an option
-
stump
Simplified command line logging
-
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
-
cargo
package manager for Rust
-
rich-result
Rich result type differentiating between recoverable & fatal errors
-
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.
-
rubbl_core
Core types and traits for Rubbl, a Rust package for astrophysics
-
has_fields
Some macros helpful for processing forms with optional fields
-
tt-call
Token tree calling convention
-
pipette
Polymorphic function pipelines without traits or macros
-
rust-secure-code/mem-markers
marker traits about types layout in memory
-
tuple-fn
call functions and closures with tuple of arguments
-
finny
Finite State Machines with a procedural builder-style API and compile time transition checks
-
flow_impl
Definition of an Implementation trait for flow functions, and a derive macro
-
new_type
Experimental implementation of newtypes by type level logic
-
actuate-core
A reactivity framework
-
stackstack
A singly linked list intended to be chained along stack frames
-
assure
macros for Rust runtime checks and error handling
-
even_bigger_s
Better String Literal
-
loglevel
way to set your log level
-
cmake-parser
parse cmake language
-
u-plus
Pretty Unicode code point literals: U+12345 instead of '\u{12345}'
-
rudeboy
Rlua User Data Extension Boy - Derive/attr macros and traits for easily exporting user data to RLua
-
litto
Building blocks for DSL scripting language interpreters that interact with native Rust code
-
disown
Drop ownership via a method
-
rvs
defining and evaluating random variables using a simple DSL
-
checked_ops
Automatic checked arithmetic operations in Rust
-
fmterr
Sane error reporting that just works
-
kmacros_shim
Useful macros
-
wdl-macros
Macros used within the
wdlcrate ecosystem -
rangecutter
working with adjacent ranges
-
xmt
Batteries-included CLI output library for Rust
-
polimorphism
Function overloading via a procedural macro
-
xconstants
Adds preliminary support for enum const generics
-
apply_conditionally
Chain and apply methods on objects conditionally
-
scopefn
Scope functions for Rust
-
typed_key
Strongly-typed string keys for configuration
-
take-static
Static items that provide mutable access only once
-
storagevec
Feature-gated heap-based/stack-based map and vector structures
-
instancebuilder
Convenient way of managing dependency injection
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
det
Calculate the determinant using a macro
-
user_stable_vtable
A partial implementation of [RFC 2955], written in stable rust
-
diatom-std-os
The diatom programming language
-
formatx
A macro for formatting non literal strings at runtime
-
furtif-core
Flexible User-oriented Rusted Toolbox for Information Fusion: a data fusion toolbox based on asynchronous and interacting processes, particularly focused on belief functions fusion
-
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
display_macro
Like print! macro but always flushing
-
dirk_framework
Dependency Injection for Rust
-
turbostate
Finite State Machine
-
racros
Collection of rust macros
-
frankencell
An alternative to
qcellandghost-cellthat instead uses const generics -
mathelogos
as a functional programming language
-
declarative_type_state
A collection of declarative macros to reduce boilerplate code when implementing type-state patterns
-
fast_async_trait
Fast async traits for Rust
-
assert-impl
Macro for static assert types implement a trait or not
-
alternator
Tools for building effect system -like functionality by abusing async
-
enum-unit
Generates unit-variant enums from existing enums
-
ufcs
Helper trait to call free functions using method call syntax
-
opt2r
crate(library) that provides a way to convert Option to Result
-
arr_ty
Macros for smart array initialization (best for trait object element types)
-
near-safe-cell
A more ergonomic 'UnsafeCell' wrapper/replacement
-
tor-async-utils
Async/futures helpers for use with Tor
-
units
Measure for Rust. Easy to use, type-safe and customizable.
-
transactional_iterator
Iterator that allows to commit or abort progress
-
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
-
try-unwrap
A revolutionary new crate that allows you to unwrap() without making your stupid software panic
-
user_doc-tests
Tests for user_doc
-
fortraith
Compile-time compiler that compiles Forth to compile-time trait expressions
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
introspectable
Basic introspection via the Introspectable trait
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
super_cell
A super (unsafe) cell that also implements send and sync regardless of the inner type's send/sync
-
type-nats
Type-level natural numbers in Rust
-
iter_vals
On the fly iterator creation
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
atomic_refcell_try
Threadsafe RefCell
-
nix-compat-derive
Nix protocols and data formats
-
transfer
that exposes a Transfer trait, that is to move what Clone is to copy
-
to_vec
convenient to_vec, to_set and to_map methods on iterators
-
serde_gelf
Gelf serialization using serde
-
algtype
Conversion between data and its representation, like Haskell Generic
-
uninitialized
Opt-in unsafe uninitialized memory
-
swamp-types
types used in Swamp
-
arraytools
A variety of helpful methods for working with fixed-size arrays
-
spawn_timeout
Call a subroutine after a constant time interval
-
HOPA
A lightweight, higher-order parser
-
chain_tools
A set of traits allowing for more a erganomic style of chain programming
-
nclosure
composable, nameable closure types with separated states and functionality for use in APIs where anonymous types are unavailable
-
yolo-block
Like a
tryblock, but automatically unwraps the result -
try_ops
try catc... ops macro
-
html_compile
A template engine for generating HTML strings within Rust for use with static websites
-
not-so-fast
data validation with derive macro
-
ra_ap_assists
TBD
-
error-context
Methods and types that help with adding additional context information to error types
-
maflow
Flow macros: basically unwrap for return, continue and break
-
new_units
Make unique types
-
slid
labeled IDs
-
have_len
container empty ? (
is_empty()andis_not_empty()) -
matrix_match
Macro to match on two values at the same time
-
dep_doc
Add a cute dependency declaration snippet in your crate documentation
-
user-panic
Error messages
-
mould
Rust web-framework for websocket based web-apps
-
unify
Trait-based equality constraint for Rust
-
base-traits
base traits (for Rust)
-
fn_name
Macros that produce the name of the function they're invoked within
-
batch_oper
some batch operation macro for some operations
-
base64_type
type wrapper for Vec<u8> that uses base64 for serialization
-
mutify
Macro for coercing a
mut var: Torvar: &mut Tinto a&mut T -
daml-macro
Helper macros for working with the Daml Ledger API
-
ambience
Lightweight library for passing ambient parameters
-
typeless
unsafeinline type erasure -
sc2-macro
Procedural macros for rust-sc2 API
-
from_int
A package to easily add a from_int method to enums with #[derive(FromInt)]
-
fkl-dot
Feakin is a architecture design and visual collaboration tool. This is the parser for Feakin.
-
damock
Derivable data mocking for tests
-
unreachable_checked
unreachable!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won't panic.
-
tany
Type-erased container with inline storage for small values
-
variante
Statically-verified enum variant names as strings
-
cassandra_macro
Create Cassandra tables and CRUD CQL prepared statements from Rust structs. (custom derive: cassandra_macro_derive)
-
constant
evaluation tools for Rust
-
bounded_types
type representing bounded integers, implemented using const generics
-
shared_error
SharedError wrapper for cloneable Error
-
stringlit
A macro to convert from str to String
-
pushy
A pushable stack-allocated buffer
-
delay_init
Macro to declare lazily initialized types
-
iso3166-1
ISO 3166-1 data
-
closure
A macro for capturing variables on a per variable basis
-
global_var
macro for declaring a global variable
-
pluginop-rawptr
Safe abstractions atop raw pointers
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
iter-python
Python generator expressions and 'list' comprehensions
-
assert-type-eq
Macro to assert types across potentially different crate versions are compatible
-
bitflags-derive
bitflags-aware #[derive] macros
-
swamp-ast
ast types for swamp
-
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
ilyvion-util
Collection of utility functions and types for use in my personal projects
-
anonymous-trait
Anonymous trait implementation with capturing the environment
-
macro-map
Closure-less
Result::map_errandOption::ok_or_else -
mod
project that provides two simple and useful utility functions for converting between Option and Result types
-
frunk_utils
working with frunk
-
berusty
Me practicing Rust
-
physical-quantity
dimension and unit system for general physical physical quantities
-
iter-flow
Functional programming utilities for Rust
-
lox_utils
General helpers used by Lox
-
lazy_thread_local
Lazily initialised per-object thread-local storage
-
regecs-codegen
Code generation macros for REGECS
-
bloc
A state management library
-
arc-interner
An interner that deallocates unused values
-
chain_linq
.NET's LINQ in rust as a declarative macro
-
merge2
Merge structs into single by values
-
error
A fancy error type for highly generic cases
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
derive-alias
Alias multiple derives as one
-
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…
-
shrinkwraprs
Auto-derive for Rust conversion traits -- make working with newtypes a breeze
-
mod_trait_exerci
how to understand the rust feature trait with mod
-
erroneous
Minimalistic helper for using errors
-
option_macro
a convenience macro
-
grade
A convenience macro for gtk-rs
-
expression_format
format Rust expressions in a string, similar to f-string formatting in Python
-
displaythis
derive(Display)
-
fourcc
Syntax extension to generate FourCCs (four-character code)
-
stringish
A smaller and easier copy-on-write string
-
uncheck-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
os_str_bytes
Lossless functionality for platform-native strings
-
chonk
A lightweight parser combinator framework
-
composing
Tools to compose functions
-
encoding_index_tests
Helper macros used to test index tables for character encodings
-
const-assert
Assert struct for const generics
-
rcrefcell
Wrapper type for Rc<RefCell<A>>
-
unwrap_let
macro for quickly unwrapping a refutable pattern
-
array-lit
Macros for array and
Vecliterals with superpowers -
predicate
Use enum to predicate something, support & and | operator
-
checked_array
A checked API for array types
-
int_ranges
ranges tools for integer
-
multiref
Multireferences: a safe way to do [&T] -> &[T]
-
tap-trait
Inspect and mutate values without leaving the method chain
-
error-macro
error macro
-
zconvertenumn
Convert number to enum
-
dyn_struct
Construct dynamically sized types safely
-
quixutils
Common helpers and utils
-
polymorph
A set of utilities to better enable polymorphic behavior in Rust
-
smart
dynamically-dispatched smart pointers
-
static-cond
Macro for performing comparisons during macro expansion
-
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. -
fancy-ip
Fanciest way to initialize IP addresses
-
simple-di
dependency injection for Rust
-
compost
Adds a macro to decompose tuples into tuples containing a subset of their values
-
try-traits
Alternatives to std lib traits that can fail
-
define_into_enum
Defines Into<T> on an enum where all variants wrap T
-
cluStaticData
Initializers of static values. Manual initialization, automatic initialization.
-
with-thread-local
A micro crate that simplifies a bit the use of the std macro
thread_local! -
anyflux
Generic flux-like state management
-
build-deftly
Derive custom builders, using the derive-deftly macro system
-
consume-iterator
Consume any iterator fully
-
visita
Elegant implementation of the Visitor Pattern
-
stable_borrow
A marker trait indicating that borrows are address-stable
-
struct-builder
Derive a builder for your structs
-
tuple_tricks
A couple of traits on tuples that allow inductively building new traits
-
vec_remove_if
Extract elements from a vector based on supplied criteria
-
strong
Strongly typed String
-
fix_fn
Macro to create recursive closures (similar to the Y combinator)
-
controlflow_inspect
inspect_* methods for ControlFlow
-
merg
Merge multiple values into one
-
ownit
Easily turn borrowed type into owned values
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
contains
A Container trait
-
default_is_triple_underscore
Shorter syntax for Default::default() : ___()
-
const_guards
An attribute macro for compile time constraints on const generics
-
any_ref
To capture and move things that are NOT 'static with memory safety
-
tagged-pointer-as-enum
A set of structs, traits and macros to implement tagged pointers
-
respan
Macros to erase scope information from tokens
-
struct2vec
Rust structure to slice
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
batbox-tuple-macros
Macro for calling your macro for all tuple sizes
-
inline_newtype
newtype macro inspired by kotlin's inline class
-
chainer
A cursed crate that allows for global call chaining with access to chained function results
-
inner
The inner! macro descends into an enum variant. It's more flexible than try!() and unwrap(), and it works with your enum, too!
-
epui
Equisized (primitive) unsigned ints for primitive ints: u8 for u8, u16 for i16, etc
-
nagios-range
types to parse and operate on Nagios ranges
-
integer_or_float
A data type holding an ‘integer or float’ (a data type in the Unified Font Object specification, among others)
-
statum-core
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
vnd_siren
A SIREN DSL/serializer
-
array-fu
Construct arrays using simple syntax
-
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
-
typedopts
Type aware command line parser
-
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
-
destruct-lib
Destruct structs and enums for simpler combinator implementation
-
slicefields
Allows for data structures whose members are sub byte aligned (e.g. a one bit alignment)
-
litenum
minimal convertion utilities between literal and enum
-
attr_alias
Reduce attribute repetition with aliases
-
display_with
Return opaque impl Display and/or impl Debug types via display_with and debug_with
-
ntstatus
bindings for Rust
-
cursor
A more free Rust-Iterator
-
ferrum-plugin
Lazily evaluated, order-independent plugins for extensible types
-
bg
builder + generics
-
endors
Validation library
-
orx-iterable
Defines and implements Iterable, Collection and CollectionMut traits to represent types that can be iterated over multiple times
-
io-read-line-prototype
Prototype for io::read_line
-
lambek
Type-Level Programming in Rust
-
error-type
macro for constructing unifying error types
-
type_utilities
Implementing more methods to rust type primitives
-
model_macro
traits collection
-
jod-thread
std::thread which joins on drop by default
-
string-newtype
New Type idiom helper for string-like types
-
macro-stateful
help record state in a global scope
-
assert_ok
A macro that asserts a Result is Ok
-
sod-tungstenite
Service Oriented Design - Tungstenite
-
conditional-assignment
very simple, small crate to help make conditional assignments more ergonomic
-
tuple_length
determining the length of a tuple
-
is-impl
Rust macro to check that a type conforms to an impl
-
box-macro
Literally just the macro
box_!which isBox::new -
fstrings
Python3 fstring interpolation in Rust
-
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… -
expect_soft
.expect but exit instead of panic
-
arch-into
safe type conversions between pointer-sized types (usize/isize) and types with fixed size
-
ama
Quasi-quotation system for designing procedural macros mixed with Rust code
-
dynamic-cast
The fifth pillar of OOP: dynamic casting
-
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
json-keypath-iter
Iterator for traversing serde json objects, yielding a flattened path and value of each element
-
safe_transmute_2
A safe-guarded transmute which aims for a good,short and extensible API
-
funfun
Macros for working with closures
-
doless
macro to simplify struct mapping and function utilities
-
n-functor
Faux-derive a
mapfunction for types with one or more type parameters -
skipif
Turn test cases into no-ops with _SKIPPED appended to their name based on compile time conditions
-
type-sets
Sets implemented in the rust type-system
-
remarklib
The core of the Remark programming language
-
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
-
tearor
Easily turn data races into data corruption!
-
interpolate_idents_gnzlbg_fork
Useable macro identifier concatenation plugin
-
unwrap_all
Unpack multiple levels of
Result<T, E>andOption<T>at once -
io-cast
a high-level io function similar to Python's input function
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
irox-structs
Traits for Struct Types - linearly serialized big/little endian bytes
-
default_macro
My default!() macro
-
miette_helper
providing helper macros for miette
-
oneshot-fused-workaround
Fused wrapper for futures::channel::oneshot
-
adana-std-process
Adana standard library
-
pages
A dynamically-sized heap-backed data page. Comprises a user-chosen header and data array packed into a single allocation.
-
clonesure
A helper macro to create closures which will clone its environment
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
stats_traits
Traits for collection-like types to calculate statistics
-
rusty-value
Create a generic inspectable value from any rust type
-
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
deferrer
defer! macro for deferring functions
-
better-as
Explicit type casting
-
autoproto
Replacement derive macros for
prost::Message, and supporting traits and types to make implementing this trait easier -
wopt
A procedural macro that automatically generates an Option-wrapped version of a struct, reducing boilerplate for optional updates
-
duplex
trait: interactive streams
-
displaydoc-lite
Implement the Display trait using your standard doc comments
-
retroqwest
A reqwest REST client generator
-
wrapped-list
Macro for wrapping elements of a list with an object, function, or another macro at compile time
-
thisisplural
#[derive(Plural)] for creating frictionless new types with any collection type like Vec or HashMap
-
error-utils
Some rust macros to simplify common error handling patterns
-
munge_macro
Macro for custom destructuring
-
cgp-error-extra
Context-generic programming error components
-
async-event-dispatch
async event dispatcher that is not susceptible to the slow-receiver problem
-
brainfuck_macros
A compiler plugin that converts brainfuck code into Rust at compile time, letting your BF programs be optimised by LLVM to super-fast native code
-
io-arc
Proof of concept Arc with IO trait delegation
-
fluent_state_machine
A domain-specific language (DSL) for creating state machines in Rust
-
unwrap_goto
unwrap Option an Result or goto
return/cotinue/breakas you want -
ref-map
Helper trait for Option and Result to map references
-
static-cow
Cowat the type level: a framework of traits for writing types that are generic over ownership of their contents -
builder-pattern
A derivable macro for declaring a builder pattern
-
kaydle-primitives
Low level primitive parsers for KDL, intended as a building block for higher level parsers or deserializers
-
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…
-
aligned_ptr
Wrappers of functions defined in core::ptr and core::slice modules with alignment and null checks
-
championship
Generate championship fixtures using the round-robin tournament algorithm
-
container_literals
vec! like macros for creating maps and sets
-
html_stack
A stack based dsl for writing html. This is not an html template!
-
float-derive
that allows deriving Eq and Hash for types that contain floating points
-
oi-unwrap
unwrap without unwrap
-
borrowck_sacrifices
Necessary sacrifices to keep the Borrow Checker happy and developers sane
-
borrown
Borrowed or owned, simplified for no-std
-
holder
getter setter auto gen with holder trait
-
block_effects
A macro to chain block effects
-
cisness
Runtime 'live witness' of two types being the same
-
map-to-const
Easily convert HashMap<K, V> to constant [(K, V); N] values
-
arraylib
Tools for working with arrays
-
structmap
Procedural macro library for converting between Rust structs and associative containers
-
ghosts
Type-check non-existing
Phantomcode for Fun And Profit™ -
literalext
A helper crate for interpreting proc-macro
Literalvalues -
unibox
Universal Box that can store any type using static or dynamic memory
-
untrusted_value_derive_internals
aim to provide a type-safe way to handle and sanitize potentially untrusted values like user input
-
irox-enums
Traits for better Enumerated Types
-
cfg_matrix
Procedural macro to generate permutations of supertraits based on cfg flags
-
nom-fields
single function-like macro that removes some boilerplate from a common pattern when using nom
-
dynamic
A dyanmically typed value with fast downcasting
-
binjs_io
I/O component of the Binary AST reference implementation
-
accord
validating data according to rules like "contains", "length", "either", "range"
-
bulwark
Panic-aware scope guards
-
using
A macro for simpler builders with method cascading
-
usage
A convenient alternative to the newtype pattern
-
multi_try
Safely combine results
-
dyn-fn-once
Dynamically-typed self-consuming closures in Rust
-
tyfling
todo
-
delegatemethod
Delegate method calls to a field
-
hashmap_macro
hashmap macro for creating hashmap from provided key/value pairs
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
html5ever-atoms
Static strings for html5ever
-
leptos_datatable
A leptos component for creating tables with data validation
-
generic-std
Experimental HKT framework and generic traits for the standard library
-
lifelink
Erase covariant lifetime parameters from anything, with generic associated types
-
logkit
Super fast, structured, scalable logging library for Rust
-
take-if
A tiny utility for conditionally taking the contents of an option
-
mixed_array
Construct arrays of mixed types
-
function-compose
lib to allow composition of sync and async rust functions
-
upget
Super simple trait that patterns the value "updae" and "get"
-
same-types
Ensure that two types are the same
-
comptools
Create iterators using Python's list comprehesion style
-
lua-macros
Useful macros to join Lua with Rust
-
endian-num
Byte-order-aware numeric types
-
rcss-layers
Part of Rust CSS embedding library that allows saving styles as seperate layers
-
zc_io
zero-copy I/O
-
drop_ok
.drop_oksyntax sugar forResult. It’s instead of.map(|_|()). -
macroland
macro shorthands of various types in Rust
-
fdb_tuple
convert between FoundationDB Tuple Layer tuples and Rust tuples
-
apply_pub
syntax extension for applying the
pubvisibility modifer to many items at once -
amass
Automatically generate
Fromimpls for nested enums, even across crates -
predicates-core
An API for boolean-valued predicate functions
-
uni_rc_lock
trait which may represent either Rc<RefCell<T>> or Arc<RwLock<T>>
-
memory-size-type
A data type for dealing with memory sizes
-
newtype-enum
Traits to convert between enums and their variant types
-
as_base
Cast trait objects to some base class
-
array_manipulation
Methods for manipuling arrays in a Vec-like fashion. It will (probably) get into core once const expressions get less experimental.
-
eso
Type machinery to build Cow-like containers
-
chained
lazily chaining functions
-
sql-functions
dialect specific SQL Functions
-
anysafe
any safe
-
wee-woo
Wanted: Handy error-related utilities
-
field-projection
Field projection experiment
-
constany_blank
Convert any function to constant
-
arrow-array
Array abstractions for Apache Arrow
-
retour-utils
creating hooks with
retour -
place_macro
Macros you wish you had while you were writing your non-proc macro
-
impl_serde_serialize_error
Macro for fast implementing error methods in serde::Serializer trait
-
lazy-attribute
convenient attribute macro for lazy function execution
-
rustica
functional programming library for the Rust language
-
structify
A procedural macro to transform functions into structs with state and execution dependencies
-
const_type
define enum-like const-types, but with aliases for variants
-
bos
Flexible Borrowed, Owned or Shared (B.O.S.) smart pointers. Like std's Cow but with Rc/Arc and without the ToOwned requirement
-
exit
Custom exit status codes with ? in main
-
mut_family
A GAT-based library for writing code that is generic over exterior/interior mutability and mutability of references
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
static-include-bytes
Like the built-in
include_bytes!macro but produces a static array definition -
iterify
Turn any type into an iterator with closures!
-
cw-dsl
Resolve tag weights of cyber waifu
-
engineer
master builder!
-
symbolism
Unique symbols made from human readable tags
-
push_mut
Push a value to the back of the vector, and return a mutable reference to it
-
sumtype-macro
Generate zerocost sumtype of iterators or closures
-
shellexpand-fork
Shell-like expansions in strings
-
derive_default_builder
derives a builder implementation relying on all fields implementing Default
-
const-enum-tools
Trait definitions for working with enums at compile time using macros
-
safe
A
#[safe]attribute for explaining whyunsafe { ... }is OK. -
open-ambient
Open files and directories with constant paths
-
sanitizeable
derive structs without certain fields
-
zerocopy
makes zero-cost memory manipulation effortless. We write "unsafe" so you don't have to.
-
yew-html-attributes
Easily forwarding standard HTML attributes to a html element
-
dyncast
Downcasting made easy
-
partial-result
results that return success for non-critical errors
-
what-i-want
Some tools to help with the return value
-
enum-tools
Automatically derive functions and trait implementations for enums
-
bstringify
stringify! that yields byte string literals instead
-
thin_delegate
Auto implementation of trivial delegation to inner types
-
pinpoint
pinned references
-
init-token
one-time safe initialization of static, without overhead
-
type-factory
unique opaque types
-
literal
Literals for Rust's collections
-
default-impl
A macro for implementing traits with their default implementations
-
ctreg
Compile-time regular expressions the way they were always meant to be
-
drop_some
.drop_somesyntax sugar forOption. It’s instead of.map(|_|()). -
rustility
A collection of utilities I often find myself using in Rust
-
option-cell
OptionCell: OnceCell but derivable from Option
-
fmt_adapter
newtype adaptors to and from any formatting trait
-
apperr
A thin special-purpose wrapper around Any
-
impl-macros
impl macros
-
environment
Helper to deal with environment variables
-
identifiers
working with rust identifiers and keywords
-
vet
Arbitrary type validation
-
id_cache
A cache data structure which generates sequentially-assigned ids for unique values
-
parametrized-macro
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
lang_extension
Rust Lang Extension
-
negative-impl
Negative trait implementations on stable Rust
-
goto
A safe but not complete implementation of the goto operator
-
guest_cell
Storage space for externally-owned private data
-
io-window
Seekable I/O adapter that limits operations to a byte range
-
keepops
Extension traits for keeping the input of mapping functions
-
unsaferef
An unsafe reference without explicit lifetime
-
doc-type
A small Rust crate for generating documents from your types
-
rust_io
Macro implementation for [rust_io] defining several operators to be used emulating Haskel [do notation]
-
structural
Field accessor traits,and emulation of structural types
-
simplerror
A zero-dep macro to declaratively define error enum types and their common trait implementations
-
kinds
Higher-Kinded Types simulated by GATs
-
dst
Data structures for DSTs
-
shoogah
Add some syntactic 'shoogah' to Rust
-
generic-statics
generic statics for rust
-
tested-trait
Associate tests with traits
-
struct2map
Procedural macro library for converting between Rust structs and associative containers
-
pointer-identity
Wrapper type to treat the pointer address of types as identity rather than the value
-
another_pipe_macro
Adds a macro for composing functions
-
trace-error
Extensions to Rust's error system to automatically include backtraces
-
test-results
A series of utility macros for outputting testing results
-
tartan-c-enum
Define FFI-safe enums that support unknown values
-
zst
Zero-sized generic type with the associated type exposing the type parameter
-
pigeon-impl
Generate recursive-descent & precedence climbing parsers. (extra implementations)
-
capture
A macro for adding explicit capture clauses to a (closure-) expression
-
loopcell
cell for multiple routes of access that are only used one-at-a-time in sequence
-
cmdstruct
A lightweight macro for implementing commands with a struct
-
roxygen
Seamlessly document function parameters with rustdoc
-
model-mapper-macros
Macros for model-mapper crate
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
cartesian_array_product
Arrays of the cartesian product of a set of items
-
own-ref
&own references with ergonomic macro construction
-
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…
-
cs-utils
Common utilities
-
pin-projections
Declarative macro for creating projection functions for pinned objects
-
template-builder
making idiomatic, declarative, builder-like patterns that use the struct literal syntax
-
soft_assert
Non-panicking assertions
-
sac
A macro for constructing collections
-
into_variant
Easily convert your types into the corresponding enum variant
-
strdeser
A struct serializer for rust empowered with a macro
-
assert_into
For when writing .try_into().unwrap() feels too long
-
cute
A macro for Python-esque comprehensions
-
temporary_enum_delegate_0_3_0
trait delegation functionality for enums and structs
-
pipe-chain
Combinators & parser library
-
mopa-maintained
My Own Personal Any: get your own Any with additional functionality
-
zisvalidator
A validator for struct and enum
-
collect-all
vec! for everything: easily make literals of any collection!
-
msiz_rustc-ap-syntax
Automatically published version of the package
syntaxin the rust-lang/rust repository from commit 74d5c70b174f06843049af2d764ff57ddc81c81c The publishing script for this crate lives at: https://github… -
derive-ex
Improved version of the macro to implement the traits defined in the standard library
-
num_alias
macros to declare 'type checked' aliases for integers and floats
-
wrap
Generic function wrapping
-
package_info
exposing Cargo Package Information to Rust code
-
init_cell
A safe-to-access, unsafely-initialized cell
-
builder_macro
A macro to generate structs and a corresponding builder
-
cfg-or-panic
Replace function bodies with
unimplemented!()when condition is not met -
macro-attr
macro_attr!macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derivecrate. -
cloneable-file
Cloneable file descriptor
-
collections-fromstr
Derives FromStr for collection types like Vec<T> or HashSet<T>
-
scones_examples
Examples (and tests) for the Scones crate
-
arraybox
A box with fixed capacity, backed by a byte array (it can be stored on the stack too). Implements fixed capacity
ArrayBox. -
explicit_cast
explicit widening, truncating, and sign casting of primitive integers
-
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. -
eieio
Error Implementing
Eq + Clonereplacingstd::io::Error -
const-anonymous-functions
macro to create const anonymous functions
-
exponential-backoff
An exponential backoff generator with jitter
-
elicit_macro
SmartPointer-like structure for polymorphism
-
onhtml
A dsl for writing html. This is not an html template! Not complete but easily extensible.
-
cow_arc
CowArc can be useful for decreasing memory allocations by sharing immutable memory
-
raw
unsafely manipulating raw representations in Rust
-
selective_assertions
Macros for asserting equality of structs with the flexibility to exclude or focus on specific fields
-
async-retry
Async Retry
-
anygma
makes it easy to define arrays containing different types
-
byte-slice
Byte slice manipulation macros
-
heredom
Tuple notations to describe XML-like trees
-
partial-context
Partial Context Types
-
scalar_types
A module that wraps scalar types in an endian safe type
-
blk_count_macro
macro for counting a number of comma-separated tokens at compile time
-
thistermination
add the Termination trait to error enums inspired by thiserror
-
facet-types
Core types and traits for the facet reflection library
-
slice_trait
A generic trait for any slice, with item as a type parameter
-
injectify
impl Trait in structs
-
iter_from_closure
Iterator<Item = Item> from FnMut() -> Option<Item>
-
isrepr
Generating validation from arbitrary memory to repr(C) types
-
spidermeme
Traits to test for type equality and type inequality
-
generic-lexer
A generic lexer using a simple match function
-
rwtypes
Adds methods to read/write binary numbers to the Read and Write traits
-
tagged_cell
Fast, initializable, and thread safe static variables
-
read-human
Read things from a human on the command line
-
cmd_error
print an error message and exit while unwrapping Options and Results
-
ternary-rs
emulating the ternary operator from C/C++ (among other languages)
-
authorized
struct's fields
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
clone-into-box
cloning trait objects
-
cgp-field
Context-generic programming field traits
-
if-let-return
macro for
if let ... pattern -
beaver
setting up Rust objects inspired by factory_bot
-
hash-that-set
Implements hashing for sets and maps themselves. Enables a map of maps to values, or a map of sets to values.
-
maplit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
assert-json-diff
Easily compare two JSON values and get great output
-
rs_envflag_macros
An easy way to define flags by environment variables
-
type-layout
Derivable trait to view the layout of a struct, useful for debugging
-
iter_mod
A macro for enumerating all the constants in a module
-
on_demand
A macro to generate aux macros for on-demand usage
-
pia
that adds packed integer arrays for mass storage of oddly sized variables
-
codegen2
generating Rust code
-
collect_array
Allows for collecting an Iterator into an exactly sized array
-
const-it
const evaluation; slicing, error handling
-
mic
Facilitates answering to competitive programming problems
-
serde_str_helpers
Helpers for using serde with strings
-
serde_extra
Various de/serialization methods
-
exclusive_cell
A thread-safe, non-blocking, no-std cell that can only be accessed once
-
if-none
Early break/continue/return if an optional expression evaluates to
None -
retry-backoff
Retry Backoff
-
strongly
A proc macro to create strongly-typed primitives
-
result
Helpers for dealing with nested Result and Option types
-
io-extra
An extension trait for
std::io::Error, with shorthand constructors for variousstd::io::ErrorKinds -
dyn_safe
Take control of the Semver hazard of the
dynsafety of your traits! -
struct-validation
trait and derive to validate structs and return a list of errors
-
tcp-struct
Share structs over tcp
-
macro_const
A macro for creating corresponding macro definitions for constants which evaluate to the same values
-
disuse
The way to notify the implementation which return value is disuse
-
generic_once_cell
A bring-your-own-mutex version of once_cell
-
asenum
Small derive macro to safely convert the numerical value of an enum to the enum
-
tuple-conv
Allows converting tuples of one element to vectors
-
status
Error container
-
sssstd
🐍 - A better analogy for resizeable arrays
-
lazier_static
A thin wrapper around
std::sync::OnceLockproviding cached, static, lazy initialization -
nes
New Error System for rust
-
debug-map-sorted
Sorted Debug impl for HashMap
-
existential
quantification over lifetimes
-
cargo-verify
Prettier error messages for the verified crate
-
tinytest
Write more compact unit tests with a small macro
-
cflp
A context-free-language parser generated by procedural macros
-
xpr
A general purpose generic expression template library
-
archery
Abstract over the atomicity of reference-counting pointers
-
pure_cell
Alternative to GhostCell that provides safe interior mutability via const expressions
-
stdont
Kitchen sink of utils that I'd like to see in std
-
codegen-rs
generating Rust code
-
adante
A versatile, small options parser for use in the command line
-
facet-core
Core types and traits for the facet ecosystem
-
slots-slice
manipulating slices of optional values
-
lisbeth-tuple-tools
A set of tools for tuple manipulation
-
byte-array-struct
Macro to create a byte-array backed struct
-
pretty_panics
pretty panic messages
-
turbonone
macro for calling functions with Option<T> arguments
-
into_inner_drop
A helper library for implementing into_inner method for drop types safely
-
collection_macros
Collection of macros for collections
-
fn_chain
Helper macro/function to create function chaining
-
dfdi
Dependency For Dependency Injection
-
icee-container-rs
Container service for custom DI
-
assert_ne
assert not equals
-
enum-utils-from-str
Code generation for mapping from strings to arbitrary values
-
multi-trait-object
A type to store an object with all associated traits
-
try-iterator
Adds a few fallible methods to iterators
-
davenport
Ergonomic thread-local workspaces for intermediate data
-
array_iter_tools
Modify simple arrays
-
newtype-derive-2018
macros for deriving common traits for newtype structures
-
all-is-bytes
Because everything is just a bunch of bytes... right?
-
expecto-patronum
add beatiful animals to your panic outputs
-
whiteout
macros that erase the type of any value into an impl Trait for a given trait
-
scsys-core
scsys is a collection of primitives and utilities for use throughout the ecosystem
-
err-convert-macro
Errors converting macros
-
static_leak
Leak references with static lifetimes from static Mutexes and RwLocks
-
dispair
(Disp-Err) is a zero-dependency (other than
std) library that provides a simple wrapper struct that implementsErrorfor any type that implements bothDebugandDisplay -
array_ex
Easy and powerful compile-time array initialization
-
from_as_file
Traits to Read and write types that implement serde Serialize and deserialize to files
-
sorted
compile time guarantees for sorted sequences
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
arrcat
Array concatenation
-
bidirectional_enum
Automatically generates conversions between an enum type and any other type
-
result-inspect
Adds the missing Result::inspect() function
-
orderless
Orderless/named functions in Rust.
add!(b = 2); // 4. -
aliri_braid_examples
Examples demonstrating usage of the
aliri_braidcrate -
rev_slice
A newtype for operating on a reversed view of a slice
-
peggen-core
Generate recursive-descent & precedence climbing parsers. (traits)
-
arrutil
Functions for manipulating arrays from slices
-
bind_match
Convenience macro similar to
matches!but binds to variables in the pattern and returns anOptionof the result -
test-macro
macro for writing Rust test code in an easy way
-
rs-utilities
Some utilities
-
generic-global-variables
tools for implement generic global variables
-
update_cell
A Cell<Option<T>> that you can update
-
gemstone
collection of utilities
-
rand_macros
#[derive]-like functionality for therand::Randtrait -
collect_into_rc_slice
that let’s you collect an
Iterator<Item=T>into anRc<[T]>orArc<[T]>without needing to make 2 heap allocations -
expand_array
Macro to convert a static array to a fixed-size array
-
rvs-parser
Parser for Rvs - A library for defining and evaluating random variables using a simple DSL
-
iterr
Combinators for dealing with iterators of
Results -
async-anyhow-logger
An easy crate for catching anyhow errors from an asynchronous function, and passing them to your logger
-
cmp_any
Comparison for &dyn types
-
object-safe
Implement object-unsafe traits for trait objects
-
get-field-by-type
Get a value of field, based on the type of a field
-
chisel-common
Chisel common macros, types and functions
-
ttype
quick macro for printing or returning the type of a variable
-
bit_fiddler
Macros for common bit operations with multiple convenient patterns
-
disjoint-borrow
Disjoint mutable borrows of slices
-
debug_utils
enhanced debugging in Rust
-
uninit-tools
that allows working with uninitialized memory entirely in safe code
-
retry-predicate
Retry Predicate
-
stack-trait
Stack trait with entry API for the LIFO element
-
random-number-macro-impl
Generate random numbers quickly
-
typed-builder-macro
Compile-time type-checked builder derive
-
kv-derive
Derive struct conversions from and to key-value vectors
-
oneoff
one-off types
-
vec_box
A single macro to create a vec of boxed elements, for trait objects
-
unwrap_helpers
Helper macros for unwrapping
-
nbytes
Rust compile-time evaluation of byte unit conversions
-
into_ext
Extension trait for the “Into” trait, offering a method “.into_::<T>()” to specify the target type of conversion
-
default-ext
extension methods for the
Defaulttrait -
maparr
macro to build a static
Mapbased on const array -
asteroids
set of macros
-
structural-convert
Derive conversion traits (From, Into, TryFrom, TryInto) when fields are structurally similar in enums or structs
-
anyinput-core
An internal helper library of anyinput
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
convertable
Non-reflexive version of From and Into
-
synstructure_test_traits
Helper test traits for synstructure doctests
-
leaky-cow
Leak the contents of a Clone-On-Write pointer
-
pino_utils
general rust utility functions and macros
-
into-result
convenience trait for converting something into a
ResultorOption -
stack-vec
Ad-hoc compile-time sized
Vec<T>like types on the stack -
dispatchtable
Small library used to specify function dispatch tables HashMap<K, Box<Fn(..)>>
-
internal
fields in Rust
-
unnest
Macros for an unnested control flow
-
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.
-
obstruct
An experimental implementation of anonymous structs and named function arguments
-
closure_capture
Capture variables are moved into closure or async block
-
type_traits
Collection of utilities related to types and their properties
-
serde-struct-tuple-enum
Procedural macro for deserializing an enum of structs from tuples
-
rjdebounce
Debouncing function utility
-
unsaef
Macros to erase scope information from tokens
-
tyenum
Attribute macro for type enums
-
sod-log
Service Oriented Design - Log Integrations
-
string_iter
An overly designed &str iterator made with zero-copy parsing in mind
-
coproduct
Generic coproduct type with minimal memory footprint
-
descriptive_toml_derive
Procedural derive macro for serializing a struct into a TOML template with field descriptions that is easily edited and deserialized
-
strser
A struct serializer for rust empowered with a macro
-
trait-variant
working with impl traits in Rust
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
koption_macros
Some macros that are useful for working with
Options -
display_container
implement Display
-
power-assert
Power Assert in Rust. Provides better assertion message.
-
is_option
Tell you if your type is an
Option<_> -
derive-for
Macro for defining structs using the same derive procedural macros
-
multiconst
destructures an expression into multiple constants
-
from_as
Traits and derive macros to Read and write types that implement serde Serialize and deserialize to files
-
saturate
Rust traits for saturating conversion between numeric types
-
input-stream
IO streams similar to C++'s streams
-
write-only
References/slices that provide write-access, but no read-access
-
typify
JSON schema to rust type code generator
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
apply_method
Allows you to apply any function given as a parameter to the object
-
scrapmetal
Scrap Your Rust Boilerplate
-
typestr
type-level strings and slices
-
assert-cmp
Convenient assertion macros that print the failed expressions and their evaluated values
-
mutslices
ability to create many mutable slices of a vector
-
take_ref
TakeRef, TakeSlice, and TakeString traits enable treating references/slices and values interchangeably. They can be treated as references/slices. And you can take ownership of the value…
-
rusty_state
state machine for rust
-
statum-macros
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
struple
Convert structures from and to tuples
-
curry-macro
Have fun currying using Rust's native closure syntax
-
sub-array
Extract a sub-array out of an array
-
to_debug
An alternative to the ToString trait that uses the Debug trait
-
static_assertions
Compile-time assertions to ensure that invariants are met
-
consumable
Consume the value by replacing it with the default value and returning the previous value
-
io_err
serializable
std::io::Errorwith improved ergonomics -
argley
Turn a struct into arguments for a
Command -
sashay
Type-erased and lifetime-erased references and slices
-
to_unit
ToUnit; Any type to () syntax sugar
-
tia
tia; trait, impl, accessors | automatic
-
intentionally-empty
An intentionally empty crate
-
assert-parse
The util to assert macro parsing
-
typestates
macro_rules! to build typestates
-
boow
Borrow Or oWnedsmart pointer. Alternative to Cow. -
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.
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
dyn_struct2
Construct dynamically sized types safely. Supports arbitrary unsized types, not just slices
-
default-test
A default trait that can be used in tests
-
binary-utils
Binary utilities
-
anymap
A safe and convenient store for one value of each type
-
maller
that calls closures depending on the input data
-
gtk_widget_macro
A derive macro helps you handle Gtk widgets
-
sugar
Rust syntax sugar collections
-
asserts-rs
Asserts utilliy macros for Rust
-
asserter
New assertion library for rust
-
array_init_macro
initialization macro for arrays
-
fancy-default
A better
derive(Default)implementation -
generics2
macros for parsing generics (with optional where clause) in
macro_rules!- enhanced fork of generics -
dangerous_option
DangerousOption - a type similar to ! in Swift language. It's basically an Option which panics if dereferenced while containing None. no_std compatible.
-
rustutil
A collection of utility functions for Rust
-
zkp-macros-lib
procedural macros implemented using
proc_macro2 -
count_enum
Enum trait for finite types, e.g., conversion with usize, iteration on values
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
snaptest
Dead simple snapshot testing
-
join-lazy-fmt
Lazy
separator.join(iterable)method andlazy_format!for Rust -
nutype_macros
The newtype with guarantees
-
rawslice
Reimplementation of the slice iterators, with extra features. For example creation from raw pointers and start, end pointer accessors.
-
uncon
Traits for unchecked conversions between types
-
opera
Marker types that are easy to understand
-
lifetime
Traits and derive macros to change the lifetime of a type, allowing efficient reuse of your stucts or enums with any lifetime requirement
-
const_stringify_ints
Converts (generic) constant integers to &'static str
-
idealist
non-empty wrappers for standard list types
-
kozo
syntax sugars for structs
-
subset
Various subsets of slice's items that are able to iterate over references to selected items