-
anyhow
Flexible concrete Error type built on std::error::Error
-
bitflags
A macro to generate structures which behave like bitflags
-
derive_more
Adds #[derive(x)] macros for more traits
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
ordered-float
Wrappers for total ordering on floats
-
pretty_assertions
Overwrite
assert_eq!andassert_ne!with drop-in replacements, adding colorful diffs -
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
once_cell
Single assignment cells and lazy values
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
predicates
boolean-valued predicate functions
-
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
-
bon
Next-gen compile-time-checked builder generator, named function's arguments, and more!
-
bytes
Types and traits for working with bytes
-
shellexpand
Shell-like expansions in strings
-
ctor
__attribute__((constructor)) for Rust
-
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
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
smol_str
small-string optimized string type with O(1) clone
-
inventory
Typed distributed plugin registration
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
human-panic
Panic messages for humans
-
assert-json-diff
Easily compare two JSON values and get great output
-
similar-asserts
assert_eq! like macros with colorized diff output
-
approx
Approximate floating point equality comparisons and assertions
-
frunk
developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
macro_rules_attribute
Use declarative macros in attribute or derive position
-
generic-array
Generic types implementing functionality of arrays
-
dyn-clone
Clone trait that is dyn-compatible
-
memoffset
offset_of functionality for Rust structs
-
typed-builder
Compile-time type-checked builder derive
-
hostname
Cross-platform system's host name functions
-
ouroboros
Easy, safe self-referential struct generation
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
static_assertions
Compile-time assertions to ensure that invariants are met
-
zerovec
Zero-copy vector backed by a byte array
-
tap
Generic extensions for tapping values in Rust
-
az
Casts and checked casts
-
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… -
arrayref
Macros to take array references of slices
-
compiler_builtins
Compiler intrinsics used by the Rust compiler. Also available for other targets if necessary!
-
streaming-iterator
Streaming iterators
-
bitfield
macros to generate bitfield-like struct
-
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!
-
nonempty
Correct by construction non-empty vector
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
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
-
error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
beef
More compact Cow
-
extendr-api
Safe and user friendly bindings to the R programming language
-
backon
Make retry like a built-in feature provided by Rust
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
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 -
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
jaq-std
Standard library for jaq
-
float-cmp
Floating point approximate comparison traits
-
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]checks -
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
polonius-the-crab
Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust
-
cargo-manifest
Helper crate to parse and manipulate manifests -
Cargo.tomlfiles -
nutype
The newtype with guarantees
-
constcat
concat! with support for const variables and expressions
-
assertables
assert macros for better testing, debugging, quality assurance, and runtime reliability
-
rustdoc-types
Types for rustdoc's json output
-
opaque-debug
Macro for opaque Debug trait implementation
-
volatile
wrapper types for raw pointers
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
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.
-
enclose
A convenient macro, for cloning values into a closure
-
educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits
-
if_chain
Macro for writing nested
if letexpressions -
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
iri-string
IRI as string types
-
dlib
Helper macros for handling manually loading optional system libraries
-
async-once-cell
Async single assignment cells and lazy values
-
float-ord
A total ordering for floating-point numbers
-
derive-where
Deriving with custom trait bounds
-
orchestra
Generate an orchestra of subsystems from a single struct
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
jsonptr
Data structures and logic for resolving, assigning, and deleting by JSON Pointers (RFC 6901)
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
rustler
Safe Rust wrappers for creating Erlang NIF functions
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
buffer-redux
Drop-in replacements for buffered I/O in
std::iowith extra features -
unwinding
in Rust and for Rust
-
lazy_format
lazily formatting values for later
-
inlinable_string
inlinable_stringcrate provides theInlinableStringtype – an owned, grow-able UTF-8 string that stores small strings inline and avoids heap-allocation – and theStringExttrait… -
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
all_asserts
multiple types of asserts that don't exist in the standard library
-
tynm
Returns type names in shorter form
-
faux
mock structs
-
testresult
type for concise and precise test failures
-
buffered-reader
A super-powered Reader
-
stdext
Extensions for the Rust standard library structures
-
aws-smithy-types-convert
Conversion of types from aws-smithy-types to other libraries
-
bit_field
bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
foreign-types
A framework for Rust wrappers over C APIs
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
async-trait
Type erasure for async trait methods
-
enum-ordinalize
enables enums to not only obtain the ordinal values of their variants but also allows for the construction of enums from an ordinal value
-
iter-read
A Read implementation for iterators over u8 and related types
-
by_address
Wrapper for comparing and hashing pointers by address
-
fallible_collections
adds fallible allocation api to std collections
-
erasable
Type-erased thin pointers
-
failsafe
A circuit breaker implementation
-
mem_dbg
Traits and associated procedural macros to display recursively the layout and memory usage of a value
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
version-sync
ensuring that version numbers in README files and other files are kept in sync with the crate version
-
pact_consumer
Pact-Rust module that provides support for writing consumer pact tests
-
const-gen
generating (relatively) complex compile-time constants in rust
-
atomic
Generic Atomic<T> wrapper type
-
field-offset
Safe pointer-to-member implementation
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
tuples
many useful tools related to tuples
-
bounded-collections
Bounded types and their supporting traits
-
retour
A cross-platform detour library written in Rust
-
inout
Custom reference types for code generic over in-place and buffer-to-buffer modes of operation
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
konst
Const equivalents of std functions, compile-time comparison, and parsing
-
error-code
Error code
-
fatality
extension to
thiserror::Error -
easy-cast
Type conversions which are expected to succeed
-
recursion
cache-aware stack safe recursion
-
tiny-fn
Type erased closures on stack
-
lender
A lending-iterator trait based on higher-rank trait bounds, with full std::iter::Iterator functionality
-
indoc
Indented document literals
-
swift-rs
Call Swift from Rust with ease!
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
safe-transmute
A safeguarded transmute() for Rust
-
arrow_convert
Convert between nested rust types and Arrow with arrow
-
typr
A superset of the legendary R
-
calendrical_calculations
Calendrical calculations in Rust
-
dprint-swc-ext
Functionality to make swc easier to work with
-
text-size
Newtypes for text offsets
-
terrors
ergonomic and precise error handling built atop type-level set arithmetic
-
tryhard
Easily retry futures
-
st-map
Runtime for a stack-alocated map
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
psm
Portable Stack Manipulation: stack manipulation and introspection routines
-
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… -
pyo3-polars
Expression plugins and PyO3 types for polars
-
soa_derive
Automatic Struct of Array generation
-
anymap3
A safe and convenient store for one value of each type
-
rustrict
profanity filter for Rust
-
fallible-streaming-iterator
Fallible streaming iteration
-
rust-sitter
A package for defining tree-sitter grammars alongside Rust logic
-
thiserror-no-std
derive(Error)
-
strck
Checked owned and borrowed strings
-
lending-iterator
Fully general lending iterators in stable rust: windows_mut!
-
try_match
Fallible pattern matching with a function-like syntax
-
libc-print
println! and eprintln! macros on libc without stdlib
-
pinned-init
facilitate safe pinned initialization
-
oxc_index
Newtype-style helpers for
Vecandusize -
shaku
Compile Time Dependency Injection for Rust
-
cascade
Dart-like cascade macro for Rust
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
deriving_via
DerivingVia
-
cargo-generate-type
Cargo subcommand to generate Rust code from and for input data
-
crossterm_winapi
WinAPI wrapper that provides some basic simple abstractions around common WinAPI calls
-
overload
macro to simplify operator overloading
-
pusherator
Push-based version of Rust iterators
-
fallible-iterator
Fallible iterator traits
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
deno_error
Error representation to JavaScript for deno
-
chalk-ir
Chalk's internal representation of types, goals, and clauses
-
maybe-owned
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
simple-mermaid
Mermaid diagrams RustDoc integration
-
arr_macro
Initialize arrays with ease!
-
auto_enums
allow multiple return types by automatically generated enum
-
random-number
Generate random numbers quickly
-
reborrow
Emulate reborrowing for user types
-
socketpair
Cross-platform socketpair functionality
-
oxc-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
outref
Out reference
-
dupe
Marker for types which are cheap to clone
-
pin-utils
pinning
-
joinery
A small crate for generically joining iterators with a separator
-
nshare
Conversion between n-dimensional types in different Rust crates
-
i_float
This fixed float math library provides an efficient and deterministic solution for arithmetic and geometric operations
-
autosurgeon
working with data in automerge documents
-
elain
Set a type's minimum alignment with const generics
-
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…
-
vtable
Helper crate to generate ffi-friendly virtual tables
-
sealed
Macro for sealing traits and structures
-
conjure-object
Runtime support for generated Conjure objects
-
shopify_function
write Shopify Functions in Rust
-
with_locals
Function attribute to return references to locals by using CPS
-
macon
builder macro-based generator with its own idioms
-
inline-python
Inline Python code directly in your Rust code
-
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.
-
const_soft_float
Const Soft Float Point
-
r3bl_redux
Redux library built using Tokio, concurrent & parallel
-
savvy
R extension interface
-
o2o
Object to Object mapper for Rust. Derive '(Try)From' and '(Try)Into' traits.
-
retry
retrying operations that can fail
-
aoc-parse
A little library for parsing your Advent of Code puzzle input
-
condtype
Choose types at compile-time via boolean constants
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
safelog
Conditionally suppress confidential information from logs
-
cast_trait_object
Cast between trait objects using only safe Rust
-
rc-borrow
Borrowed forms of Rc and Arc
-
walle-core
OneBot lib in Rust
-
loft
embedded scripting language
-
concat-with
Extend the function of the
concat!macro instd -
vercel_runtime
Vercel Rust Function Runtime
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator -
cargo-check-external-types
Static analysis tool to detect external types exposed in a library's public API
-
void
The uninhabited void type for use in statically impossible cases
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
hooks
Compile-time, async hooks
-
sptr
Strict Provenance Polyfill
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_partsandVec::into_raw_parts -
soa-rs
A Vec-like structure-of-arrays container
-
munge
Macro for custom destructuring
-
exhaust
Trait and derive macro for working with all possible values of a type (exhaustive enumeration)
-
wyz
myrrlyn’s utility collection
-
moveit
safe, in-place construction of Rust (and C++!) objects
-
buildstructor
Macro to derive a builder from a constructor function
-
better_scoped_tls
scoped-tls, but with good error message
-
open-enum
An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
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!
-
dync
An efficient alternative to
dyn Traitfor containerized types -
fluent-comparisons
Boost readability by writing multicomparison expressions like
if any_of!({a,b,c}>=5) {...}while keeping the benefits of hand-written code -
myutil
Rust Util Collections
-
rustversion
Conditional compilation according to rustc compiler version
-
refined_type
imbuing rules into types and elevating them to more robust types
-
vector2d
The spoon of 2D vector libraries, intended for simple game development
-
lazy_errors
Effortlessly create, group, and nest arbitrary errors, and defer error handling ergonomically
-
easy_prefs
simplest to use API we could think of to persist prefs to disk. Basically wrap a macro around a struct (see syntax), then data is saved when you write to it. Performant, testable, thread safe…
-
fakeit
Fake data generator library with 130+ functions
-
data-rw
io buffer write reader
-
lambda_mountain
Typed Macro Assembler (backed by Coq proofs-of-correctness)
-
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… -
miden-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
flex-error
Flexible error definitions using macros and traits
-
orion-error
Struct Error for Large Project
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
copyless
Ways to eliminate memcpy calls when using the standard library
-
sugar_path
Sugar functions for manipulating paths
-
lazycell
providing a lazily filled Cell struct
-
devise
devising derives and other procedural macros
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
probe
Static instrumentation probes
-
ra-ap-rustc_pattern_analysis
Automatically published version of the package
rustc_pattern_analysisin the rust-lang/rust repository from commit f08d5c01e69436891ff1c181385d0e078a8482ec The publishing script for this crate lives at:… -
rust_info
Extracts the current rust compiler information
-
tan
language
-
gat-lending-iterator
iterators who's items can [mutably] reference the iterator
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
k8-client
Core Kubernetes metadata traits
-
dispose
wrapper for values that must be consumed on drop
-
funty
Trait generalization over the primitive types
-
stak-native
Optimized primitives of native functions for Stak Scheme
-
fixnum
Fixed-point numbers with explicit rounding
-
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
any_of
A general optional sum of product type which can be Neither, Left, Right or Both
-
autofolder
Single-element folding wrapper
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
parsable
A trait to easily parse data structures
-
formatx
A macro for formatting non literal strings at runtime
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
entrait
Loosely coupled Rust application design made easy
-
macro-machines
State machine macros with logging and graphviz DOT file generation
-
lowdash
A Lodash inspired utility library to manipulate array and object for Rust
-
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.
-
io-streams
Unbuffered and unlocked I/O streams
-
lazy-static-include
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
andex
Safe, strongly typed array indexes and wrappers for rust with zero dependencies
-
tuplex
Rust tuple extension
-
proc-bitfield
expressively declare bitfield-like structs
-
iced_anim
creating animations in Iced
-
fn_vm
A lightweight frame based virtual machine, meant as the base for rigz_vm
-
psl-types
Common types for the public suffix implementation crates
-
cell_wrappers
set of macros for ergonomically working with TCells and TLCells from the qcell crate
-
aerosol
dependency injection for Rust
-
vector-traits
Rust traits for 2D and 3D vector types
-
capnp_conv
capnp write/read traits to convert from structs to readers/builders
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
uniplate
boilerplate-free operations on tree-shaped data types
-
TSPL
The Simplest Parser Library
-
base-traits
base traits (for Rust)
-
resiter
Helper crate for handling iterators over result
-
stackalloc
Safely allocate and manipulate arbitrarily-sized slices on the stack at runtime
-
jnix
High-level extensions to help with the usage of JNI in Rust code
-
regex-macro
A macro to generate a lazy regex expression
-
documented
Derive and attribute macros for accessing your type's documentation at runtime
-
cap-std-ext
Extension APIs for cap-std
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
fixed-hash
Macros to define custom fixed-size hash types
-
pared
Projected reference counted pointers
-
assert_approx_eq
assert approximately equal
-
metastruct
Abstractions for iterating and mapping over struct fields
-
nunny
the definitive non-empty slice/array/vec library for Rust
-
float8
8-bit floating point types for Rust
-
enum-assoc
Procedural macro to associate constants with enum variants
-
libspecr
standard library for specr lang
-
hstr
A string type which is optimized for hash operations
-
as-any
provide the AsAny trait
-
instant-xml
A more rigorous way to map XML to Rust types
-
conflate
Merge multiple values into one
-
rustica
functional programming library for the Rust language
-
smarterr
Smart error handling library
-
sc
Raw system calls
-
emboss
Macros to embed metadata as an ELF/Mach-O section in your final binary
-
nanvm
NaN VM
-
gstuff
Small macro and trinkets that make my life easier
-
orx-pseudo-default
PseudoDefault trait allows to create a cheap default instance of a type, which does not claim to be useful
-
slice_ops
A selection of useful slice operations
-
tracerr
Custom compile-time captured error tracing
-
cluster-api-rs
Cluster API structures generated by kopium from upstream CRDs
-
current
setting current values for stack scope, such as application structure
-
steckrs
A lightweight, trait-based plugin system for Rust applications and libraries
-
renoir
Reactive Network of Operators In Rust
-
fauxgen
write your own generators in stable rust
-
radiation
Convert Rust type into raw bytes and vice versa
-
macro-asm-builder
macro-assemblers
-
conv2
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
floxide-event
Event-driven node abstractions for the floxide framework
-
panic-analyzer
an audit tool to scan your crate or workspace searching for potential panic points in your codebase
-
tinyvec_macros
Some macros for tiny containers
-
const-field-offset
Wrapper around field-offset crate and const-field-offset-macro
-
hax-lib
Hax-specific helpers for Rust programs
-
state-department
state management and dependency injection in Rust
-
endian-num
Byte-order-aware numeric types
-
globals
Painless global variables in Rust
-
ijzer
Main crate for IJzer. Provides a macro for using IJzer in a rust project, and a prelude with dependencies..
-
delegation
Macro-based delegation for enums and structs
-
subplotlib
functions and types for
subplot codegengenerated Rust based test suites. Relies onsubplotlib-derivefor associated macros. -
proc-easy
Macros to make writing proc-macro crates easy
-
corlib
A various ideas library
-
direction
Representations of directions
-
ext-trait
Annotation to easily define ad-hoc / one-shot extension traits
-
econf
Load environment variables into your struct members in one shot
-
qualifier_attr
Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items
-
doku
A framework for documenting Rust data structures
-
kindest
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
endian-writer
[no_std] Methods for efficient reading and writing of structures to raw pointers in a stream-like fashion
-
frunk_proc_macro_helpers
Common internal functions for frunk's proc macros
-
human-errors
An error library focused on providing your users with relevant advice for any problem
-
collect-with
enhanced collection operations with capacity control
-
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. -
many-unzip
Unzip iterators into tuples of arbitrary length, surpassing the limitations of
Iterator::unzipanditertools::multiunzip -
rancor
Scalable and efficient error handling without type composition
-
smart_task_openapi_axum
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
-
wiwi
Stuff™
-
statum
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
indicator
Abstractions for stream aggregation, we call them
Indicators -
file_rw
high-performance, memory-mapped file I/O utilities
-
sosecrets-rs
Secretwrapper type that reveals the secret at mostMEC: typenum::Unsignedtimes with compile time guarantees -
one_err
OneErr to rule them all
-
quoth
scannerless (no-lexing), developer-friendly parsing library for implementing DSLs and syntax parsers in Rust
-
strong-type
Procedural macros for naming and strong-typing pritimives and strings
-
ungrammar
A DSL for describing concrete syntax trees
-
suika_templates
template engine for the suika web stack
-
cast
Ergonomic, checked cast functions for primitive types
-
racer
Code completion for Rust
-
gh-workflow-tailcall
macros for gh-workflow
-
parsel
Zero-code parser generation by using AST node types as the grammar
-
fugue
A binary analysis framework written in Rust
-
rshyper
focuses on hypergraphs
-
cartesian
QOL macro that creates the cartesian product of multiple iterators
-
mut_set
A safe implementation for HashSet with iter_mut and get_mut
-
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…
-
rust-witness
Build a circom witness in Rust
-
rc-box
Known unique versions of Rc and Arc
-
zed
A minimal, Redux-like state management library for Rust with advanced features
-
semval
Semantic validation
-
doc-comment
Macro to generate doc comments
-
bool_ext
defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
yerevan
Small Rust crate that brings computation expressions idea from F# for help you to work easier with functors and monads
-
nar_dev_utils
用于NARS相关项目开发的实用工具包
-
model-mapper
Derive macro to map between different types
-
nnn
Generate your newtypes from a single macro
-
arrow-buffer
Buffer abstractions for Apache Arrow
-
familiar
reserve
-
auto_ops
Macros for easy operator overloading
-
sod-actix-web
Service Oriented Design - Actix Web
-
zngur
A Rust/C++ interoperability tool
-
unsafe-fields
unsafe to access or modify fields with safety invariants
-
bit-cursor
A cursor that supports bit-level reads and writes
-
iterate-trait
Experiment with methods on IntoIterator
-
derive_destructure2
Destructure structs that implement Drop
-
raugeas
Augeas bindings for Rust
-
eventsourced
Event sourced entities in Rust
-
funcmap
Derivable functorial mappings for Rust
-
trait-cast
Get your own Any with support for casting to trait objects
-
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
xx
A collection of useful Rust macros and small functions
-
certain-map
A typed map which can make sure item exist
-
fomat-macros
Alternative syntax for print/write/format-like macros with a small templating language
-
slice_map
A generic container to store a single type of data into unevenly sized slices
-
bilge
Use bitsized types as if they were a feature of rust
-
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
dyn-context
mechanism for lifetimes erasing
-
sugars
An useful collection of macros to make tasks easier
-
show-option
displaying Options
-
const_struct
macro that allows const structures to be passed as const generics
-
handybars
Minimal template parsing and expansion
-
components-arena
creating complex domain-specific self-referential data structures
-
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
nameof
macro to determine the string name of a binding, type, const, or function
-
heterob
conversion between bytes/bits and heterogeneous lists (tuples)
-
igc_parser
A high-level parsing/deserializing crate for IGC flight recorder files
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
simple-error
error type backed by a string
-
structx
Simulating anonymous struct and named arguments in Rust
-
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) -
cache_diff
Generate clean, human readable diffs between two cache structs
-
static-keys
Reimplement Linux kernel static keys for Rust userland applications
-
downcast
Trait for downcasting trait objects back to their original types
-
untrusted_value
aim to provide a type-safe way to handle and sanitize potentially untrusted values like user input
-
rxml_validation
Plumbing crate for rxml and rxml_proc crates
-
a1
A package for converting to and from A1 spreadsheet notation
-
verbena
Scripting language
-
btypes
Better types (BTypes) for when you dislike normal types, I guess
-
dioxus-class
Dioxus class
-
hermit-sync
Synchronization primitives for kernels
-
redb_model
Redb model derive macro and DTO type conversion
-
heap-array
variable length array, with its main benefit over
Vecis taking up less space -
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
functor_derive
A derive macro to derive a functor for a type
-
fp_rust
Implement fp features for Rust
-
thiserror-core
derive(Error)
-
sdl-parser
The SDL parser is a Rust tool designed for parsing Scenario Defined Language files
-
superscript
A Common Expression Language (CEL) interpreter for Rust
-
teleparse
-
mlua-extras
Extra helpers and functionality built on top of mlua for embedded lua development
-
async-recursion
Recursion for async functions
-
wmlua
-
pipe-trait
possible to chain regular functions
-
swamp-script-derive-tests
tests for swamp macro
-
implementation
The implementation crate
-
trender
graphics library for the terminal
-
backtrace-error
wrap errors with automatic backtrace capture and print-on-result-unwrap
-
enum-derived
Generate random instances of your enums and structs
-
tokenlock
cell types that decouple permissions from data
-
mikros
An optionated crate to help building multi-purpose applications
-
unwinder
Call stack spoofing for Rust
-
dogma
Dogma.rs
-
is_empty
Easily check if the struct is empty
-
static-id
A memory-efficient library for handling interned identifiers
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
wallee
Flexible concrete Error type built on std::error::Error with caller location tracking
-
more-di
support for dependency injection (DI)
-
cl-format
Use Common Lisp format in Rust
-
syndicate-schema-plugin
Support for using Preserves Schema with Syndicate macros
-
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
hlua
Zero-cost high-level wrapper for Lua
-
rawcode
Implements a simple as-is encoding format
-
bigerror
handle big errors ¯\_(ツ)_/¯
-
char-device
Character Device I/O
-
rs_envflag
An easy way to define flags by environment variables
-
atomic-dbg
Atomic
dbg/eprintln/eprintmacros -
alternating-iter
Provide an iterator adaptor which alternate between two iterators
-
spade-ast
Helper crate for https://spade-lang.org/
-
small_len
A small library for storing the length in the smallest internal type
-
linear_type
Linear types for rust
-
tremor-common
Tremor common functions
-
sovran-typemap
A thread-safe heterogeneous container with type-safety
-
case_insensitive_string
A case insensitive string struct
-
windows-targets
Import libs for Windows
-
route_match
A context-agnostic http routing utility
-
bignumbe-rs
Large, medium-precision numbers
-
script-format
DSL to format data via rhai scripting
-
struct-field-names-as-array
generating the field names of named structs as constants
-
defer
excecution of code, inspired by go's defer statement
-
htmf
hypertext markup functions: functions for generating HTML
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
ghost
Define your own PhantomData
-
ref_iter
Dynamic borrowing iterator
-
nu-std
The standard library of Nushell
-
maelstrom-test
Test macros for Maelstrom
-
rst-common
A shortcut to common Rust crates
-
aad
Automatic adjoint differentiation library
-
parail
Easily switch between sequential and parallel
-
elicit
SmartPointer-like structure for polymorphism
-
one_two_eight
typed 128-bit identifiers
-
self-rust-tokenize
Turns instances of Rust structures into a token stream that creates the instance
-
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. -
specmc-protocol
parsing Minecraft protocol specification
-
xasm-rs
generating linux 32/64 bit assembly easily
-
trybuild-internals-api
A fork of trybuild with the internals exposed as a public API
-
evcxr_repl
A REPL for Rust
-
oxrdf
providing basic data structures related to RDF
-
transpose-future
Transpose Option<impl Future>
-
cooked-waker
A safe interface for creating async Wakers
-
tupletools
functions for tuples
-
yield-return
Implement a coroutine like C#‘s
yield returnusing Rust’sasync,await -
deki
A base for most of my rust projects (tailored to myself)!
-
comparable_test
comparing data structures in Rust, oriented toward testing
-
ffi_types
C ABI compatible wrappers for cbindgen/bindgen
-
rev_buf_reader
that provides a buffered reader capable of reading chunks of bytes of a data stream in reverse order. Its implementation is an adapted copy of BufReader from the nightly std::io.
-
tagu
Write SVG / HTML / XML programmatically
-
algoroutine
Light-weight algebraic effect(algebraic goroutine) in Rust
-
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
-
hash-db
Trait for hash-keyed databases
-
enum-ptr
Ergonomic tagged pointer
-
string_capacity
Moved to capacity_builder
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
intern-arc
An interner that deallocates unused values
-
zeke
a http library for rust built on top of tokio
-
option-operations
Traits and auto-implementations to improve arithmetic operations usability when dealing with
Options -
checked-rs
encoding validation semantics into the type system
-
crabtime
A powerful yet easy-to-use Rust macro that generates code by evaluating inline Rust logic at compile time
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
dtor
__attribute__((destructor)) for Rust
-
focusable
A trait for types that can be focused
-
std-next
Opinionated utilities and polyfills
-
ffi_helpers
help make working with FFI easier
-
hex_lit
Hex macro literals without use of hex macros
-
version-ranges
Performance-optimized type for generic version ranges and operations on them
-
derive-ctor
Adds
#[derive(ctor)]which allows for the auto-generation of struct, enum, and union constructors -
variadics_please
Implement things as if rust had variadics
-
abs-file-macro
A macro that returns the absolute file path of the Rust source file in which it is invoked
-
airbag
handling errors and panics using 3rd party services
-
text-block-macros
Create a multiline string literal
-
portrait
Fills an
implwith the associated items required by the trait -
deptypes
Dependent types
-
append-only-bytes
Shareable append-only bytes
-
supertrait
enables default associated types and const fn trait items in stable Rust
-
inline-option
A memory-efficient alternative to Option that uses a pre-defined value to represent None
-
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
numtest
Unit testing for numerical methods
-
cortex-ai
An asynchronous flow-based processing framework for building flexible data pipelines with conditional branching and error handling
-
non_structural_derive
nonstructural derives for auto traits
-
path_scan
A lightweight Rust procedural macro for parsing path patterns (URLs, routes) with variable capturing, static binding, and compile-time checks
-
opentalk-kustos-prefix
Derive macro for defining kustos prefix
-
nject
Zero cost dependency injection module
-
easy-err
An easy Error wrapper
-
ferment
Traits for FFI conversions and some helper methods
-
maxlen
Length-bounded string and slice/vector
-
dyn-hash
Hash trait that is dyn-compatible
-
stupid_utils
that provides some simple and maybe stupid or useful tools
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
mapper
Mapping macro to help to reduce mapping boilerplate
-
variadics
Variadic generics on stable Rust using tuple lists
-
struct-metadata
Macros for attaching metadata to structs
-
ice_code
A macro to mark code paths as cold, allowing the common case to be inlined
-
enum-lexer
A proc_macro lexer generator. using
enum-like syntax. -
dynamodel
derive macro to implement conversions between your object and
HashMap<String, AttributeValue> -
result-like
Option/Result-like monad interface for your own enum
-
separator
Formats numbers into strings with thousands separators for readability
-
inline-c
Write and execute C code inside Rust
-
prima_bridge
implement the bridge pattern
-
async_labjack
A pure rust, async interface to the LabJack T-series via Modbus TCP
-
openapi_type
OpenAPI type information for Rust structs and enums
-
enum_cycling
Small macro for working with enums
-
is-odd
Returns true if the given number is odd
-
collate
Traits and a data structure to support collation and bisection
-
fmodel-rust
Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust
-
qualified_do_proptest
Proptest integration for qualified_do, enabling alternative sytnax for prop_compose!
-
orx-closure
An explicit closure with absolute seperation of the captured data from the function
-
linked_list_r4l
Linked lists that supports arbitrary removal in constant time
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
pilgrimage
A Kafka-like message broker in Rust
-
gen_value
indexes and values with generations for vectors
-
optfield
A macro that generates structs with optional fields
-
steel-core
Core compiler and VM implementation for steel
-
re_error
Helpers for handling errors
-
bellframe
Fast and idiomatic primitives for Change Ringing
-
tisel
Effective type-based pseudodynamic dispatch to impls, enums and typeid
-
restructed
Quickly derive subsets of your structs
-
vsprintf
Rust bindings to the libc vsprintf function
-
dto_mapper
create dynamic DTOs (Data Transfer Object) from a structure
-
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)
-
gan
Just do it! A small tool provides ergonomic value handling with ignore/ ok/ some semantics
-
gesha-rust-types
Rust types for Gesha proejct
-
mago-typing
basic type inference for PHP code, deducing variable and return types to assist in static analysis and automated tooling
-
selectic
that provides a cross-platform way to retrieve user-selected content from the operating system. Currently, it focuses on obtaining selected text, but it is designed to be extensible…
-
pathbufd
PathBuf with Display + formatting macro
-
sod
Service Oriented Design
-
floxide-transform
Transform node abstractions for the floxide framework
-
swift-rs-hatter-fork
Call Swift from Rust with ease!
-
visibility
Attribute to override the visibility of items (useful in conjunction with cfg_attr)
-
to-display
A trait that is Display or can be converted to Display
-
failed-result
A small crate for converting various failed value to result with corresponding error type
-
expect-exit
Result.expected(): display an error message and exit without a panic
-
deno-bindgen2
An FFI bindings generator for Deno
-
binread
helping read structs from binary data using ✨macro magic✨
-
fn_macro
函数宏
-
jkcenum
Rust enum library
-
depub
Reduce function/struct visibility
-
axum-openapi3
Facilitate the generation of OpenAPI 3.0 documentation for axum applications
-
type_cell
Attach values statically to a type using static get/set methods
-
tracker-rs
Rust bindings for tracker
-
sector
A stateful vector implementation that provides different memory management behaviors through Rust traits and state machines
-
conv
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
anyrust
any rust
-
fmt-interspersed
write an iterator's items, interspersed with a separator, to a destination
-
drop_bomb
A runtime guard for implementing linear types
-
halo2-base
Embedded domain specific language (eDSL) for writing circuits with the
halo2API. It simplifies circuit programming to declaring constraints… -
fx-callback
A subscription based callback to inform subscribers about relevant data events within structs
-
context_manager
Python's like context_managers in Rust
-
imperat
enable dependency injection and management of step-by-step flows
-
safecast
Traits to define safe casting between types
-
rs-obs-signal
observer pattern with variadic template arguments
-
strprintf
Provide a way to interpolate printf-style format strings using native Rust types. Part of libnewsboat lib dependencies
-
gluon_completion
Auto-completion for the gluon programming language
-
should
Postfix assertion library for Rust
-
assume
Macro for stating unsafe assumptions in Rust
-
system-pause
system-pauseis a Rust library for stopping program execution temporarily. It offers simple macros for pausing the console, either waiting for user input or pausing with a countdown timer… -
slice-diff-patch
providing utility functions for diff and patch of slices
-
option_trait
Helper traits for more generalized options
-
code-path
A code path macro
-
devela
A cohesive development layer
-
ffi-enum
Simply write and use
enums like rust native enums, freely passing through ffi -
blanket
macro to derive blanket implementations for your traits
-
re_tuid
128-bit Time-based Unique Identifier
-
easy-threadpool
A relatively simple thread pool which you can send jobs to
-
portable-io
“ A subset of Rust
std::iofunctionality supported forno-std -
light_ranged_integers
Ranged integers for stable Rust compiler, zero-dependencies and no unsafe code
-
hlist2
Compile-time heterogeneous list implementation
-
page-turner
A generic abstraction of APIs with pagination
-
dynamic-provider
Dynamically request arbitrarily-typed values from providers with borrowed data
-
nix-compat-derive-tests
Nix protocols and data formats
-
stream_assert
Macros to simplify testing of
Streambased APIs -
fn-traits
function traits like the standard library ones, but can be used in stable Rust
-
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
snowflaked
creating and working with snowflake ids
-
deterministic_default_hasher
A deterministic initialisation of the stdlib default hasher
-
culpa
error-handling syntax in Rust
-
gen_ops
Macros for operator overloading for generic types
-
mod_use
pub mod xxx; use xxx::*;
-
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… -
yffi
Bindings for the Yrs native C foreign function interface
-
fallthrough
Pattern match with fallthrough, in the style of C switch
-
to_method
micro-crate for using Into more ergonomically
-
nz
Collection of 100% safe macros for creating non-zero integers more easily
-
refinement-types
Refinement types
-
rust-rapidsnark
Rust wrapper for the Rapidsnark proof system
-
service-builder
A lightweight, type-safe service construction library for Rust that provides compile-time dependency injection through builder pattern
-
dynarg
mechanism for dynamic robust argument handling
-
selfie
Experimental, macro-free and allocation-free self-referential structs
-
traitsequence
Traits to abstract over sequences
-
pyo3-error
Unified error causality chains across Rust and Python
-
string_more
Extension traits for
Stringand&strtypes -
libtree
general or game tree
-
nutype-enum
Helper macro to create a nutype that behaves like an enum
-
git-ref-format
Everything you never knew you wanted for handling git ref names
-
humanbyte
A procedural macro for deriving human readable byte functions
-
abcgen
A procedural macro to generate boilerplate code for objects implementing the 'Actor' pattern
-
dicom-object
A high-level API for reading and manipulating DICOM objects
-
parenv
Environment variable parser with a clap style derive macro and elm style error reporting
-
enum-display
A macro to derive Display for enums
-
region_local
Isolate variable storage per memory region, similar to
thread_local! -
twine-core
framework for functional and composable system modeling
-
partially
Partial trait, and an optional macro to mirror a struct, wrapping each field in an Option
-
eira
Ansi-colored error reporting output
-
enum-update
representing state changes as enums
-
pergola
abstract types for join-semilattices
-
ruut-functions
parse math functions from string (1D,2D,3D,ND) and perform symbolic derivation, gradient, hessian
-
deltoid
calculate and apply deltas to structs and enums
-
pinkie
(Almost) compile-time scoped CSS-in-Rust
-
bounded-vector
Vec wrapper that guarantees upper and lower bounds on type level
-
qualified_do
Composable _qualified_ do expressions for Rust, supporting monad- and applicative-like structures
-
partial_function
A clean way to define function as a set of subfunctions where each has defined start and end bounds
-
illicit
An implicit thread-local environment which is indexed by type
-
iceyee_error
Error Message
-
advent-of-rust
Advent of Code utility macro for Rust
-
rangetools
Extending the Rust Range structs found in std::ops
-
any-fn
Dynamically-typed functions to represent any functions in Rust
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
ownable
Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more
-
cove
Casts Of Varying Elegance (COVE): extension traits for casting numerical types
-
wrap-match
A procedural macro to wrap a function in match statement to make error logging super easy
-
async-injector
Reactive dependency injection for Rust
-
ltpp-output
An atomic output library based on Rust that supports output functionalities through functions, builders, and other methods. It allows customization of text and background colors.
-
const_fn
A lightweight attribute for easy generation of const functions with conditional compilations
-
width_counters
Atomic counters with variable bit widths and customizable atomic ordering
-
enumerable
helping you to enumerate all possible values of a type
-
tighterror
A minimalistic error representation framework
-
derive-alias
Alias multiple derives as one
-
sitrep
Frontend-agnostic progress reporting
-
stack-vm
A generic, reusable, stack-based virtual machine
-
hexdump
Easy hexdump to stdout or as an iterator
-
thiserror-context
A wrapper around thiserror, giving you the ability to add context
-
nonany
Integer types with customizable niche values
-
suitest
quality of life test suites
-
minior
Ergonomic Minio Client
-
merg
Merge multiple values into one
-
unty
Explicitly types your generics
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
easy-error
error utilities
-
numeric_cast
Safely cast between numbers
-
flatty-io
Flat message transfer
-
trustfall-rustdoc-adapter
Trustfall query adapter for rustdoc JSON data
-
precomputed-hash
intending to be a base dependency to expose a precomputed hash
-
gramatika
A minimal toolkit for writing parsers with Rust
-
univec
A vector that can hold elements of any single type
-
with_drop
Nostd wrapper for using a closure as a custom drop function
-
dmntk-feel-evaluator
DMNTK | FEEL evaluator
-
syllogism
allow for some specialization using stable Rust
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
rempl
creating html components directly in your source
-
quickbits
Fast bit manipulation routines for Rust's native integer types
-
scout-json
JSON representation of ScoutLang AST
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
namewise
Derived trivial name-wise conversions for Rust types
-
named-tup
Create named tuples using the tup!() macro
-
assert-eq-float
assert_eq_float!macros that support floats -
paracord
A fast, simple, multi-threaded string interning library
-
partial_derive2
makes all the properties of a struct type an optional property
-
bytes-cast
Safely re-interpreting &[u8] bytes as custom structs without copying, for efficiently reading structured binary data
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
dinvoke_nostd
Dynamically invoke arbitrary unmanaged code
-
smallmap
Small byte-sized generic key-value map type
-
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…
-
arkui-sys
Bindings to the native ArkUI API of OpenHarmony
-
round
your floats with precision from 1 to 10
-
hs-bindgen
Handy macro to generate C-FFI bindings to Rust for Haskell
-
talib
Ta-Lib binding rust safe wrapper
-
termite-dmg
Termite Data Model Generator is a crate meant to generate boiler plate code for data models
-
type-fn
Allows for simpler coding of type-level logic, e.g. for type-number systems.
-
twinsies
Smart pointer providing 2-way joint ownership of an object
-
iter_fixed
Iterator of fixed length
-
cmp
convenience macros and function for comparing
-
box_raw_ptr
providing safe wrappers for working with raw pointer. These raw pointers are
*const Tand*mut T. These wrappers ensure memory safety by encapsulating the raw pointers in safe abstractions… -
eldenring-dlrf
Macro for generating singleton specifier for usage with the DLRF singleton finder
-
processmanager
manage process lifecycles, graceful shutdown and process faults
-
shards
rust bindings and utility in order to use shards
-
crete
Ergonomic, thread-safe & flexible state management
-
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
-
iter-comprehensions
iterator comprehensions
-
rust-kzg-bn254-primitives
offers a set of structs, traits and functions for generating Blobs and Polynomials which are used to interact with rust-kzg-bn254-prover and rust-kzg-bn254-verifier crates
-
cgp-field
Context-generic programming field traits
-
ownedbytes
Expose data as static slice
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
sigmut
a state management framework designed to be used as a foundation for UI frameworks
-
wiwi-macro-decl
declarative macros for wiwi, a library, of, Stuff™ (implementation detail; do not depend on this crate directly)
-
tw_merge
merging Tailwind CSS classes or creating variants
-
iterator-sorted
Stable functions for checking iterator sorting
-
panicmsg
simplyifying common panic messages
-
ty_map_gen
A type projecting map generator
-
verity-memory
Personal memory library with some cool features
-
rudi
out-of-the-box dependency injection framework for Rust
-
mode
A behavioral state machine library written in Rust
-
parquetry-gen
Parquet code generator
-
cranelift-assembler-x64-meta
Generate a Cranelift-specific assembler for x64 instructions
-
serde_closure
Serializable and debuggable closures. This library provides macros that wrap closures to make them serializable and debuggable
-
io-arrays
Random-access I/O
-
defer-heavy
A versatile and easy to use defer statement for Rust. Similar to Go's or Zig's defer.
-
barexp
that automatically generates mod.rs files for your project
-
flaw
Control-law-inspired embedded signal filtering, no-std and no-alloc compatible
-
kinded
Generate enums with same variants, but without data
-
conerror
macro that automatically adds context to errors
-
tardar
Extensions for diagnostic error handling with
miette -
prost-dto
Data transfer object conversion macros for prost
-
io-adapters
Adapters to convert between different writable APIs
-
unzip_iter
Unzip an iterator to iterators
-
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
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
souper-ir
manipulating Souper IR
-
maelstrom-worker-child
Helper library for maelstrom-worker
-
rustivity
An easy to use & 0 dependency reactivity crate
-
b-x
The stupidest boxed error ever
-
sfo-result
Result type for Rust
-
flexcell
A flexible cell that allows safe circumvention of double borrow issues
-
decimal
floating point arithmetic for Rust
-
convert_traits
Define your own conversion traits to solve the problem of converting two external types without using new types
-
encdec-base
encdec simple encoder/decoder base types and traits
-
convi
Convenient (but safe) conversion (
From-like) traits -
easy_node
Smart pointer for graph nodes
-
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
-
syncthreads
Safe thread synchronization
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
generativity
Generation of unique invariant lifetimes
-
path-dsl
DSL and macro to help deal with Paths and PathBufs
-
enumtrait
macros for polymorphism using enums
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
pretty-error-debug
If the process ends with an
Error, write out theErrormessage and chain -
pin-macros
primarly used to simplify the proccess of working with self-referencial structures
-
never
A stable version of the unstable never type (!)
-
messages
Runtime-agnostic actor library
-
scoped_thread_local
Highly flexible Scoped thread local with HKT builtin
-
maybe-single
A singleton. Maybe.
-
transitive
derive macros for Rust
-
fmt-derive
A more robust and versatile derive macro for Debug and Display
-
mlang-rs
scheme definition language for markup languages
-
docsplay
A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc
-
safe_math
Math without overflow, creates an enum and a macro to help mitigate any overflow while multiplying and adding
-
error2
error handle library for Rust
-
iter-index
More flexible alternative to Iterator's enumerate() method
-
oxiderr
Streamlining Error Handling in Rust
-
plugrs
A lightweight and type-safe plugin system for Rust
-
vtid
generating volatile type IDs
-
manifest-dir-macros
function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
lazy-init
Lazy initialization
-
merge
multiple values into one
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
opentalk-types-signaling-recording-service
Signaling types for the OpenTalk recording_service module
-
iced_af
The iced application framework project
-
merge2
Merge structs into single by values
-
metfor
Meteorological formulas and constants
-
dowhile_rs
Do while macro for rust with labels and nesting support
-
fnichol-cime
A demonstration of a Rust CI build/test/release workflow supporting multi-platform testing, binary builds, Docker image building, and Crates.io publishing
-
windows-link
Linking for Windows
-
home-prelude
Prelude library to support home applications
-
impls
Determine if a type implements a logical trait expression
-
trig
Complete set of trigonometric and hyperbolic functions in Rust
-
static_mime
mime type that embeds data from the IANA directly
-
borrow-or-share
Traits for either borrowing or sharing data
-
ferrunix
A lightweight run-time dependency injection framework for Rust
-
hzrd
Shared mutability containers based on hazard pointers
-
radicle-std-ext
Monkey patches of std types
-
windows-helpers
Helpers for the windows crate
-
procc-ll
processor of tokens for rust
-
ubits
Bit fields and masks
-
pgde
A macro library for consuming PostgreSQL row data into structs
-
transitionable
A no_std compatible type to transition
T -> Twhere you have an&mut T -
ser_mapper
Mapped DTO serialzation wrapper for DBO/Model
-
arrcomp
Python-style list comprehension syntax for contiguous memory Rust arrays
-
rtoolbox
functions for other crates, no backwards compatibility guarantees
-
copy_from_str
An extension trait to copy a string into another string
-
retryable-result
repeatedly try on some recoverable errors until too many or a fatal error
-
hax-frontend-exporter
mirrors of the algebraic data types used in the Rust compilers, removing indirections and inlining various pieces of information
-
err_mac
no dependency macro for creating error enums with automatic
Fromimplementations -
async-transmit
Trait for transmitting data to peers asynchronously
-
rust-code-analysis-web
Run a web service to compute and export code metrics
-
slugify-rs
generate slugs from strings
-
allow
Alias/label lints (to disable) with your intentions. Reexported from allow_prefixed, grouped under rustc::, clippy:: and rustdoc:: modules.
-
libgraft
that grafts various functions onto std & friends. Mostly intended for personal development ergonomics.
-
derive-insert
GetOrInserttrait for enums and its derive macro -
rust_examples
rust 的学习中的一些例子
-
logisheets_controller
the core of LogiSheets
-
advancedresearch-path_iter
A cocategory enumeration library based on path semantics
-
vcell
Cellwith volatile read / write operations -
bytestream
convenient way of writing binary data to a buffer
-
hexchat-plugin
Lets you write HexChat plugins in Rust
-
gazebo
A collection of well-tested utilities
-
lucene_query_builder
A procmacro derive crate to generate lucene query builder for Rust structs :
-
no-break
Typesafe extraction of continuation values from unbreakable control flows
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
ffi_time
FFI assistant for Rust time types
-
shadow_counted
An iterator that counts every iteration in a hidden counter, nested iterators may commit the count to parents
-
macro-bits
performing macro-based bit manipulation
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
ak_macros
faster development and simpler syntax with Macros Ak-Macros Group
-
function
A set of useful traits for your functional needs
-
beetle-nonzero
Combines the std
NonZerostructs into one struct -
apply
A tiny library for chaining free functions into method call chains
-
unchecked_wrap
Convenient UncheckedSync/Send wrapper types
-
cplex-rs
Binding of IBM Cplex library
-
carboxyl
functional reactive programming
-
simple-logging
logger for the log facade
-
structz
Anonymous struct implementation in rust
-
prange2
Parse numeric ranges for indexing
-
partial_application
partial function application via the partial! macro
-
buggy
A less panicky replacement for unreachable!() and unwrap
-
pike
A macro collection to pipe |> your functions calls, like in functional languages such as F#, Elixir and OCamel
-
hierr
RUST Error
-
pad-adapter
that provides pad adapter
-
superstruct
Versioned data types with minimal boilerplate
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
maybe_path
Zero overhead static initializer for Path
-
hydroflow
Hydro's low-level dataflow runtime and IR
-
algorithmify
Create specifications for algorithms defined using Rust code
-
copstr
COpy STRing module
-
eoe
exiting processes on errors gracefully
-
fcitx5-dbus
fcitx5 dbus interface for rust
-
duplicate_macrotest
Fork of the macrotest crate specifically to test the duplicate crate
-
serde_json_path_macros
Macros for the serde_json_path crate
-
better_any
Type id and Any for non static types
-
ordes
treating arrays and tuples a little bit more like vectors
-
ex_em_ell
Provide macros for serializing and deserializing XML
-
z21_api
Rust API for Roco Z21 model railway control system
-
fiberplane-pdk
Fiberplane Provider Development Kit
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
typeables
type aliases. By SixArm.com.
-
sealed_trait
making sealed traits more accessible
-
retry-error
An error type for an operation that can fail more than once
-
newstr
macros for declaring String-base new types
-
std-traits
Traits for types in the standard library
-
problem
Error handling for command line applications or prototypes
-
ifc_rs
IFC standard
-
dynrsaur
working with type-erasure/dynamic-types in Rust
-
niloecl
axum handler pattern for twilight interactions
-
adjacent-pair-iterator
An iterator over adjacent pairs in another iterator
-
crony
cron runner that spawns another thread to run your cron jobs
-
rt-format
Fully-runtime equivalent of the format! macro
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
janus-plugin
creating plugins for Janus, the WebRTC gateway
-
wager
Primitive types and functionality for betting odds
-
our-string
Customizable shared strings with inlining
-
srb-std
test description 02 description
-
sdml_error
Domain Modeling Language (SDML) errors and diagnostics
-
slice-utils
A collection of slice utils, like itertools
-
iter-identify_first_last
A helper iterator, flagging first and last elements
-
thin_cstr
An experimental crate which provides a truly thin std::ffi::CStr
-
rustdoc-stripper
manipulate rustdoc comments
-
lexi-matic
A Lexer Library
-
size-of-no-padding
A procedural macro to calculate the size of a type without padding
-
tl_interface
Type-level interface for type-level programming in Rust
-
gravitron_macro_utils
Gravitron's Macro Utils
-
configrs
Configuration library
-
generics
macros for parsing generics (with optional where clause) in
macro_rules! -
aws-smt-ir
Intermediate representation for SMT problems
-
spacetimedb-lib
A common library for SpacetimeDB
-
ux2
Non-standard integer types like
u7,u9,u10,u63,i7,i9etc -
jni-toolbox
tools to make writing JNI native functions less tiresome
-
simplerror
A zero-dep macro to declaratively define error enum types and their common trait implementations
-
yup-hyper-mock
testing clients using hyper
-
stack_box
store unsize struct on stack with static check
-
kind
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
filterable-enum
generating filterable enums (Combining bitflags and discriminated unions)
-
bogdan_hello_macro
adds the method hello_macro that generates a greeting based on the name of the struct
-
tentacli-traits
Traits and types for tentacli and related projects
-
take-until
A take_until extension for iterators
-
nil
Noxmore's Ixperimental Lutilities
-
flowcontrol
clarifying and simplifying control flow
-
mac
A collection of great and ubiqutitous macros
-
beetle_bits
A collection of bit-based types. Currently only u1 (1bit uint) and f3 (3bit float) are implemented
-
grid-iter
Ideomatic Grid operations via Iterators
-
noco
no code, no problem
-
nohashmap
Use HashMap syntax in Rust for non-hashable types
-
func
that helps creating colsures from function pointers
-
not-found-error
Convert Option to Result using convenient functions
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
easy-ext
A lightweight attribute macro for easily writing extension trait pattern
-
thiserror-ext
Useful extension utilities for
thiserror -
capture-it
Modern c++-ish capture syntax for rust
-
clap-doc
Create markdown descriptions for
clap::Commands -
stream-find
Add a
findandfind_mapmethods to any stream -
lichen
Scripting DSL (for Dialogue Graphs, et al)
-
opdater
Small trait based approch to struct updates
-
genztools
Tools for readability of Result and Option types for zoomers
-
try-specialize
Zero-cost specialization in generic context on stable Rust
-
chasa
A parser combinator with
manytaking iterator, conditional branching, and method chain -
ffi-convert
A collection of utilities to ease conversion between Rust and C-compatible data structures
-
iter-scan
Iterator scan methods that don't suck
-
htmlm
html macro with no dependencies
-
map
map!macro andmap_insert!macro, to create a HashMap collection and insert key-value pairs. Inspired by thevec!macro. -
suika_mime
handling MIME types in the suika web stack
-
okapi-response-mac
A macro for creating response code based on responses structs rather than typing and implementing OkapiRocketResponseInner manually
-
easy-int
macros for easy implementation of integer aliases
-
filterm
Filter terminal data to and from a child process
-
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
labview-interop
Types and wrappers for interperating with LabVIEW when called as a library
-
clamp_to
Clamp integer and float values to the values that fit within both the original number type and the receiving type
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
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
-
deep_safe_drop
Safe dropping of deep trees that otherwise could cause stack overflow
-
macro-attr-2018
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
parsey
parser-generator framework
-
ps-util
aims to provide generally helpful utility functions and traits
-
scoped-writer
Scoped writer utility
-
glam-traits
Traits for the vectors in glam
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
erased
Erase the type of a reference or box, retaining the lifetime
-
zellij-tile
A small client-side library for writing Zellij plugins
-
tupl
Perform generic operations on tuples
-
murrelet_src_midi
MIDI input functions for murrelet, a livecode framework
-
devgen-splitter
Devgen Splitter is a Rust library that breaks down source code into contextual chunks
-
constructivism
Simplify the construction of structured data
-
ra_ap_test_fixture
Test fixtures for rust-analyzer
-
yukon
trait for the ability to cheaply duplicate an object
-
chandeliers-sem
Semantics of Candle, a shallow embedding of Lustre in Rust
-
graphql-starter
GraphQL starter kit
-
error_mapper
standardized Results and Errors handling accross all your projects
-
xmacro_lib
macro engine for producing multiple expansions
-
credibil-did
Decentralized Identifier (DID) utilities for Rust. See features for implemented DID methods and key management or use core functionality to implement your own.
-
color-eyre-attach-report
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors. This fork adds the ability to attach new reports to existing reports.
-
approxim
Approximate floating point equality comparisons and assertions
-
ref-ops
An escape hatch for implementing
opstraits for references to newtypes -
autoerr
Very opinionated helper to declare error types
-
dyn_std
Dynamic (object-safe) version of std traits
-
isolator
A lightweight library for isolating Rust functions
-
dontpanic
Get instant notifications about any panic!(); in your codebase
-
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
as_num
Checked conversions between Rust's numeric types
-
zngur-generator
Generates Rust and C++ glue codes from the zng file
-
swimos_model
SwimOS Generic Representation of the SwimOS Serialization Model
-
accessor-pair
A trait for a pair of a getter and a setter, with a macro for easy creation
-
extended-primitives
providing primitive-like types for use
-
conditional-mod
macro for conditional module visibility
-
calc_lib
calculating things with correct order of operations
-
log_limit
A rate limiting logging crate
-
granite_reckoner
aggregator enabling basic statistical operations on Vec<T> in the specified number of threads. Works for all Rust's built-in numeric types.
-
game_inventory
An inventory system independant of item data
-
dilib
A dependency injection library for Rust
-
more-itertools
python more-itertools
-
asm_block
Translate tokens to string for Rust inline assembly
-
zerror
error interface for context-aware error-reporting
-
gemini-mainloop
An engine-agnostic mainloop abstraction library
-
columnation
Unsafe columnar containers for native Rust types
-
version
A very simple library who's job is to return the version of your crate if you're building with Cargo
-
cmdparsing
adds a macro to parse arguments
-
pathbuf
A macro to conveniently build PathBufs
-
binary-util
A panic-free binary utility crate to read/write binary streams over the wire
-
cifg
A macro for defining #[cfg] if/else blocks; alternate to cfg-if
-
advancer
Helper for advancing over mutable slices
-
board_game_range
A set of iterators for target ranges in a square tile based board game
-
cli_utils_hoijui
A tiny CLI utilities library, providing functions and constants useful in many CLI tools
-
friperms
framework for creating typed permission models for whatever system you could phatom
-
cubob
Structured output helpers for display mode
-
netsblox-extension-util
Allows for automatic generation of a NetsBlox extension that uses WASM
-
prost-validate-types
validation types with prost and prost-reflect support
-
cmdstruct
A lightweight macro for implementing commands with a struct
-
pit-rust-externref
Portal Interface Types
-
hotswap
Easy code swapping in running executables
-
rocket-response
enum for variable Rocket Responses
-
forgy
Derive macro for building dependency graphs
-
pulse
async wake signals
-
arc-interner
An interner that deallocates unused values
-
kutil-std
std utilities from Kutil
-
defer-drop
Defer dropping large types to a background thread
-
simple_parse
A declarative converter for Rust type to and from binary
-
quit
Exit cleanly with an exit code
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
boolean-circuit
import, modify and export boolean circuits
-
relax
Derive Partial<T>
-
cve-rs
Blazingly fast memory vulnerabilities, written in 100% safe Rust
-
vector3d
3D vector type
-
ssexp
A powerful parser for s-expressions
-
reductor
Generic abstractions for combining and nesting reduction patterns for iterables
-
custom-format
Custom formatting for Rust
-
enum-derive-2018
macros for deriving additional functionality for enums
-
gerber-types
Types and code generation for Gerber files (RS-274X)
-
const-macros
Various macros for const contexts
-
cgp-error
Context-generic programming error components
-
efb
Electronic Flight Bag library to plan and conduct a flight
-
opaque_typedef
Supports defining opaque typedefs
-
intertrait
Allow for inter-trait casting
-
functionality
Rust |> Functional programming = 💖
-
spade-hir
Helper crate for https://spade-lang.org/
-
implicit-fn
A macro that adds support for implicit closures to Rust
-
cryptify
A procedural macro library to obfuscate Rust code. Provides compile-time string encryption and random flow obfuscation.
-
reax
A reactivity system for Rust that infers dependencies between functions
-
relrc
Reference counted pointers, with relationships to other pointers
-
zesh_git
Package to provide git functionality to zesh
-
nrfxlib-sys
Rust bindings to the Nordic nRF91* Socket Library
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
tc-error
TinyChain's generic error struct
-
copyvec
A contiguous growable array type, with a fixed, stack-alllocated capacity that implements Copy
-
tacit
macro to make newtypes easier to create
-
shive
lightweight IOC service container writen for the Rust applications
-
tamanegi-error
detail of
tamanegi-errorcrate -
nype
Newtype helper macros for Rust
-
rvs
defining and evaluating random variables using a simple DSL
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
ref_wrapper
Wrapper of dynamically borrowed data
-
exec-rs
that provides utility traits for task execution and, if the sync feature is enabled, the ability to synchronise tasks based on the value of a key
-
og-enum-to-string
EnumToStringderive macro which implements the methodsas_str()andas_dbg()to enums with no associated values -
wintypes
that exports windows functions as types
-
rama-error
error types and utilities for rama
-
error-graph
Allows non-fatal errors in a tree of subfunctions to easily be collected by a caller
-
sod-mpsc
Service Oriented Design - Multi Producer Single Consumer
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
unwrap_or
Four easy unwrap Result and Option macros that allow for any inline-scoped code for things like return, continue, and break
-
plain_hasher
Hasher for 32-byte keys
-
orion_cfmt
Format output without Rust code segment in binary to reduce the ultimate binary size
-
smallnum
Compile-time size optimization for numeric primitives
-
custom_derive
(Note: superseded by
macro-attr) This crate provides a macro that enables the use of custom derive attributes -
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…
-
wrapnum
Ever wanted to make easy arbitrary number wraparounds? Now you can
-
algebloat
Rust linear algebra library
-
iter-progress
Calculate progress of your iterators
-
macon_api
builder macro-based generator with its own idioms
-
vec_to_array
Moves a heap allocated
Vec<T>to an stack allocated array of typeTand sizeN -
salsa-macro-rules
Declarative macros for the salsa crate
-
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
syntastica-queries
Collection of tree-sitter queries for syntastica
-
orchestrator
Orchestration sequences
-
zugferd-code-lists
ZUGFeRD code lists, e.g. languages enum, currencies enum, countries enum, etc.
-
once_cell_serde
Single assignment cells and lazy values
-
defer-lite
A lightweight high-performance implementation of Go's defer statement
-
aligners
alignment guarantees for data
-
enum-unit
Generates unit-variant enums from existing enums
-
mago-source
Manages PHP source files by providing functions for loading, reading, and referencing PHP code, making it easier to work with file-based inputs
-
state-shift
Macros for implementing Type-State-Pattern on your structs and methods
-
bint
Bounded Integer in Rust
-
match-commutative
Match on patterns commutatively, reducing the use of duplicated patterns. ↔️
-
cowstr
Copy-on-Write shared strings
-
genius-invokation
Abstractions and structures for Genius Invokation TCG
-
isr-macros
Macros for ISR
-
ambient-authority
Ambient Authority
-
pyo3_special_method_derive
Automatically derive Python dunder methods for your Rust code
-
itertools-num
Numerical iterator tools. Extra iterators and iterator methods and functions.
-
poison-guard
maintaining sane state in the presence of panics and failures
-
esync
This package contains some useful synchronization primitives
-
ilyvion-util
Collection of utility functions and types for use in my personal projects
-
openmls_rust_crypto
A crypto backend for OpenMLS implementing openmls_traits using RustCrypto primitives
-
tinydyn
A lightweight dynamic dispatch library
-
recall_entangler_storage
Distributed storage for uploading and downloading data
-
coded
concrete error type with an
ErrorKindenum matching Google’s “canonical error codes” -
tuple_split
An extension for the tupleops crate which adds a trait for splitting tuples
-
kx-utils
Common utils incubator
-
gur
A undo-redo framework
-
padder
Highly efficient data and string formatting library for Rust
-
effing-mad
The hottest algebraic effects library in Rust
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
mini-config
Minimalistic Dynamic Configuration Library for Rust
-
konst_macro_rules
detail of the konst crate
-
bounded-registers
A high-assurance memory-mapped register interaction library
-
normalize-line-endings
Takes an iterator over chars and returns a new iterator with all line endings (\r, \n, or \r\n) as \n
-
tao-of-rust
《Rust编程之道》随书源码
-
degeneric-macros
Hides struct generics into trait associated types
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
piston-float
Traits for generic floats in game development
-
task_pool
Flexible abstraction for task-based composable multithreading
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
annasul_macro
annasul: macro library
-
prc-rs
working with PRC types in Smash Ultimate
-
summum-types
A sum-type macro crate with all the conversions, accessors, and support for abstract methods across variants, and interoperability between sum-types
-
function_overloading
that adds function overloading
-
qm-utils
functions and macros
-
bty
Streamlined definition and usage of branded types in Rust
-
os-thread-local
OS-backed thread-local storage. This crate provides a
ThreadLocaltype as an alternative tostd::thread_local!that allows per-object thread-local storage, while providing a similar API… -
index-ext
Index slices with arbitrary ints and as arrays
-
multi-readers
Combining multiple readers
-
range-ext
Range intersection
-
cast_checks
A procedural macro to check for invalid casts
-
assert_matches2
A version of the assert_matches! macro that brings variables from the pattern into scope
-
nougat
(lifetime) GATs on stable Rust
-
frunk_laws
contains laws for algebras declared in Frunk
-
kurtbuilds_regex
Wraps the regex library to also provide macros
-
iterpipes
Compositional, pipes-style stream processing
-
eventmill
Event sourcing and CQRS for Rust applications
-
displaythis
derive(Display)
-
plectrum
An easy way to represent lookup tables in a db as rust enums
-
neoncore
Core utility library for working with binary data streams
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
twurst-error
Twirp error struct
-
chassis
Compile-time dependency injection framework
-
builder-pattern
A derivable macro for declaring a builder pattern
-
elvish
Overengineered Advent of Code framework - not quite Santa's elves
-
rusty-cmd
creating custom line-oriented command interpreters in Rust
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
market
Infrastructure for producers and consumers
-
mini-macro-magic
Export tokens to other modules and crates. Now with 100% less proc macros!
-
plexer
A Pattern-matching LEXER
-
init_array
Initialize arrays itemwise
-
lset
Data types describing linear sets
-
opentalk-types-signaling-livekit
Signaling types for the OpenTalk livekit module
-
prepeek
Peekable iterators without mutation
-
ohos-sys-opaque-types
Internal helper cratefor opaque type bindings that are used in multiple ohos-sys crates
-
eventually
using Event Sourcing in Rust applications
-
docify_clone
Docify allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples
-
pingora-error
Error types and error handling APIs for Pingora
-
panicking
std::thread::panickinganalog available in theno_stdcontext -
progress-streams
Progress callbacks for types which implement Read/Write
-
floating-ui-utils
Rust port of Floating UI. Utilities for Floating UI.
-
ty-tag
TypeId for lifetime containing types via type tags
-
derive_generic_visitor
Boilerplate for building rust visitors
-
bestbefore
A procedural macro for marking code with expiration dates
-
strpatmatch
string pattern matching
-
bitbag
A useful struct for dealing with bit flags
-
plain_enum
Mimicing Java's enum::values() and EnumMap
-
telecomande
A small crate providing a primitive for the execution of asynchronous tasks by processor through commands
-
coi
Dependency Injection library
-
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
shuriken-bindings
Safe bindings for the [Shuriken bytecode analyzer
-
nzliteral
Macro simplifying use of NonZero literals
-
snapup
Abstractions for handling snapshots with streams of subsequent updates
-
named-block
Macro implementing early-exit-from-any-block
-
safe_cache
A key-value cache library in Rust featuring dynamic typing with support for multiple data types, automatic expiration, and thread-safe operations using Arc and RwLock
-
utility-macros
emulate Utility Types and Unions from TypeScript
-
hyper_byte
An unsafe, near-zero cost (1-2 instructions) byte transmuter to numeric types with fast byte reader
-
kust
Kotlin-like APIs for Rust
-
minvect
A mini vector library
-
pigeon-core
Generate recursive-descent & precedence climbing parsers. (traits)
-
kstring
Key String: optimized for map keys
-
fsm_gen
FSM (finite state machine) DSL for code generation (c++ at the moment)
-
measures
A unit-of-measure and electrical calculations library
-
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.
-
pipa
Pipe Operator Library for Rust
-
control-flow
A hack to control control-flow outside closures
-
gz_lib
gz 的工具箱
-
lucchetto
easily call a rust function without holding the GVL lock
-
instruct-macros-types
Instructor Macro Types are a collection of simple types that we export to work with the instruct-macros crate
-
swiss-army-knife
Common utility code to support linux-support and other projects
-
maybe-borrow
Macros for conditionally returning borrowed data
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
pathogen
Typed references and deep mutation into Rust types
-
add_macro
more additional macros to help you write code faster!
-
skip-if
Attribute macro to skip running a function that produces files
-
quick-error
A macro which makes error types pleasant to write
-
singleton-manager
A programatical singleton manager
-
inherent
Make trait methods callable without the trait in scope
-
valued-enums
Macros collection and specify trait for creating valued or python-like enums
-
sendable
Rc and Option equivalents that facilitate sending data between threads
-
export-resolver
A PE (Portable Executable) parser which will dynamically resolve virtual addresses of functions loaded in a PE. It will store these function virtual addresses in a structure for retrieval at the developers behest.
-
chainerror
Make chaining errors easy
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
tower-sessions-core
Core types and traits for tower-sessions
-
the-string-macro
The missing
string!macro to constructStringvalue from string literal -
mli
Machine Learning Interface for Rust
-
samsvar
trait for matching on custom types
-
rs_transducers
transducers for Rust
-
unsafe_cell_slice
A microlibrary for creating multiple mutable references to a slice
-
filters
Build filters/predicates with the builder pattern
-
rusty-hkt
Higher-kinded types for Rust
-
relend
A generalized reborrowing mechanism that extends beyond simple references. It also allows for implementing traits that work with reborrowing for custom types.
-
saturating_add_assign
Convenience macro for AddAssign with saturating arithmetic
-
captur
Macro to capture whole structs from disjoint fields in a closure
-
min-max
max! and min! macros
-
mownstr
Maybe Owned String
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
ointer
Steal the high bits of a pointer to store an extra value
-
syscall_encode_traits
Traits and macros to help define a syscall interface for a kernel
-
test_eq
assert_eq!-like macros that return a Result instead
-
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!,include!, orconcat_idents!) -
air-macros
Macros for the TNJ Assembly Intermediate Representation (AIR)
-
racros
Collection of rust macros
-
objid
Generate a random object identifier
-
trot
Trait library
-
despatma
Design Pattern Macro like Loki
-
gann
Generic ANN
-
rsps_vergen_emboss
macro to emboss vergen-based environment variables into your binary, primarily for rsps support
-
nolife
open a scope and then freeze it in time for future access
-
copy_impl
Macro for effortlessly duplicating impl block code across various types in Rust
-
isclose
A collection of trait and macros for comparing approximate equality
-
srcerr
User friendly errors from source data
-
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
-
next_tuple
A trait to build and extend tuples
-
except
The only one
Error -
hurl_core
Hurl Core
-
warnalyzer
Show unused code from multi-crate Rust projects
-
libabort
A abort function that doesn't require the standard library
-
chalk-macros
Macros for Chalk
-
retrying
General-purpose retrying library for Rust with macros and functions
-
mantra-rust-trace
Collects requirement traces from rust code for the
mantraframework -
dare
daring flexible data representation
-
pm_rlua
Zero-cost high-level lua 5.3 wrapper for Rust. Some fixes for td_rlua.
-
dyn-ptr
A box that stores types like pointers, forgetting everything besides
Self: Unsize<dyn Trait> -
ebml-iterable-specification
base
EbmlSpecificationused by theebml-iterableandebml-iterable-specification-derivecrates -
json-query
Run jq programs to extract data from json strings
-
cherrybomb-oas
Cherrybomb OpenAPI Specification (OAS) struct and functions
-
has-some
The opposite of is_empty (and is_empty for filters)
-
rust_kafka_like
A Kafka-like message broker in Rust
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
flexi_func_declarative
exposes the fb! macro to create a function with a flexible signature
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
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…
-
mvutils
made from commonly used functions in my projects
-
lazy_link
proc macro for dynamic runtime lookup of external functions, supporting custom resolvers, caching and no_std environments
-
algar
Algebraic structures, higher-kinded types and other category theory bad ideas
-
high_mem_utils
bunch of mem safe abstractions,some involving transmute
-
array_trait
A generic trait for any array, with item as type and length as const parameter
-
stub-macro
stub!() is a better version of todo!() that can be assigned to a variable
-
flatty
Flat message buffers
-
defmac
A macro to define lambda-like macros inline
-
borrowme
The missing compound borrowing for Rust
-
serde_table
Write structs in an easy table format
-
traiter
Traits collection
-
async_fn_traits
Trait synonyms for “Fn[…]”-trait bounds returning futures
-
error-iter
Error::sources on stable Rust
-
edsm-dumps-model
Data models for EDSM dump data
-
naan
A fast, easy, and tasty functional programming prelude
-
multer-derive
derive for constructign type from multer Multipart
-
sumtype
Generate zerocost sumtype of iterators or closures
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
merge-hashmap
Merge multiple values into one
-
rual
A slim, embeddable language
-
korhah
A minimal & extensible reactive event system
-
hans-http
Writing a http request and http response safely
-
mudra
Currencies as distinct structs
-
irox-types
Enums and structs to describe Rust's basic type system
-
singleton-attr
singleton procedural attribute and derive macro
-
dev_utils
A collection of utilities for development
-
resolve-path
Easily resolve tilde paths and relative paths
-
battler-wamprat-error
Procedural macro for custom WAMP errors
-
nanvm-lib
NaNVM library
-
arcow
Atomically Reference-counted Copy-On-Write shared pointer
-
irox-structs
Traits for Struct Types - linearly serialized big/little endian bytes
-
fuck-backslash
replace the backslash with slash in-place in your PathBuf
-
better-as-any
Automatically makes your trait objects downcasting-capable
-
setjmp
/ longjmp support
-
apparat
A lightweight event-driven behavioral state machine
-
culprit
error crate with the goal of identifying precisely where and in which context an error occurs
-
cond
Rust macro to use a match-like syntax as an elegant alternative to nesting if-else statements
-
ffi-toolkit
A collection of functions useful for working with the Rust FFI
-
alua
generating lua lsp annotations from Rust types
-
aether_primitives
Helpers for common SDR and signal generation operations
-
combin-iterator
Some usefull facilities for combining iterators
-
shallowclone
Traits for working with copy-on-write types more efficiently
-
upgrayedd
Ergonomic function interposition in Rust
-
hrbf
Hermite Radial Basis Functions with higher order derivatives
-
num_bound
Add bounds fn to anything implementing
Ordthat bounds a number to a range -
bitmask
generator for enum scoped bit flags
-
hello-world-in-rust
Hello World!
-
isotest
Enables a very specific unit testing pattern
-
variadiz
Variadic function support for rust
-
bytify
macro that can write given const-expr values into a continuous byte array
-
cfgenius
Conditional compilation with macro support in Rust
-
typemap-meta
compile-time macro to create type-to-value maps
-
dirty-fsm
A quick and dirty state machine library
-
adhesion
A set of macros for design by contact in Rust. The design of this library was inspired by D's contract programming facilities.
-
indexed_valued_enums
Create enums resolving into values, and get their variants back through their values or their discriminant, inspired by Java
-
fu
Just an Error
-
sdl3-main
Tools for using SDL's main and callback APIs
-
jget
Rust tools
-
stak-primitive
Stak Scheme primitives
-
aorist_primitives
Primitive macros for the aorist project
-
trowel
Tools for writing HTML in Rust
-
anybytes
A small library abstracting over bytes owning types in an extensible way
-
dioxus-shareables
Hooks for sharing structures between components
-
aoko
extension library
-
digitize
Traits for accessing digits of primitive integers & floats
-
verbex
Vebex is a Rust library that provides procedural macros for creating regular expressions in a verbose and readable way
-
koute/nes
emulator written in Rust
-
arc_macro
A macro wrapper around Arc::new() for convenience
-
yikes-intenum
Augment integer-based enums with an unknown variant; a macro that makes you say "yikes!"
-
tracked
A stringly-typed Error that includes
#[track_caller]information -
swamp-script-semantic
semantic types for swamp script
-
teo-teon
Object notation for Teo
-
tt-toolkit
A collection of macros for rapidly prototyping programming languages
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
coercible_errors
Zero-cost error handling for generic traits
-
duplex
trait: interactive streams
-
dbus-strings
Rust native implementation of different D-Bus string types
-
rnet
Easily call into Rust from C# or other .net langauges
-
typle
Generic tuple bounds and transformations
-
typomania
A toolbox to check for typosquatting in package registries
-
tangu
language
-
stylish-core
The semver-stable subset of
stylish -
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
-
fn_zip
zip trait for functions, allowing two functions to be combined before being called
-
unwrap-macros
Convenience macro for unwrapping result and option
-
assert_unordered
A direct replacement for
assert_eqfor unordered collections -
libc-extra
Additional bits and bobs found in libc libraries that either hasn't been submitted to Rust's official libc crate yet, or has been rejected or requires too much work to integrate
-
tor-async-utils
Async/futures helpers for use with Tor
-
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
essrpc
RPC using natural trait definitions and calls
-
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…
-
tlkit
Tool Kit integration
-
derive-regex
Easily parse a regex into a struct or enum variant
-
to_snake_case
that transforms strings to snake_case
-
branch_hints
that provides likely and unlikely branch hint functions in stable Rust
-
libc-nnsdk
Rust bindings for the parts of libc exposed by nnsdk, intended to be a in-place replacement for standard Rust libc bindings
-
lazy_bastard
A helpfull macro because writeing a seperate Default function is too much effort
-
astro-notation
transcoding between Astro Notation Format and Native Rust data types
-
option-ext
Extends
Optionwith additional operations -
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
runestr
User-perceived characters related types and data structures
-
tugger-windows
Collection of packaging primitives specific to Windows
-
fixed-macro-types
Macro aliases used in the
fixed-macrocrate -
thread-scoped-ref
that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
yugen
Writing rust like python
-
kvlogger
human readable key-value logger
-
pooled-writer
using N threads to write to M compressed files/writers
-
prae
that aims to provide a better way to define types that require validation
-
unique-uuid
generate unique UUIDs
-
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.
-
maybe-uninit
MaybeUninit for friends of backwards compatibility
-
event-listener-primitives
Low-level primitive for building Node.js-like event listeners
-
getopts-macro
Using macros to concisely define the getopts
-
aliri_macros
Macros used by the
alirifamily of crates -
xxlib
Rust xxlib
-
delegare
delegate struct easy
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
no_std_strings
no_std version of crate fixedstr: strings of constant maximum size that can be copied and stack allocated
-
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
scientisto
A light-weight Rust implementation of the github/scientist library used for careful refactoring of critical code paths
-
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
dyn_struct
Construct dynamically sized types safely
-
godotdoc
documentation generator for GdScript
-
rtea
Makes writing Tcl extensions in Rust ergonomic
-
uints
Unsigned Integer Properties
-
almost
comparing floating point numbers
-
app-frame
Compile-time dependency-injected application framework with a service orchestrator
-
jsona-openapi
A openapi dsl in jsona
-
netherite
A tokio implementation of the Minecraft Protocol with derive macros
-
semantic-exit
Semantic exit codes inspired by HTTP status codes
-
prev-iter
Iterator which allows you to view the previous element
-
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 -
audiotags-dev-macro
macros used during the development of audiotags
-
essentials
essential utils for rustaceans
-
rspack_macros_test
rspack macros test
-
sod-crossbeam
Service Oriented Design - Crossbeam
-
switcheroo
Lightweight userland context switches
-
ir_aquila
personal utility library, not for public use(yet)
-
const-type-layout
Derivable const trait to view and compare the layout of a struct, union, or enum
-
cflp
A context-free-language parser generated by procedural macros
-
osu-file-parser
parse an osu! beatmap file
-
floxide-reactive
Reactive node abstractions for the floxide framework
-
defer-rs
Deferred execution Rust utilities
-
bp3d-util
template
-
stylo_traits
Vocabulary types for the Stylo CSS engine
-
shared-type
Shared type alias and several traits to simplify working with Arc<Mutex<T>>
-
softfloat-sys
Rust bindings for Berkeley SoftFloat 3
-
cstr-argument
A trait for converting function arguments to null terminated strings
-
micro_errors
deal with errors without taking the derive macro approach
-
databend_educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits, temporarily used in databend
-
enumeration
An extension to rust enum
-
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. -
handy_shortcuts
A handy toolbox for things like substring finding, working with indexes and other string manipulation things
-
inter-struct
Automatically generated traits for arbitrary structs
-
box-dyn
Macro to derive the implementation of Trait for Box<T: Trait>
-
tailsome
Blanket traits providing
.into_ok(),.into_err(), and.into_some()for happier method chaining -
wrappr
A libary for some useful wrapping traits
-
hado
Monadic do notation using a macro
-
livre
type-safe PDF parser
-
wx-core
微信数据解析工具
-
range_check
bounds-checking and range helpers
-
audiotags-macro
macros used during the development of audiotags
-
mixed-num
A trait for generic implementations of numerical methods
-
ez-err
error handling library with support for ergonomic and fast error handling
-
standback
New standard library, old compiler
-
matr
A metaprogramming library for Rust
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
axocli
common code for setting up a CLI App and handling errors/printing
-
closure_example
A short description of my package
-
ffizz-passby
FFI helpers for implementing pass-by-value and pass-by-pointer
-
eldenring-util
Implement common helpers for Elden Ring modding
-
enum_to_enum
Derives possibly effectful conversions between enums
-
lazyinit
Initialize a static value lazily
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
env-flags
A convenience macro for declaring environment variables
-
oc-hook-macros
Some convenient macros for hooking Objective-C functions
-
finite_repr
Isomorphic encoding/decoding data to & from numbers
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
adventage
Advent of Code, easier!
-
squeak
providing types allowing execution of callbacks in response to values being broadcast or mutated
-
lyneate
beautiful code underlining and error reporting
-
enum_delegate
Easily replace dynamic dispatch with an enum, for speed and serialization
-
ptrplus
Additional funtionality for pointer types
-
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
macro_lisp
Lisp-like DSL for Rust language
-
nonicle
Tools for type-safe, canonical data representations
-
consclr
console text colorful
-
macro-utils
Some macros to make code writing more elegant and funny
-
macroland
macro shorthands of various types in Rust
-
cantor
A general toolkit for working with types that have a small number of values
-
rubber_duck
Enables building functions that can be called with named arg syntax
-
structmap
Procedural macro library for converting between Rust structs and associative containers
-
serde-textual
derive Display/FromStr by using serde
-
standard_test
A set of tests checking the properties of your impls of std traits
-
enumcapsulate
Safe casting for newtype enums and their variants
-
cynic-proc-macros
Procedural macro crate for cynic - a code first GraphQL client for Rust
-
menu_genie
Multi-level terminal menu library
-
uwuizer
Rust Macro to UwUize your text. UwU.
-
dims_macro
Macros for Generating Systems of Units
-
tch-tensor-like
Derive convenient methods for struct or enum of tch tensors
-
hxdmp
A small utility to create hexdump output from byte slices
-
specler
way to write specifications on values
-
zero_v
implementing iterators over function outputs for collections of types implementing a common trait, without using vtables/ dynamic polymorphism
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
scanfmt
easy to use macro for parsing a string
-
peeking-iter
An iterator adapter that allows infinitely-deep peeking
-
lachs
automatically creating a lexer based on a given enum
-
standalone-proc-macro2
Fork of proc-macro2 that uses rustc-ap-proc_macro so as to remove the rustc dylib dependency
-
grouping_by
allows the user to group an iterator by various ways
-
impl-opaque
Macro for declaring complex struct and initializer
-
nanopre
A a zero-dependency, no-unsafe implementation of a minimal C-style text preprocessor
-
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
-
brazier
A mediator implementation in Rust, heavily inspired by the .NET MediatR package (https://github.com/jbogard/MediatR)
-
mogrify
macro for autogenerating a “Parse, Don’t Validate”
TryFromimplementation for structs -
enum_pipeline
way to use enums to describe and execute ordered data pipelines
-
cbsk_mut_data
ref mut tool
-
permeable
A permission-demand trait. Decouples the permission-demander from the permission / auth provider.
-
in
Python's input() for Rust
-
nano_parser_gen
A parser generator inspired by yacc (types and functions)
-
rsfindlibs
Find shared libraries in the system and provide a useful macro to load them
-
dbg_unreachable
Switch between unreachable! and unreachable_unchecked with a single macro
-
valid8
no-nonsense validation library
-
bilk
Miscellaneous convenience functions and traits
-
famedly_rust_utils
Random rust utility functions and types
-
enum-to-string-traits
EnumToStringderive macro which implements the methodsas_str()andas_dbg()to enums with no associated values -
tokio-inherit-task-local
Task local variables for tokio that can be inherited across a spawn
-
shorter-bounds
Write shorter bounds with a trait alias macro
-
tiny_bail
Small but flexible macros for bailing on failure
-
benri
Convenient macros wrapping the standard library
-
name-it
Give a name to async fn return types
-
will_exit
work on program will exit
-
unocss-classes-utils
Utils for
unocss-classes -
patched
Macro for patch like structure
-
typedopts
Type aware command line parser
-
multindex
Index slices with multiple const indices/ranges
-
sql-table-macros
Helper macros to generate SQL table definitions
-
rs-category
Categorical traits
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
destruct
structs and enums for simpler combinator implementation
-
rem-verification
Verification tool for the REM toolchain. Built to be implemented into the VSCode extension for REM. Relies on AENEAS and CoQ
-
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. -
place_macro
Macros you wish you had while you were writing your non-proc macro
-
sod-bus
Service Oriented Design - Single Producer Multi Consumer
-
single_executor
Traits for concurrent primitives
-
iter_peek_end
current element the last one of a peekable iterator ? (
is_last()andis_not_last()) -
nyar_valkyrie
-
lurk-ipld-macro
lurk-ipld macro
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
thin_delegate
Auto implementation of trivial delegation to inner types
-
stackerror
A pragmatic error handling library for Rust that provides helpful strings for debugging, and structured data for runtime error handling
-
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
imgref-iter
A small crate for iterating over the rows or columns of
imgrefbuffers -
ddd-rs
Domain-Driven Design (DDD) building blocks, for Rust applications
-
tram
event bus that can be cloned and shared across threads
-
rsb_derive
An opinionated macro implementation for Rust struct builder pattern with compile-time validation
-
num-sign
enum Sign { Positive = 1, Negative = -1 }
-
enum_macro
Useful macro for enum
-
dir-assert
Assertion to compare directories recursively
-
readonly
Struct fields that are made read-only accessible to other modules
-
sly_static
Seamless Rust Static Initialization: Effortless and Efficient
-
eager
macro expansion
-
wrapping-macro
wrapping macro
-
classes
Dependency-free macro that simplifies the process of building class strings for DOM elements
-
tl_list_lib
Type-level kinded heterogeneous list for type-level programming in Rust
-
supply
Provider API for arbitrary number of lifetimes
-
laxcow
Clone-on-write smart pointer with relaxed trait constraints
-
ident-util
macro to determine the string name of a binding, type, const, or function
-
element-ptr
A macro to make accessing elements through raw pointers easier
-
ferrisume-domain
The domain entities for the ferrisume CLI tool
-
exponential-backoff
An exponential backoff generator with jitter
-
kmacros_shim
Useful macros
-
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
arrays
Construct an array from an iterator
-
static_assertions_next
Compile-time assertions to ensure that invariants are met
-
binary_modifier
read & write to buffer
-
gull
type generation
-
mapcomp
Python-like list comprehensions for standard containers
-
printc
Print-clean macro. Like
println!but cleaner input. -
disuse
The way to notify the implementation which return value is disuse
-
tryiter
functions for Iterators of Results
-
ip-family
IP family enum with functions to get special ips of the right family
-
gitoxide-core
implementing all capabilities of the gitoxide CLI
-
veccell
variant of Vec with interior mutability
-
as-is
An abstraction over ownership
-
curerr
easy error handling
-
oop
Object-Oriented Inheritence in Rust
-
divide_slice
methods to divide a slice into portions of same size
-
bronzeflow
Bronze: A workflow scheduler in rust
-
projecture
Easy arbitrary type projections without proc macros
-
whiskers-widgets
Dynamic UI sub-system for whiskers
-
wgsl-types
WGSL Types
-
ghost-lite
custom PhantomData types
-
const-exhaustive
Enumerate all values of a type at compile time
-
tcp-struct
Share structs over tcp
-
yansongda-utils
rust 中一些关于我自己的常用工具
-
sapper_std
Wrappers for rapid coding for sapper web framework
-
peekable-fwd-bwd
Iterator Peekable with multi-forward-peek and multi-backward-peek
-
quark
Types for manipulating numeric primitives at the bit level
-
opentalk-types-signaling-moderation
Signaling types for the OpenTalk moderation module
-
intfloat
Fast and simple hashable float alternative using ints
-
nanokit
A collection of tiny, reusable utility methods that reduce code size and improve performance
-
bidir_iter
Bidirectional iterators
-
pluck
Extract values conveniently
-
non-empty-str
Non-empty strings
-
primitive-from-enum
macros for get primitive enum from complex
-
fast-concat
Fastest macro for concatenating strings
-
bittorrent-primitives
collections of basic types for BitTorrent projects
-
brug
enum command generation for implementation blocks
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
error_status
Model common error context with HTTP 4xx and 5xx code
-
rust_c
Write C code inline in your rust code (hacky fork of rust-cpp / cpp crate)
-
object-id
Unique object ID with no generation
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
axum-typed-routing
Typed routing macros for axum
-
tartan-bitfield
Define structures with accessors for particular bits or bit ranges
-
doless
macro to simplify struct mapping and function utilities
-
data_models
used to lookup the sizes of various C-types of historical data models
-
const-chunks
Extension trait to chunk iterators into const-length arrays
-
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)
-
typestate-builder
Derive-macro-based generator that combines
TypestateandBuilderpatterns -
timed
Macros to time function execution
-
std_io_iterators
An iterator for
STDINand a wrapper forSTDOUT. Allows easy piping, and graceful closing of application if pipe breaks -
oxydized-money-macros
Companion library to oxydized-gains providing convenience macros
-
type-handle
Regular and reference-counted type handles
-
scoped-thread-pool
A flexible thread pool providing scoped threads. Updated fork of https://github.com/reem/rust-scoped-pool
-
hereditary
Procedural macros for emulating OOP Inheritance in Rust
-
valq
macros for querying and extracting value from structured data by JavaScript-like syntax
-
casual
parsing user input
-
mashin_sdk
SDK for writing mashin resources
-
error_mancer
Quickly define custom error enums for a function
-
spawn_timeout
Call a subroutine after a constant time interval
-
wurm
Non-fatal, strongly typed errors
-
repeated
Allows you to repeat a block of code a number of times
-
influxdb-client
Rust client library for InfluxDB v2
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
hcstatic-str
compact storage for short static strings
-
async_pipeline_for_lucas
Easy way to pipeline sync and async functions
-
x-bow
Precise State Management Library
-
scout-audit-dylint-linting
writing Dylint libraries
-
persian-rug
Framework for bringing together disparate objects with inconvenient relationships
-
pisserror
A golden rip-off of thiserror
-
rustils
Utilities for rust
-
unroll_range
Repeats a block of code for each number in a specified range
-
metacrate
Metadata for crates
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
env-var
Macros providing easier access to environment variables in rust
-
deferred-box
Defer the value set after the struct has been initialized
-
html5ever_macros
High-performance browser-grade HTML5 parser − compiler plugins
-
tiny-ordered-float
Tiny version of OrderedFloat
-
pyderive
Derive macro of Python special methods and a class attributes for PyO3
-
xdi
Rust di containers system
-
pi_null
define trait is named Null. u8,u32,u64,Option...is implements Null
-
anyerr
Dynamic error library with rich error wrapping and context support
-
overloadf
unlock function overloading for rust
-
type-variance
Marker traits for subtype variance
-
chisel-common
Chisel common macros, types and functions
-
write-to-file
Write to a file, simple helper fn and traits lib crate
-
tokio_interval_buffer
Easy enum wrapper that implements all traits that the wrapped objects implement
-
iter-n
functions returning impl Iterator to return one of several distinct types
-
lockstep
An iterator adaptor for selective zipping
-
fix_me
A very simple macro that lets you write temporary code that WILL NOT build in release mode
-
gilder
Golden testing library
-
derive-prom-metrics
Build Prometheus metrics declaratively as structs
-
rsor
Reusable slice of references
-
wrapping_macros
A macro for wrapping arithmetic
-
formy
derive macro to turn structs into html forms
-
vec_vec
When dealing with
Vec<Vec<T>>is unavoidable -
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.
-
extent
replacement for std::ops::{Range,RangeInclusive}
-
avr-libcore
Minified version of libcore for AVR
-
ptrscan
Pointer chain scanner
-
postgres-mapper
Struct mapping for postgres
-
error_def
syntax extension for generating error-handling boilerplate code
-
tenacious
[RETIRED: Will not work with MIR] A plugin to prevent certain types from being moved
-
enum_primitive
Macro to generate num::FromPrimitive instances for enum that works in Rust 1.0
-
darkly
scanf-style scanner
-
typesets
Enables generating subtypes and supertypes of a given type via derive macros
-
match_any
declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
ari
ari. the extras library.
-
qcontext
One-time initializable static state with statically-checked zero-cost interior mutability
-
iterator_item
a generator syntax experiment
-
todo_using
A super small crate only exporting a single macro to "use" parameters
-
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… -
trey
Writing V3000 CTfiles
-
golangify
published at 01.04.2024 this crate brings familiar flavor for newcomers from golang
-
easy-min-max
Easy to use macros for min, max and clamp. Works with no_std
-
itermap
Iterator tools for maps (
HashMap,BTreeMap, etc.) -
once
assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
yadi
Dependency Injection framework for writing applications with Rust programming language
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
interruptor
Collection of functions generating Unix process signal receivers for use in the Crossbeam Channel select! macro
-
wtflip
A language in a Rust macro... or something.
-
murrelet_src_audio
audio input functions for murrelet, a livecode framework
-
winit-main
Abstract away winit's event-loop inversion of control
-
btl
shell scripting in rust. Github Repo: https://github.com/znx3p0/btlsh
-
cew
Personal Rust utility library
-
lup
A custom indexed loop macro library for Rust
-
tryvial
Small crate for ok-wrapping and try blocks
-
smurf
SMall Useful Rust Functions
-
token-ref-cell
Interior mutability cell using an external token to synchronize accesses
-
smol_buf
small-string optimized string / buffer type with O(1) clone
-
diffuser-edit
Edit diffuser models without GPU and Python
-
target-test-dir
A proc-macro attribute for providing test-specific directories
-
simple-undo
Easy to use undo-redo library
-
schemafy_snapshot
Snapshot for bootstrapping the schemafy crate
-
u7
dotnet's 7bit int in Rust
-
simple-dmenu
macro to call dmenu
-
list_comprehension
A macro for Haskell-like list comprehensions in Rust
-
hex-slice
Extends the std::fmt::*Hex traits to slices
-
throwing
Create explicit errors easily with a handy macro
-
dav1d
libdav1d bindings
-
defvar
A macro that makes defining environment variables easy
-
vec-utils
vector utilities
-
another-visitor
Lets you derive visitor pattern implementations
-
dyn-error
Error-related utilites for Rust
-
sophia_indexed
toolkit for RDF and Linked Data - Utility traits and functions for index-based implementations of graphs and datasets
-
unwind_safe
Readable unwind-safe code thanks to a try-finally-looking builder pattern
-
smartcow
a cow for smartstrings
-
cell-project
Safe interface for cell projection
-
cryo
Extend the lifetime of a reference. Safely.
-
codespan-derive
derive(IntoDiagnostic) for easy codespan integration
-
light_arena
A lightweight, placement based memory arena for types which are Sized + Copy. This crate requires nightly.
-
size
expressing, formatting, and interacting with file sizes
-
marker_trait
Implement a blanket implementation for a marker trait
-
kix
A result type for testing that supports to eliminate using of Result::unwrap
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
option-cell
OptionCell: OnceCell but derivable from Option
-
inline_default
Macro for inline Default implementation
-
nonasync
A set of utilities useful for building a non-blocking non-async APIs
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
loop-let
An immutable loop structure that can be used as an expression
-
fluid-macro
Write long method chains as a series of steps instead, and more!
-
str_crypter
A macro library for XOR encryption and decryption of strings at compile time, meaning no cleartext strings will be in your release binary (when using the macro). The encrypted strings will be decoded at runtime.
-
extension-eyre
Re-export of color-eyre that introduces Extensions (type-map) to eyre::Report
-
iban_validation_rs
Facilitate validation of ibans and selecting Bank identifier and Branch identifier in Rust
-
flip-flop
implements the flip-flop operator from Perl and Ruby as a Rust macro
-
ministark-gpu
GPU optimized primitives commonly used by STARK/SNARK provers
-
rusty-peg
A macro for defining PEG parsers
-
typestate
A proc macro DSL for typestates
-
pack1
Byte array newtypes for different primitive types
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
ever
Print the build information of your program with minimal boilerplate
-
i-codegen-code
Common tools supporting the
derive-codegencrate -
simple-triple-buffer
triple buffer
-
drop-bin
Defer running expensive destructors until later
-
vm6502
A 6502 virtual machine backend
-
pattern_code
Given a path patterm matched source code
-
fallback-if
Fall back to an alternative given some predicate
-
rtlola-reporting
An error reporting crate for RTLola-related crates
-
partial-borrow
Partially borrow a struct
-
string-eyre
Convenience traits for dealing with errors that don't want to eyre
-
std_nightly_to_stable_3db085279c83
-
nanoval
A nan-tagged value for representing f64, i32, u32, booleans, null and arbitrary pointers
-
nofmt
nofmt::pls, a macro that does its best at preventing a code block from being mangled -
retry-block
retry operations that may fail with configurable backoff behavior using macros over blocks of code
-
ratelimit_rs
The ratelimit package provides an efficient token bucket implementation
-
oneline-eyre
A fork of
simple-eyrewhich outputs errors on a single line -
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
overloaded_literals
Overloaded Literals to construct your datatypes without boilerplate and with compile-time validation
-
math-jit
Compile arithmetic expressions to native code
-
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
azucar
syntax sugar
-
timed-locks
Smart pointers to
tokio::synclocks that either panic or error after a timeout -
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
macroquest
Write MacroQuest plugins in Rust
-
ez_jni
Macros and functions that make using Java in rust feel natural
-
regexm
macro for writing regex pattern matching
-
async-wormhole
Async calls across non-async functions
-
msiz_rustc-ap-rustc_errors
Automatically published version of the package
rustc_errorsin the rust-lang/rust repository from commit 74d5c70b174f06843049af2d764ff57ddc81c81c The publishing script for this crate lives at: https://github… -
csharp_binder
generate C# bindings for a Rust foreign function interface (FFI)
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the *relative* difference
-
multi_stack_queue
Abstraction layer for a stack-allocated multi-queue with bounded length. WIP
-
string-join
A python-like way to join items in an iterator with a separator
-
similar-structs-macros
Quality-of-life macros for more concise struct/enum definitions
-
ad-hoc-iter
Ad-hoc exact size owning iterator macro and other optional utils
-
writeable
A more efficient alternative to fmt::Display
-
nesty
Generate code with with human readable indentation
-
python-packaging
Python packaging primitives implemented in Rust
-
rusty-typesh
A flexible type pattern matching system for Rust
-
colourado-iter
A small and minimalistic library to generate a random color palette of infinite size
-
conditional-assignment
very simple, small crate to help make conditional assignments more ergonomic
-
rust-enum-derive
(and program) for generating rust enums and associated traits from text files
-
unwrap_todo
Option::todo and Result::todo methods
-
mqtt_macro
MqttItem trait, that helps with defining topics and json payloads for MQTT broker usage
-
mathelogos
as a functional programming language
-
nade
Adding named and default arguments to Rust functions
-
fold-license
Folding licenses from multiple dirs with
cargo/Cargo.toml andyarn/package.json -
retryiter
A wrapper lib on top of rust Iterator with added retry support
-
scroll
A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
structmapper
help you generate code that mapped one struct to another
-
os_str_bytes
Lossless functionality for platform-native strings
-
aranya-buggy
A less panicky replacement for unreachable!() and unwrap
-
interpolate
form of string interpolation
-
ehttpd-querystring
comfortably handle HTTP query string within
ehttpd-based applications -
shoogah
Add some syntactic 'shoogah' to Rust
-
retry-policy
Retry Policy
-
fastperm
A dead-simple, extreme fast permission flag system for Rust with no dependencies
-
generic-vec
a vector implementation that can be used in
no_stdenvioronments -
const_unit_poc
Proof of Concept: Physical units through const generics
-
validus
A string validation library
-
shared_singleton
trait provides singleton pattern state management with shared container
-
these
A three-way enum capturing This, That, or Both. Inspired by the Haskell package https://hackage.haskell.org/package/these
-
og_fmt
The original
format! -
never-say-never
The never type (the true one!) in stable Rust
-
ownit
Easily turn borrowed type into owned values
-
self-reference
Helper
-
cron_macro
cron macro
-
sbse
skylar's simple errors
-
async-reply
handle typed messages and replies
-
option_into_controlflow
Option into ControlFlow conversion
-
comparator
A Java-like Comparator type
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
xselfref
Fork of the selfref library, with some additions
-
rs-flow
Create flows to execute based in components created and yours connections
-
components-arena-traits
Does not intend for direct use
-
new_type
Experimental implementation of newtypes by type level logic
-
cgp-component
Context-generic programming core component traits
-
materially
A macro for material implication
-
global-errors
sinsegye test runtime global errors
-
locenv
aid on module development for locenv
-
stackstack
A singly linked list intended to be chained along stack frames
-
destructure_traitobject
Unsafe helpers for working with raw trait objects. (Forked from traitobject)
-
tri_ton
A Macro for Handling Exceptions
-
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
-
descriptive_toml_derive
Procedural derive macro for serializing a struct into a TOML template with field descriptions that is easily edited and deserialized
-
binder
zero-dependency property-binding framework
-
bherror
TBTL's library for error handling in Rust
-
tugger-snapcraft
Snapcraft packaging primitives
-
buffer
Safe, write-only, generics-free buffer abstraction
-
nan-tag
NaN-tagged pointers in Rust, storing an f64 in the same space as a pointer
-
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) -
ffd
Fast Function Dispatch: Improving the performance of Rust's dynamic function calls
-
morphism
A structure for suspended closure composition in Rust
-
rco_utils
Shared functions for "Remote Code Execution"'s (RCO's) binaries
-
value-bag-serde1
detail for value-bag
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
panic-room
An experiment in panic handling with setjmp/longjmp and arenas
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
eater_rangeset
work with set's of ranges
-
rustico
Rust programming, in Spanish
-
checked-float
making invariant-enforcing floating point wrappers
-
zkp-logging-allocator
Wrapper around the system allocator that logs large allocations
-
sized-dst
Owned container for dynamically-sized types backed by inline memory
-
lateinit
Unsafe late-initialization for statics
-
columnation-master
An experimental columnar arena
-
tinybuf
Container for many types of immutable bytes, with optimisations for small arrays
-
tuplemagic
manipulating tuples through various operations like mapping, filtering, nesting, and reducing
-
quick-error2
A macro which makes error types pleasant to write
-
negative
impls in stable Rust
-
abstract-impl
Create abstract implementations for traits
-
fix-rat
A rational number type with fixed denominator
-
wgpu_bind_dsl
An experimental macro dsl for describing Bind layouts in wgpu-rs
-
repository
all kinds of entities
-
mapper-api
Api of the
mappercrate -
internal
fields in Rust
-
throw
Efficiently add statically-calculated stack traces to errors
-
lambda-types
Puts the lambda calculus in Rust...'s type system
-
easy_error_core
Core error type for easy_error
-
rusty-cheddar
automatically generate C header files from Rust source files
-
realbox
The real copyless box
-
tagged-pointer-as-enum
A set of structs, traits and macros to implement tagged pointers
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
fmterr
Sane error reporting that just works
-
en
The easiest numeric traits!
-
assure
macros for Rust runtime checks and error handling
-
seasick
FFI-safe nul-terminated strings with ownership semantics
-
simple-version
The easiest way to manage versions in rust
-
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
-
zonbi
Type-Erase tools for non-
'statictypes -
wiwiwiwiwiwiwiwiwiwi
declarative macros for wiwi, a library, of, Stuff™ (implementation detail; do not depend on this crate directly)
-
lens-rs
lens implemented in rust
-
strdeser
A struct serializer for rust empowered with a macro
-
libmw
constructing a pipeline of middleware functions
-
multi_try
Safely combine results
-
assemblist
Define your builder patterns as you use them
-
handlevec
Small abstraction over index-style iteration over a vector, with deletion, insertion, and other operations on the vector while iterating
-
declarative_type_state
A collection of declarative macros to reduce boilerplate code when implementing type-state patterns
-
birds
Combinators using Rust macros
-
tlns-google-oauth2-traits
A bunch of traits for
tlns-google-oauth2-traits -
color-core
Color shared definition
-
symbol-ty
generating symbols as type-level strings
-
cargo-toml-macros
Convinient macros for pulling fields from your Cargo.toml. Prettier than std::env
-
string-utility
substring implementation (with the RangeBound trait), keep string before or after a specified string, etc
-
try-drop
Batteries included error handling mechanisms for drops which can fail
-
str-macro
The str!() macro, similar to vec![] but for strings
-
reinterpret
Low level utility functions to reinterpret arrays of data
-
advance-iter
A small crate to help with "stepping through" iterators
-
dmv
identity values that are restricted to user-specified scopes
-
stack-tokens
stack token implementation for convenient TLS borrowing
-
loop_chain
Macro for writing nested Loop expressions
-
maybe-uninit-ext
Extended maybe-uninit types
-
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
constructor-lite
Generate minimal constructors for structs
-
invade
reflect on Rust types and generate code
-
rig-dyn
A dynamic client-provider abstraction framework for Rust applications on top of rig-core
-
fastpeek
A different way to peek iterators
-
rustbench
A lightweight Rust procedural macro for benchmarking function execution time
-
with_capacity_safe
A safer alternative to Vec::with_capacity with into_raw_parts which can be used from stable
-
enum_derive
macros for deriving additional functionality for enums
-
path_semantics_std
type checked implementation of the standard dictionary of path semantics using constrained functions
-
objectionable
storage of unsized types inline inside allocated objects
-
bump-into
a no_std bump allocator sourcing space from a user-provided slice
-
displaydoc-lite
Implement the Display trait using your standard doc comments
-
ejni
working with JNI more pleasant
-
rassert-rs
macro for expressing Result-returning assertions
-
switch_statement
switch statement macro
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
near-safe-cell
A more ergonomic 'UnsafeCell' wrapper/replacement
-
dynamic-dispatch
Allows compiling generic functions that do not have generic parameters inside a library, specifying all the possible specializations for each generic type
-
fieldx_plus
Design patterns built on top of fieldx crate
-
monitor
synchronization construct
-
escher
Self-referencial structs using the async/await transformation
-
bloc
A state management library
-
flipflop
Stress-tester for double-ended iterators
-
peekable_next
An extension for Rust iterators to peek at the next element without advancing
-
tuple_list
macro-free variadic tuple metaprogramming
-
humane_commands
Allows you to write more shell-like Commands
-
qbdi-sys
QBDI library rust binding (use rust bindgen)
-
ez_jni_general_utils
General utility functions and data that are common for the ez_jni crate, its macros, and its tests
-
applying
Apply functions in method-position
-
bidirectional_enum
Automatically generates conversions between an enum type and any other type
-
flow-control
Declarative macros for common flow-control use cases such as break, continue, and return
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
cudd-sys
Bindings for CU Decision Diagram library (CUDD)
-
runtime-contracts
Structured, understandable runtime contracts
-
thiserror-nostd-notrait
derive(Error)
-
rstgen
Even simpler code generation for Rust
-
fluent_builder
builder API
-
dec-number
Decimal Floating Point Arithmetic for Rust
-
interning
Thread-Lcoal and Global Interning Library
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
fmap
Functors in Rust
-
staged-builder
A proc macro which generates staged builders for types
-
hatch_result
A result-like struct that returns on Ok, instead of on Err when ? operator is used
-
aprox_eq
determining aproximate equality between floating point types and deriving this capability to structs comprised of floating point numbers and other implementers of
AproxEq -
ra_ap_ssr
Structural search and replace of Rust code
-
type-uuid
Safe, stable IDs for Rust types
-
byteorder_slice
Byteorder like crate for &[u8]
-
schemars-zod
A few functions to aid Zod schema generation from rust types annotated with schemars
-
cxx-symbols
detail of the
cxxcrate -
derive_constructors
Deriving From, TryFrom and create new_with_*args* functions
-
macro_error
A macro to display error message
-
has_fields
Some macros helpful for processing forms with optional fields
-
apply_attr
A syntax extension providing higher-order attributes to Rust
-
partial-default
PartialDefault, a trait similar to Default but with fewer guarantees
-
typederror
A wrapper around anyhow that allows for a primary error type
-
nstd_core
NSTD core crate
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
iota-rs
macro for other Go refuges who miss const blocks and iota
-
tpfs_logger_port
A generic interface definition to support logging
-
notzero
macro for constructing
std::num::NonZero*from constants -
typed_macros
Adds typing to your macro's arguments, making it a lot less of a pain to deal with them
-
argcall
Enables enums and structs to be callable by associating functions with their variants or fields
-
splop
Helper functions to determine the first/last repetition of something
-
rust-hl7
HL7 Parser and object builder? query'er? - experimental only at any rate
-
fancy-default
A better
derive(Default)implementation -
oxidd-core
Core traits and types of the OxiDD decision diagram framework
-
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
phantom-enum
macro library for creating phantom enums
-
io-read-line-prototype
Prototype for io::read_line
-
input-macro
No-nonsense input!(...) macro for Rust
-
byte-mutator
define staged mutations for a series of bytes
-
laby_common
Shared code required by laby
-
fuzzypath
Quick & dirty fuzzy path comparison
-
jnt
full of just neat things
-
concat-string
macros for concatenating string slices into owned strings
-
methods-enum
Two macros for easy implementation of 'state' design pattern and other dynamic polymorphism using enum instead of dyn Trait
-
endian_trait
A trait for Endianness conversions that can be implemented on most types
-
context-iterators
Iterators adaptors with associated read-only data
-
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 -
peak-result
trait that extends the standard Result enum to allow you to run some code in case of error or success
-
racer-interner
thread-local string interner for racer-rust
-
rustcomp
Adds vector, map, set, and iterator comprehensions to Rust
-
ruroonga_command
A tiny Groonga query builder and generator
-
sqler
way for writing SQL queries using some of Rust syntax
-
haz
A thin abstraction over polymorphic environments
-
cargo-toml-builder
A builder for generating Cargo.toml files
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
pluginop-rawptr
Safe abstractions atop raw pointers
-
tupperware
Storage traits for your types
-
simple_detailed_error
Stack and specify errors explainations saying what happened, why, how, where, how to solve it and its causes
-
rw-exact-ext
Extension of std::io to read and write data types with exact amounts of bytes
-
vjoule_api
API for vjoule
-
from_bytes_or_zeroed
Reads integers from an arbitrary slice of bytes
-
rustc_utils
working with the Rust compiler
-
inew
Macroses for constructor generation
-
fungus
reduce code verbosity
-
source-chain
Formats StdError with it's source chain
-
adhocerr
construction of efficient single use static/dynamic error types per callsite
-
impl_ops
Macros for easy operator overloading
-
atruct
macros for anonymous structs in Rust
-
flaky_test
atttribute macro for running a flaky test multiple times
-
selfref
Semi-pain-free self-referential pinned types
-
lifted
Higher-kinded types in Rust
-
id-ish
Numeric ID types that can be swapped in & out
-
kv-derive
Derive struct conversions from and to key-value vectors
-
truthy
Check if a value is "truthy"
-
objective-rust
Seamlessly bind Rust and Objective-C code
-
prctl
This package provides safe abstraction to the linux prctl() interface. Some functions may be architecture-specific.
-
structural
Field accessor traits,and emulation of structural types
-
common_macros
common macros like
hash_map!orhash_set!(WIP) -
singleton-trait
Singleton trait for types with unique values and Erased type for zero-sized ownership proofs
-
impl-converter-helper
declarative macro library to help you implement the
FromorTryFromtrait for your type -
surrealize
A procedural macro for generating helper struct variants for use with SurrealDB
-
sortby
adds convenient sort functions for Iterators
-
compiler-builtins-snapshot
Snapshot of the compiler-builtins crate
-
rexpr
Rust Json Object access Runtime
-
mago-interner
A string interning library that stores and reuses identical strings efficiently, improving memory use in large codebases or tools
-
terminal-clipboard
a minimal cross-platform clipboard
-
cex
Checked exception simulation
-
strunemix
allows to build a struct with a form of its fields, by deriving enums of them
-
frayed
Unfused and unashamed iterators
-
argley
Turn a struct into arguments for a
Command -
rich-result
Rich result type differentiating between recoverable & fatal errors
-
pyspark-arrow-rs
Derive macros to be used to add some helper functions to Rust structs to make them useable in Pyspark's mapInArrow
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
redox_simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
fstrings-rust
Python3 fstring interpolation in Rust
-
proptest-recurse
Helper for defining mutually recursive strategies with proptest
-
vec_split
Splits arrays of vectors into arrays of items
-
lox_utils
General helpers used by Lox
-
commandspec
Rust macro to build std::process::Command objects with shell syntax. Uses macro_rules! and works on stable.
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
butcher
An easy way to interact with structs and enums wrapped in Cows
-
helper
provided some useful proc macros for Rust
-
getfn
generating function pairs to refer to functions via custom expressions
-
kind-parser
Parser for the kind compiler
-
topset
Top N selector
-
tapir
Adding tapping functionality to rust
-
flexible-io
Wraps values such that dyn-safe IO traits need not appear as static bounds
-
opentalk-types-signaling-breakout
Signaling types for the OpenTalk breakout module
-
uninit-tools
that allows working with uninitialized memory entirely in safe code
-
yadir
Dependency Injection Registry for Rust
-
common_regex_rs
Set of common regex for Rust
-
rs-std-ext
An extension for the standard library
-
refid
Newtype enabling identity comparison (e.g. through pointer equality)
-
cute
A macro for Python-esque comprehensions
-
kvtree
Heterogenous in memory key value tree storage
-
not-so-fast
data validation with derive macro
-
untrusted_value_derive_internals
aim to provide a type-safe way to handle and sanitize potentially untrusted values like user input
-
aspect
Toolkit for Rust
-
defunctionalize
Defunctionalization as a proc-macro over modules
-
controlled-option
Custom Option type with explicit control over niches and memory layout
-
phantom_newtype
Lightweight newtypes without macros
-
as-result
Traits for converting types which may be interpreted as or into a result
-
quick_io
facilitate input and output within programs, with a set of macros
-
sddl
parse and analyse SDDL Strings
-
colon
A array and number utility functions
-
twitter/rustcommon-atomics
Atomic primitives unified by traits
-
const_typed_builder
Compile-time type-checked builder derive using const generics
-
stdworld
signal-safe std replacement
-
syrette
The convenient dependency injection framework
-
tupleops
work with tuples
-
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 -
lazy_transducer
Lazy, parallel, indexable, generic data iterators
-
rtml
(r)ust macros for h(tml) expansion => rtml. (r)ust type safe (css) => rcss
-
tany
Type-erased container with inline storage for small values
-
binstring
Store binary data as a string
-
enum_ext
procedural macro that enhances enums with additional methods and conversions
-
specler_arbitrary
For generating arbitrary values for specler specifications
-
higher-kinded-types
"Generic generics" / higher-kinded APIs in stable Rust
-
unwrap-overflow-ops
arithmetic operations that always panic on overflow
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
log_err
Log error messages from Unwrap and Expect with log crate
-
hexify
Format hex
-
desaturate
This package aims to makes it easier to maintain a single code base for both regular and async functions
-
negative-impl
Negative trait implementations on stable Rust
-
spawn_interval
Call a subroutine at a constant time interval
-
newtype-derive-2018
macros for deriving common traits for newtype structures
-
any_cmp
Support dynamic type comparisons
-
no_debug
Helper types to omit debug info for select values
-
init_with
Helper trait to initilize an array with a function
-
scroll-buffer
Extra writable buffers for Scroll
-
teloc
compile-time DI framework for Rust
-
fuzzy_match_flex
Fuzzy matching library based on the popular
FuzzyWuzzylibrary for python -
docpos
Compact-document items after defining them (fn, struct, enum) + document fn parameters with rustdoc (⑂roxygen)
-
option_macro
a convenience macro
-
parameterized_test
A macro to support providing arguments to test functions
-
py-comp
A macro implementing a Python-like generator expression
-
read-restrict
Restrict the number of bytes read from a reader
-
vector_calculus
A single easy-to-use library for all vector calculus computations
-
ryu_floating_decimal
Fast floating point to floating decimal conversion. See the crate 'ryu' for more details
-
fat_type
A type which permits thin references to arrays and dynamic types
-
chainer
A cursed crate that allows for global call chaining with access to chained function results
-
zip_clone
Zip an iterator to a repeately cloned object
-
signrel
Trait expressing relationship between integers of different signedness
-
incomplete
incomplete!(), a compile-time checked version of unimplemented!()
-
traitreg
Create a registry of implementations of a trait
-
controlflow_inspect
inspect_* methods for ControlFlow
-
enum_handler
A macro to generate a handler trait for enums variants
-
fortify
convenient way to bundle owned data with a borrowing type
-
cgp-async
Async-generic primitives to support both sync/async in context-generic programming
-
guard-clause
Syntactic sugar for writing simple guard clauses
-
stuff
Stuffing things into pointers
-
ioc
An Inversion-of-Control library in Rust
-
std-io-peek
Peek trait
-
transactional_iterator
Iterator that allows to commit or abort progress
-
regex-dfa-gen
A proc_macro lexer generator. using
enum-like syntax. -
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…
-
lithium
Lightweight exceptions
-
c-emit
Polished builder API to write C Code
-
ngram_iter
An iterator of arbitrary N-grams of rust Copy types
-
rustpy
Bindings of Rust programming language primitives
-
free-wrap
Provide a easy way to define NewType Wrapper
-
rxrs
Reactive Extensions for Rust
-
custom_float
Custom floating-point types
-
big_mac
A metamacro toolkit for writing complex macros
-
ironplc-dsl
Domain-specific language objects for IEC 61131 language elements
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
laddu-amplitudes
Amplitudes for the laddu library
-
accompany
with-like macro for Rust -
nias
closure generator library
-
consumable
Consume the value by replacing it with the default value and returning the previous value
-
vimvar
that provides ability to read neovim/vim variables
-
phantomdrop
Go-like deferring of function calls
-
totally-safe
that allows you to bypass Rust's safety guarantees with totally safe patterns, featuring arbitrary lifetimes, aliasing, and more!
-
let_clone
Declarative macro to clone multiple values at once
-
array-fu
Construct arrays using simple syntax
-
cassandra_macro
Create Cassandra tables and CRUD CQL prepared statements from Rust structs. (custom derive: cassandra_macro_derive)
-
transitive_from
Helper macros for creating hierarchies of transitive
Fromimplementations -
cronjob
scheduling your methods
-
enumx
Ad-hoc enum extension
-
scalar_types
A module that wraps scalar types in an endian safe type
-
tectonic_errors
A boxed error type for Tectonic, with supporting utilities
-
dirk_framework
Dependency Injection for Rust
-
pre
Compile-time assistance for working with unsafe code
-
chunk_iter
Chunked iterator generic over any iterator
-
symbolism
Unique symbols made from human readable tags
-
vnum
Create enums with a constant value associated to every variant
-
array-lit
Macros for array and
Vecliterals with superpowers -
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
bog
The highly-modular abstraction standard
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
fluent-string
Fluent versions of String mutation methods
-
proto-mapper
A Macro library for easier mapping between custom models and proto generated code
-
iter_from_fn
Create iterator from repeatedly aplying a function that takes no parameters
-
wutil
A lightweight library that contains useful functions, wrappers, and macros
-
u-plus
Pretty Unicode code point literals: U+12345 instead of '\u{12345}'
-
unwrap_none
Implements the
unwrap_noneandexpect_nonemethods removed by https://github.com/rust-lang/rust/pull/83349 -
nvim-types
Rust bindings to the Neovim C types
-
gpp
A generic C-like preprocessor for Rust
-
effective
An effects library, an alternative to keyword generics
-
plmap
Parallel pipelined map over iterators
-
ownref
Provide the smart pointer type that bundles the data with its owner
-
quack
Duck typing traits
-
tl_str_list
Type-level string (tl list of chars)
-
miden-thiserror
derive(Error) with no-std support
-
cart_prod
Cartesian product of iterators
-
open-ambient
Open files and directories with constant paths
-
nagios-range
types to parse and operate on Nagios ranges
-
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
-
value-bag-sval2
detail for value-bag
-
io-ensure
Prototype of the
std::io::ensurefamily of macros -
irrelevant
ignoring variables in a more explicit fashion, and checking assumptions about those variables
-
arrutil
Functions for manipulating arrays from slices
-
orfail
Error handling library for portable unrecoverable errors
-
finite-fields
Traits and types for computations on finite fields
-
dyn-any
An Any trait that works for arbitrary lifetimes
-
rquickjs-extension
An extension system for rquickjs
-
have_len
container empty ? (
is_empty()andis_not_empty()) -
prec
A generic operator-precedence parser library
-
chandeliers-err
Internal error message generators for the Chandeliers project
-
linq
Language Integrated Query in Rust
-
iterator-ext
An extension to Rust's Iterator
-
lifo
last-in first-out api wrapper for std
VecDeque<T> -
knife
An iterator that divides things evenly
-
r-ex
Zero-bloat Rust core library extensions
-
bitutils
Bitfield macro and utilities
-
parser-c
Macros for parser-c
-
mudders
Generating Lexicographically-Evenly-Spaced Strings, or: Mudder.js in Rust
-
murrelet_livecode_macros
livecode macros for murrelet, a livecode framework
-
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.
-
vlq-bij
Bijective Variable-Length Quantity encodings
-
xconstants
Adds preliminary support for enum const generics
-
ps-alloc
a reasonably safe allocator
-
standalone-quote
Fork of quote that allows disabling the proc-macro feature in proc-macro2 so as to remove the rustc dylib dependency
-
interior_mutability_pointer
A wrapper around
Rc<RefCell<T>>allowing immediate access to inner methods -
slice-copy
Go style copying for slices
-
zc_io
zero-copy I/O
-
swahili-dsl
A Swahili-based DSL made for educational purposes
-
cgp-error-eyre
Context-generic programming error handlers implemented using eyre
-
early_returns
Macros to make early returns easier to work with in Rust
-
mightrix
treat continous memory as a matrix
-
selfe-start
defining the entry point to the initial thread on seL4
-
sanitizeable
derive structs without certain fields
-
noders
NodeJS-like event loop environment for Rust
-
borrow-framework
More flexible borrowing
-
iter-diff
Differences between iterators
-
crossdylib
Cross-platform shared state across shared libraries/modules
-
boolinator
trait, which lets you use Option and Result-style combinators with bools
-
pi_print_any
print any value without trait bounds using specialization (Rust nightly channel)
-
rust_io
Macro implementation for [rust_io] defining several operators to be used emulating Haskel [do notation]
-
funlib
Rust functional library
-
litto
Building blocks for DSL scripting language interpreters that interact with native Rust code
-
onlyerror
Obsessively tiny error derive macro
-
beaver
setting up Rust objects inspired by factory_bot
-
serde_type_name
lookup name of type for any struct or enum that derives serde Serialize
-
emplacable
Return unsized values from functions
-
nstd_io
NSTD standard I/O crate
-
json_extract
This macro reduces boilerplate when using serde_json::Value variants when trying to get into a nested property
-
diva
Opinionated convenience wrappers for
std::process::Commandand friends -
unsafe-any
Traits and implementations for unchecked downcasting
-
iter-tee
Make several clones of an iterator
-
diman_lib
Commonly used types for internal use in diman
-
rbuwu
rust macros but in uwu
-
anyhow_ext
Extension of anynow
-
ieee-apsqrt
Square root functions for IEEE floats using rustc_apfloat
-
mod
project that provides two simple and useful utility functions for converting between Option and Result types
-
nearly_eq
Nearly(Approximately) equal traits and assertion
-
bit
helpers to manipulate bits and bit ranges
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
fast_delegate
delegate struct easy
-
asyncsync
Runtime-agnostic synchronization primitives for asynchronous Rust
-
core-nightly
Nightly build of libcore from the rust repo
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
check
Convenience assert!-like macros which return instead of panicking
-
enum_downcast
Safe downcasting for enums
-
lexington
A very simple library for lexing / parsing
-
futility
Functional Utility types, macros, and functions for common tasks or needs in Rust
-
collection_literals
macros for initializing std::collections
-
sod-tungstenite
Service Oriented Design - Tungstenite
-
total_float_wrap
Floating point wrapper implementing Hash and Ord according to IEEE 754 totalOrd
-
closure
A macro for capturing variables on a per variable basis
-
callable
closures implementing PartialEq and argument operations
-
tor-basic-utils
General helpers used by Tor
-
clc-engine
Provide calculation api for calculator ui
-
tupley
Extension for primitive tuple (Hlist based on recursive structure)
-
zoomer
Making Rust a true modern language™️ with revolutionary macros
-
user_stable_vtable
A partial implementation of [RFC 2955], written in stable rust
-
pass_by_catastrophe
Please do not use this
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
tea-map
Map functions for tevec
-
int-to-c-enum
TryFromInt - A convenient derive macro for converting an integer to an enum
-
query_interface
Dynamically query a type-erased object for any trait implementation
-
tightness
Define types bound by arbitrary invariants and conditions
-
observe
Rust declarative observables inspired by MobX
-
tearor
Easily turn data races into data corruption!
-
thin-slice
An owned slice that packs the slice storage into a single word when possible
-
ref_kind
Different reference kinds
-
fast-rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
forgejo-api-types
API types of the forgejo API
-
try-traits
Alternatives to std lib traits that can fail
-
zkp-error-utils
Assertion like macros for returning
Result::Err -
mc-network-data-types
Minecraft network I/O data types
-
magic_static
Global singletons initialized at program start, an alternative to lazy initialization
-
rs_state_machine
A business-oriented state machine library
-
always_equal
A wrapper for types that can't implement Eq
-
leptos_datatable
A leptos component for creating tables with data validation
-
cfg-or-panic
Replace function bodies with
unimplemented!()when condition is not met -
generate
compatability layers for
std::ops::Generatoron stable rust -
kinder
small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
steloc
compile-time DI framework for Rust
-
hb_error
Useful macros and traits for creating and handling errors
-
mods
Simpler module declaration
-
serde-partial
Serde partial serialization made easy
-
future-union
Use future::Either with
impl Future -
batch_oper
some batch operation macro for some operations
-
bset
Fast and compact sets of bytes or ASCII characters
-
assert-impl
Macro for static assert types implement a trait or not
-
std_prelude
prelude that the rust stdlib should have always had
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
arch-into
safe type conversions between pointer-sized types (usize/isize) and types with fixed size
-
dyn-dyn
Flexible trait object downcasting using ptr_metadata
-
tagname
get the name of a variant in your enum as a string
-
instancebuilder
Convenient way of managing dependency injection
-
tuple-traits
Additional tuple traits to enable ergonomic types
-
ssttt
More Syn Syntax Tree Traversal Trait
-
io_resp
A RESP parser implementation, written with edge performance in mind
-
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… -
davenport
Ergonomic thread-local workspaces for intermediate data
-
to_tokenstream
An interface for creating a compiler within a Rust macro
-
tiny-input
Tiny input macros
-
constrained_type
On the fly value objects in Rust
-
gha_main
Convenience macros for writing GitHub Actions in Rust
-
checked_sum
safely summing up iterators
-
erreport
A Result helper to catch all the Err propagation path for Rust
-
niceowner
A stupid library that allows you to own a value, even if it comes from a reference. No cloning.
-
greattraits
My own collection for traits extending standard library types
-
mapro
A tiny macro library for creating std::collections
-
macro-stateful
help record state in a global scope
-
atomic_non_null
An atomic wrapper around NonNull
-
deinterleave
your datastructures
-
cor_iter
Correlate of two iterators
-
io-error
convenient macro for creating I/O errors
-
first-err
Find the first Err in Iterator<Item = Result<T, E>> and allow iterating continuously
-
nested-ref
References to data contained in one or more nested RefCells
-
nclosure
composable, nameable closure types with separated states and functionality for use in APIs where anonymous types are unavailable
-
default_is_triple_underscore
Shorter syntax for Default::default() : ___()
-
easing
Leveraging Rust's powerful iterators for easing
-
visita
Elegant implementation of the Visitor Pattern
-
own
Wraps an owned or borrowed value
-
tuple_utils
A set of utilities to enable higher level operations over tuples
-
unreachable_checked
unreachable!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won't panic.
-
anxious
panic-free dialect of Rust
-
hala-rs
Hala rust standard library facade
-
simple_scan
Iterator extensions for simple scan operation
-
tailwag_utils
A collection of assorted utility functions / traits. Part of the tailwag stack.
-
doxed
making Rust doc strings available at runtime
-
namedarg_rustc_macro
namedarg main package
-
dyn_ord
Equality and ordering for trait objects
-
roopert
object-oriented toolkit for Rust
-
nopanick
No panic library for add, sub, mul, div operators in Rust
-
io-cast
a high-level io function similar to Python's input function
-
beard
Handy macro to generate formatted text in rust
-
tyco
Macro for generating scoped TYped COntexts
-
zkp-macros-decl
Procedural macros
-
inline_dyn
A container type for storing dynamically-sized types inline
-
esvc-traits
Traits for ESVC
-
vec3
-
result-ext
Extends
Resultwith additional operations -
okey
Everything is Result::Ok
-
lsdata
LSD (Less Syntax Data) configuration/data transfer format
-
lazy_thread_local
Lazily initialised per-object thread-local storage
-
fluent_state_machine
A domain-specific language (DSL) for creating state machines in Rust
-
typesafe-builders
Infallible compile-time checked builders for your structs
-
safe_unwrap
allows unwrapping and annotating that the unwrap will never fail. Does not require
std. -
ordered_iter
Ordered iterators
-
anony
Anonymous struct
-
tartan-c-enum
Define FFI-safe enums that support unknown values
-
breadx-image
Image type to be used in breadx
-
catch_panic
A helper macro for safe Java-Rust interop that "catches" Rust panics and rethrows them as Java exceptions
-
turbostate
Finite State Machine
-
ffizz-string
FFI string implementation
-
type_utilities
Implementing more methods to rust type primitives
-
tt-call
Token tree calling convention
-
err-context
Lightweight context layers for stdandard library errors
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
maflow
Flow macros: basically unwrap for return, continue and break
-
hacspec-lib
The hacspec library
-
enum_index
Trait and macros for extracting Enum variant index
-
dyn_partial_eq
PartialEq macros for trait objects
-
cpp_core
interoperability with C++
-
eieio
Error Implementing
Eq + Clonereplacingstd::io::Error -
hand
Easy to use, pretty cmd log for lazy devs
-
newtype_derive
macros for deriving common traits for newtype structures
-
collected
Summation, product, maximum and more special collectors for Rust iterators
-
elor
Base generic implementation of an Either type
-
mat-rs
no_std implementation of mathematical matrix types
-
rust-cef
Trait to serialize/convert/map a Rust item into an ArcSight Common Event Format string. This trait enables logging libraries and frameworks that may wish to integrate with standardized…
-
scones
Generates simple constructors for structs
-
dyn_traits
Magically derive non-object-safe traits
-
strongly
A proc macro to create strongly-typed primitives
-
err-per-field
A more fine-grained control over field-level error handling
-
tuppipe
pipe operator-like implementation using tuples in Rust
-
typeful
A collection of helper derive macros for type patterns
-
diesel_derives_traits
Traits for diesel_derives_extra
-
podstru
Bureaucratic structs to speed up rust development
-
oofs
Error handling library that generates and injects context for you
-
lcrt
help writing leetcode solutions in rust
-
hash_table_datastruct
Adds a HashTable type, allowing to store values in a table with integer-indexed rows and hashable keys for columns
-
opentalk-types-signaling-polls
Signaling types for the OpenTalk polls module
-
cisness
Runtime 'live witness' of two types being the same
-
type-record
A type-level record (see documentation for details)
-
dynstore
A container for arbitrary castable objects
-
destruct-drop
Macro for dropping the fields of a struct or enum without dropping the container
-
const_ptr
Implements a Const Pointer struct
-
remit
Rust generators implemented through async/await syntax
-
const-assert
Assert struct for const generics
-
rusty_helloworld
Mastering Rust, step by playful step.Rusty_Helloworld is your one-stop shop for exploring the diverse landscape of Rust through practical examples. Whether you're a beginner diving…
-
oco_ref
A smart pointer for storing immutable values with relatively-cheap cloning. (Like a
Cowmeets anRc!) -
indiscriminant
A proc-macro for mapping between values and enum discriminants
-
simplebyteunit
A thin encapsulate for integer primitives to facilitate a fast, simple, yet ergonomic byteunit implementation
-
hexf-parse-libm
Parses hexadecimal floats (see also hexf)
-
declarative_enum_dispatch
Declarative macro generating boilerplate for enum dispatch
-
kube-core
Kube shared types, traits and client-less behavior
-
read_buffer
ReadBuffer, a wrapper to safely read into a buffer from a Read
-
zhi_enum
derive macros to easily use enum
-
holder
getter setter auto gen with holder trait
-
enum-unitary
Trait and macro for unitary enums
-
trait-based-collection
A trait-based collection library that implement different data structures using the same trait
-
ld_preload_helpers
Macros to run code at load time and override C functions
-
integer-iterator
Add the ability to iterate over the digit of all primitive integer types. Also exposes the trait so one can implement it oneself.
-
fang_oost
implementing Fang and Oosterlee's algorithm for inverting characteristic functions
-
entwine
Generic slice-like interface for operating on multiple slices at the same time
-
dynstack
A stack for trait objects that minimizes allocations
-
opt2r
crate(library) that provides a way to convert Option to Result
-
maparr
macro to build a static
Mapbased on const array -
unwrap_let
macro for quickly unwrapping a refutable pattern
-
easy_errors
simplify and enhance error handling in Rust
-
ebacktrace
error wrapper which captures a backtrace and can carry an optional textual description
-
variant_count
Derive macro for enum which adds to it the count of variants
-
ref-map
Helper trait for Option and Result to map references
-
rusty-cron-scheduler
scheduler that executes function pointers following a cron string
-
chain_tools
A set of traits allowing for more a erganomic style of chain programming
-
atomic_refcell_try
Threadsafe RefCell
-
shorten
A collection of convenience functions, macros and traits to shorten repetitive code
-
defew
A new() derive macro for structs
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
namable_closures
types and macros to create namable closure types
-
debug-fn
A function adapter that implements Display and Debug
-
project-uninit
Macros for safe references to and initialization of fields in MaybeUninit structs
-
detach
helper type for being able to detach/reatach a member item
-
option-like
Create your own Option-like enum
-
cartesian_array_product
Arrays of the cartesian product of a set of items
-
generic_singleton
allowing for generic singleton patterns
-
prim_int_kind
Enumeration whose variants represent kinds of primitive integers
-
bongonet-error
Error types and error handling APIs for Bongonet
-
traverse
Proof-of-concept trait for internal iterators called traversals
-
not_empty
Slices and vectors that are statically guaranteed to be not empty
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
fimi
A generic migration framework
-
vec_remove_if
Extract elements from a vector based on supplied criteria
-
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
detour2
A cross-platform detour library written in Rust
-
pythonic-helper
that provides Python-like functions (and some surprises)
-
bevy_cell
Attach Bevy's Handles/Entities statically to Types
-
bitty_write_macro
A drop-in
write!replacement that optimizes non-formatting writes for code size -
shellexpand-fork
Shell-like expansions in strings
-
amass
Automatically generate
Fromimpls for nested enums, even across crates -
arbintrary
Proof of concept for arbitrary integer sizes using generic const
-
unnest
Macros for an unnested control flow
-
derive-ex
Improved version of the macro to implement the traits defined in the standard library
-
io-window
Seekable I/O adapter that limits operations to a byte range
-
collar
easy array collection
-
cpp_to_rust_generator
Automatic generator of C++ library wrappers
-
bit_roles
Granular role management based on bit flags
-
ffizz-header
FFI helpers to generate a C header for your library
-
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.
-
statum-core
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
simplicio
Gets rid of the boilerplate in rust
-
omniswap
swap values between possibly-overlapping references
-
cfg-if-edc
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.
-
navigator
A Macro-heavy Domain-Specific Language for console apps with menu systems
-
type-vec
A type-safe vector with type-level length
-
generic-str
Annoyed that Rust has two string types? Well it doesn't any more
-
tagged_cell
Fast, initializable, and thread safe static variables
-
display_with
Return opaque impl Display and/or impl Debug types via display_with and debug_with
-
tuplestructops
Structural manipulations for tuples
-
iter-python
Python generator expressions and 'list' comprehensions
-
quartet
Nibble (quartet, u4) slices
-
predicate
Use enum to predicate something, support & and | operator
-
rerast_macros
Macros for use in Rerast rules
-
thinnable
Thin references to unsized types
-
irox-enums
Traits for better Enumerated Types
-
rust-fp-categories
A Functional Programming Library in Rust, Category
-
errore
error handling and tracing
-
fix_fn
Macro to create recursive closures (similar to the Y combinator)
-
for-loop-iterator
Iterators like traditional for loops
-
oneshot-fused-workaround
Fused wrapper for futures::channel::oneshot
-
evaluator
interfaces and implementations for logic constructs that return values without accepting arguments, either via closure captures, global state, calculation or otherwise
-
qed
Compile-time assertions
-
enum-tools
Automatically derive functions and trait implementations for enums
-
slyce
Python-like slices
-
fn_block
defining macros for calling blocks or expressions in a closure
-
pipeop
Adding the pipe operator to Rust with a declarative macro
-
quasi_iter
that contains supplementary iterator objects and methods
-
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
-
do-not-use-testing-rosidl_runtime_rs
Message generation code shared by Rust projects in ROS 2
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
is-same
A trait for comparing object equality
-
zisvalidator
A validator for struct and enum
-
intuple
Convert structs and enums into tuples (of refs) and back - recursive, ignore fields
-
matrix_match
Macro to match on two values at the same time
-
errify
Function error context provider
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
sexpr_parser
Generic S-Expression parser
-
mopa-maintained
My Own Personal Any: get your own Any with additional functionality
-
zipped
recursively unzipping tuples, Options of tuples and Results of tuples
-
ataraxy
Discord slash commands framework for Serenity
-
vmprotect
Unofficial VMProtect SDK for Rust
-
ddi
Dynamic dependency injection library for rust
-
friendly_safety_buddy
A fun macro to write safe code with
-
opentalk-types-common-identifiers
Common identifier types for OpenTalk crates
-
array_manipulation
Methods for manipuling arrays in a Vec-like fashion. It will (probably) get into core once const expressions get less experimental.
-
rvs-c-api
C-API for Rvs - A library for defining and evaluating random variables using a simple DSL
-
global-static
Lazily evaluated non-constant static items
-
cereal
data serialisation library
-
abort_on_panic
Intercept panic! from unsafe locations and abort the process
-
rs-utilities
Some utilities
-
slip
A hassle-free utility to encrypt error handling strings in your public binaries to protect your business logic
-
abi_stable_shared
detail of abi_stable
-
anonymous-trait
Anonymous trait implementation with capturing the environment
-
input-stream
IO streams similar to C++'s streams
-
microtype
simplify the creation of microtypes
-
therror
derive(Error) with a twist (based on thiserror)
-
ghosts
Type-check non-existing
Phantomcode for Fun And Profit™ -
tiberius-mappers
Row mappers for Tiberius
-
improved_slice_patterns
A tiny crate that provides macros to help matching on Vecs and iterators using the syntax of slice_patterns
-
tap-trait
Inspect and mutate values without leaving the method chain
-
ferrite-session
Session Types DSL for Rust
-
scopefn
Scope functions for Rust
-
eros
Context aware, ergonomic and precise error handling
-
cgp-extra
Context-generic programming extra meta-crate
-
typefun
Emulating various values at compile-time using types
-
wherr
Enhance Rust errors with file and line details using the
#[wherr]macro for clearer debugging -
to-syn-value
Defines a derive macro to implement a trait converting values to instances of syn::ToDeriveInput
-
retry_macro
A set of declarative macros which retries executing a function upon failure
-
builder_option
A macro to generate builder class for a struct
-
measurement
unit safe computation in rust
-
deborrow
Splits mutable references safely into their fields, and helps with reference manipulation
-
redox-path
Path parsing primitives for Redox
-
thiserror_lite
Almost drop-in replacement for thiserror, implemented using 100% declarative macros
-
apply_conditionally
Chain and apply methods on objects conditionally
-
hexhex
hexadecimal conversion 🪄
-
nonminmax
Primitives types which cannot be their minimum/maximum value
-
cargo-verify
Prettier error messages for the verified crate
-
cpp_to_rust
Automatic generator of C++ library wrappers
-
function-compose
lib to allow composition of sync and async rust functions
-
generic_graph
implementing general purpose graphs. Including some default implementation (the latter are still WIP)
-
thisctx
Easily create error with contexts
-
unwrap_helpers
Helper macros for unwrapping
-
integer_or_float
A data type holding an ‘integer or float’ (a data type in the Unified Font Object specification, among others)
-
infix_macro
macro that generates the neccesary boilerplate to use "*operator*" infix functions
-
result-inspect
Adds the missing Result::inspect() function
-
predicates-core
An API for boolean-valued predicate functions
-
arrcat
Array concatenation
-
rmin
A minimal Rust lib for writting R extensions
-
command-extra
Additional methods for std::process::Command
-
engineer
master builder!
-
lua53-ext
Extension to jcmoyer's Lua 5.3 bindings
-
match_opt
A macro for turning a partial match into a full match returning an option
-
axmac
Readable indexing macros for 1-4 dimensional data structures
-
arraylib
Tools for working with arrays
-
c99
C99 types for easier interop
-
orx-iterable
Defines and implements Iterable, Collection and CollectionMut traits to represent types that can be iterated over multiple times
-
cobhan
FFI is a system for enabling shared code to be written in Rust and consumed from all major languages/platforms in a safe and effective way, using easy helper functions to manage any unsafe data marshaling
-
cgp-inner
Context-generic programming inner component
-
trait_enum
Easy enum wrapper that implements all traits that the wrapped objects implement
-
set_slice
A macro for assigning values to slices
-
randlib
Dependency-less random value generator using pointer addresses and time
-
pyo3_special_method_derive_lib
Automatically derive Python dunder methods for your Rust code
-
type-layout
Derivable trait to view the layout of a struct, useful for debugging
-
trigram
Trigram-based string similarity for fuzzy matching
-
generator_extensions
Basic extensions to Generator types to bring parity with Iterators
-
string-builder
string builder type
-
pin-init
Safe pinned-initialization in Rust
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
goof
A reusable, composable, aggregate and
no_std-friendly error library -
macro-attr
macro_attr!macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derivecrate. -
posix-errors
Posix error codes and handy functions for using them
-
pointer-identity
Wrapper type to treat the pointer address of types as identity rather than the value
-
isnt
Inverted versions of boolean-valued stdlib functions
-
blue_typemap
A TypeMap Dependency Injection method for dynamic function parameters
-
unsafe-any-ors
Traits and implementations for unchecked downcasting
-
com-scrape-types
Support code for bindings generated with com-scrape
-
with-api
macro for shrinking scope
-
anyint
traits and structs for working with integers of any bit size
-
maplit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
structify
A procedural macro to transform functions into structs with state and execution dependencies
-
number-bytes
trait for converting generic numeric types to and from bytes
-
io-extra
An extension trait for
std::io::Error, with shorthand constructors for variousstd::io::ErrorKinds -
tool
A grab-bag of tools for functional programming
-
select_indices
Iterators for taking multiple shared/exclusive references from a slice
-
fallible_map
fallible mapping over
Optionand iterators using functions that can returnResults -
modifier
Fluid chaining APIs for both mutable ownership types
-
if-let-return
macro for
if let ... pattern -
borrown
Borrowed or owned, simplified for no-std
-
error-utils
Some rust macros to simplify common error handling patterns
-
even_bigger_s
Better String Literal
-
config-docs
A trait and derive macro to generate documentation for your structs
-
rustollens
A small and experimental library with a type-level representation of booleans with companion connectives for compile-time sort-of fun with logic
-
intercom
writing COM visible Rust components
-
effect_cell
Container that runs effects when updated
-
rnet-gen
Generator for rnet
-
containerof
Macros and traits facilitating the use of intrusive structures in Rust
-
struct_update
export a macro to instantiate a struct with others which have common fields
-
squote
A clone of the quote crate that uses a String as its backing store
-
relevant
A small utility type to emulate must-use types
-
wider_primitives
Wider primitive integer types
-
biheap
A heap group that supports efficient removal of extreme elements
-
shpat
sasha's solution to common patterns
-
zerocopy
makes zero-cost memory manipulation effortless. We write "unsafe" so you don't have to.
-
makeit
Compile-time checked Builder pattern
derivemacro with zero-memory overhead -
purescript_waterslide
Generate Purescript types from your Rust types
-
struct-builder
Derive a builder for your structs
-
rs_envflag_macros
An easy way to define flags by environment variables
-
litenum
minimal convertion utilities between literal and enum
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
struct-validation
trait and derive to validate structs and return a list of errors
-
tailwag_macro_inline
The logic for A collection of macros to support the tailwag crate
-
stecs
Experimental static compiler-checked ECS library
-
mapstruct
Create refactor safe derivatives of Structs with proc-macros
-
respan
Macros to erase scope information from tokens
-
ogma-libs
Ogma DSL builder libs
-
vec2
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
cgp-run
Context-generic programming runner component
-
kind-derive
Derive generator the kind compiler
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
vet
Arbitrary type validation
-
lodust
Rust version of Lodash
-
dot-generator
the set of macros to generate dot files
-
romap
A trait for read-only-maps
-
derive_di
realized the dependency injection pattern
-
type-factory
unique opaque types
-
memoize
Attribute macro for auto-memoizing functions with somewhat-simple signatures
-
serde_str_helpers
Helpers for using serde with strings
-
layout-lib
view the data layout of a struct
-
close-err
Add .close() to file-like types, for error handling
-
lit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
type-sets
Sets implemented in the rust type-system
-
bind_match
Convenience macro similar to
matches!but binds to variables in the pattern and returns anOptionof the result -
clonesure
A helper macro to create closures which will clone its environment
-
case_iterable
A procedural macro to iterate over enum variants, ala Swift's CaseIterable
-
middleman
A wrapper for a mio::TcpStream to send and receive serializable Structs (blocking or non blocking) of arbitrary size
-
stackvec
stack-allocated Vectors (performance and/or no-std)
-
fstrings
Python3 fstring interpolation in Rust
-
compost
Adds a macro to decompose tuples into tuples containing a subset of their values
-
scsys-core
scsys is a collection of primitives and utilities for use throughout the ecosystem
-
arr_ty
Macros for smart array initialization (best for trait object element types)
-
aict
Generates auto-incrementing unique IDs
-
structinator_traits
traits allowing transfer of data from iterators to structs
-
facilitest
that facilitate testing
-
smart
dynamically-dispatched smart pointers
-
make_public
A procedural macro to make struct fields public
-
rattish
Cast between trait objects
-
catch-unwind
Wrappers for catch_unwind that handle the edge case of the caught panic payload panicing
-
kg-symbol
Atomic strings in Rust
-
flow_impl
Definition of an Implementation trait for flow functions, and a derive macro
-
trait-set
Support for trait alias feature on stable Rust
-
description
like Display, but 'static
-
chain-debug
Injecting debug without rewriting chain-calling code
-
static-cond
Macro for performing comparisons during macro expansion
-
take-static
Static items that provide mutable access only once
-
deref_owned
Generalization of std::borrow::Cow
-
transition-table
transition table utilities for keyword parser
-
iterator-endiate
Extension method for (exact size) iterators which yields tuple containing whether item is last in iterator
-
ferment-interfaces
Traits for FFI conversions and some helper methods
-
opentalk-types-signaling-recording
Signaling types the OpenTalk recording module
-
dynamic-cast
The fifth pillar of OOP: dynamic casting
-
polymorph
A set of utilities to better enable polymorphic behavior in Rust
-
c8str
String types that are both utf-8 and null terminated
-
transmute_guard
Transmute between types that have been marked as safe by the marker type
-
rustspec
BDD style test library
-
eso
Type machinery to build Cow-like containers
-
cow_arc
CowArc can be useful for decreasing memory allocations by sharing immutable memory
-
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.
-
nes
New Error System for rust
-
parametrizer
safe crate for parsing properly-formatted math strings representing parametric functions into Rust functions
-
flatty-portable
Flatty portable trait and primitives
-
seestr
pointer-wide nul-terminated strings with ownership semantics
-
rvs-parser
Parser for Rvs - A library for defining and evaluating random variables using a simple DSL
-
timely-bytes-master
Disjoint mutable byte slices from a common allocation
-
utils-results
The easiest and most intuitive error handling solution
-
number-types
A typenum clone I made for fun with some positive changes but much fewer features
-
trait-union
Stack-allocated trait objects
-
drop_ok
.drop_oksyntax sugar forResult. It’s instead of.map(|_|()). -
arraybox
A box with fixed capacity, backed by a byte array (it can be stored on the stack too). Implements fixed capacity
ArrayBox. -
build-deftly
Derive custom builders, using the derive-deftly macro system
-
trait-gen
Trait implementation generator macro
-
byte-array-struct
Macro to create a byte-array backed struct
-
restate
state machine library
-
cri-ref
Embedded-friendly equivalents of URIs
-
lambek
Type-Level Programming in Rust
-
thiserror_string_context
Adds context string to error enums generated with thiserror
-
thisisplural
#[derive(Plural)] for creating frictionless new types with any collection type like Vec or HashMap
-
rustyinject
Zero-cost, compile-time DI framework for Rust
-
hazmat
A collection of helpers for working with hazardous materials in Rust crates
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
error
A fancy error type for highly generic cases
-
ctjs
compile time javascript as a rust proc macro
-
get-field-by-type
Get a value of field, based on the type of a field
-
shoggoth
Generic and type-level programming for Rust
-
structural-convert
Derive conversion traits (From, Into, TryFrom, TryInto) when fields are structurally similar in enums or structs
-
frust
Functional Programming in Rust
-
atomik
Generic Atomic type
-
checked_array
A checked API for array types
-
sod-log
Service Oriented Design - Log Integrations
-
peggen-core
Generate recursive-descent & precedence climbing parsers. (traits)
-
derive_environment
modifying structs via environment variables
-
try-iterator
Adds a few fallible methods to iterators
-
exun
Handle unexpected errors
-
okk
approach to replacing the
Ok(()) -
null-terminated
slices and UTF-8-encoded strings with thin references
-
sim_connect_rs
An easy to use, opinionated API for SimConnect
-
maybe_null
A pointer type for handling potentially null values without accidental dereference
-
kwarg_macros
Keyword argument plugin
-
scope-functions
Kotlin-inspired scope functions for use in almost any situation
-
partialdebug
Derive Debug partially
-
astr
A const lenght stack str
-
khtml
macros for simple html generation
-
unflatter
unflatteris a Rust library providing extension traits for flattening and unwrapping nested structures, including nestedOptionandResulttypes. It simplifies working with deeply… -
memprint
A way to print memory layout of a struct
-
rutenspitz
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
any_ref
To capture and move things that are NOT 'static with memory safety
-
partial-functional
A small collection of Semigroups and Monoids for rust
-
derive
providing a minimal example of a derivable trait (via companion crate derive-derive) for testing and illustration
-
kommons_macros
a set of macros with utils
-
crosstrait
Cast from
dyn Anyto other trait objects, with no_std, no alloc support -
nstd_math
NSTD math crate
-
if-none
Early break/continue/return if an optional expression evaluates to
None -
borrowck_sacrifices
Necessary sacrifices to keep the Borrow Checker happy and developers sane
-
assert-type-eq
Macro to assert types across potentially different crate versions are compatible
-
roopert_macro_common
object-oriented toolkit for Rust (common data)
-
meticulous
Result extension to add more meaning to unwrapping
-
eternal_iterator
Trait implementation to promise that the iterator iterates forever
-
shrinkwraprs
Auto-derive for Rust conversion traits -- make working with newtypes a breeze
-
kaguya_rs
Functional Programming tools and ADTs
-
nonn
Integer types that are known not to equal any single N
-
fast-map
Map-like structs
-
enjoin
Powerful syntax-level async join macro
-
typebitset
Type-level bitset implementation
-
rustility
A collection of utilities I often find myself using in Rust
-
fsize
fsizeis aliased to the floating-point type of pointer size -
derive_variants
derives an additional enum from a nested enum that contains only variants and no nested fields
-
bit_fiddler
Macros for common bit operations with multiple convenient patterns
-
dyncast
Downcasting made easy
-
recursion-visualize
visualized cache-aware stack safe recursion
-
optargs
Easily create macros for functions with optional arguments
-
type-layout-syn2
Derivable trait to view the layout of a struct, useful for debugging. Patched for syn 2.
-
flatty-base
Flatty traits and primitives
-
clonelet
macro to capture by clone in closures
-
newtype
Custom Derive to give tuple structs newtype semantics
-
chained
lazily chaining functions
-
iter-flow
Functional programming utilities for Rust
-
mononym
Type-level named values with partial dependent type support in Rust
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
abi_stable_derive_lib
detail of abi_stable
-
tuplify
Generic hlist/tuple library
-
interleave_n
A generic iterator interleaving extension for iterators of iterators, based on itertools
-
letr
The macro for the lazy
-
dyn_struct2
Construct dynamically sized types safely. Supports arbitrary unsized types, not just slices
-
fallible-option
Fallible is an Option with inverted Try-semantics
-
assert_into
For when writing .try_into().unwrap() feels too long
-
upget
Super simple trait that patterns the value "updae" and "get"
-
assert_ok
A macro that asserts a Result is Ok
-
temporary_enum_delegate_0_3_0
trait delegation functionality for enums and structs
-
injectiny
A tiny dependency injection utility for Rust
-
nommy
Type based parser
-
enum_variant_macros
Macros to generate From & TryFrom for enums
-
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
-
rcrefcell
Wrapper type for Rc<RefCell<A>>
-
winit_event_helper
Simplified winit event handling using callback functions
-
arraytools
A variety of helpful methods for working with fixed-size arrays
-
enum_like
trait to treat any type as an enum. If a type has a reasonably small number of variants, for example a
struct A(bool, bool)which has 4 variants, this trait provides a 1-to-1 mapping from type value to a… -
derive_destructure2_examples
Examples for crate derive_destructure2
-
liftor
Functors for Rust lifetimes
-
asset-container
Manage local and remote assets in your structs
-
try_utils
The try! macro descends into an enum variant. It's more flexible than ? and unwrap(), and it works with your enum, too!
-
collect_array
Allows for collecting an Iterator into an exactly sized array
-
head-tail-iter
An iterator that repeatedly splits head & tail
-
static-cow
Cowat the type level: a framework of traits for writing types that are generic over ownership of their contents -
unreachable
code optimization hint in stable rust
-
polimorphism
Function overloading via a procedural macro
-
stringreader
wrapper for strings so that they can be consumed via the std::io::Read trait
-
soapy-shared
Custom types used by soapy macros
-
the-newtype
The Newtype trait
-
htmxpress
Procedural macros for generating htmx strings
-
err-convert-macro
Errors converting macros
-
simple-bits
trait to extract and replace bits in integer types
-
unibox
Universal Box that can store any type using static or dynamic memory
-
struple
Convert structures from and to tuples
-
log-instrument
Offers an attribute procedural macro that adds
log::trace!events at the start and end of attributed functions -
forward_ref_generic
Generically forward references for operations on Copy types
-
to_that
Declarative compile safe explict type conversion. Useful for chaining.
-
polymorphic-constant
A macro to define a numerical constant in multiple types at once
-
assert-cmp
Convenient assertion macros that print the failed expressions and their evaluated values
-
try_convert
Auto-generate TryFrom and an error type, with minimal boilerplate
-
thiserror_core2
derive(Error) (no_std-enabled using core2)
-
rs2glsl
Conversion from Rust code to GLSL
-
constptr
NonNull without mutability
-
unsaef
Macros to erase scope information from tokens
-
rxs
Reactive extensions library for Rust with Object-safe traits
-
consume_on_drop
A zero-cost abstraction that allows Drop::drop to consume self by value
-
handle_errors
just a macro to get the thiserror with colors and the error place
-
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. -
index_vec
Newtype-style helpers for
Vecandusize -
tracing-assert-macros
A macro for capturing trace logs
-
ternary-rs
emulating the ternary operator from C/C++ (among other languages)
-
tuple-conv
Allows converting tuples of one element to vectors
-
valibuk
set of macros implementing the correct-by-construction pattern
-
try-unwrap
A revolutionary new crate that allows you to unwrap() without making your stupid software panic
-
str_assert
Thin wrapper around stdlib assert_eq macros using dissimilar as the comparison. (Only for strings)
-
bounded_types
type representing bounded integers, implemented using const generics
-
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
-
encoding-next_index_tests
Helper macros used to test index tables for character encodings
-
unused
Allows for unused generic parameters that do not act like they are owned
-
simple-di
dependency injection for Rust
-
tuple-arity
Get the arity (number of elements) of tuple types with 0-12 elements
-
extern-c
Convert a zero-sized closure into an
extern "C" fn(…)pointer -
derive-for
Macro for defining structs using the same derive procedural macros
-
tosserror
derive(Toss)
-
once-cell-regex
just gives you the
regexmacro from theonce_celldocs! -
rusty-value
Create a generic inspectable value from any rust type
-
diff-ba-rs
macros to get the difference of variables caused by a procedure
-
orion-async
Eliminate this constraint for performance - the local variables of asynchronous functions must implement Send Trait
-
static_str_ops
A package allows using static strings with non-trivial operations, e.g.,
concat!,format!,call_once, and more -
convertable
Non-reflexive version of From and Into
-
kinds
Higher-Kinded Types simulated by GATs
-
similarity
calculating similarity between numerical slices
-
bstringify
stringify! that yields byte string literals instead
-
monomo
Explicit trait monomorphization
-
rustutil
A collection of utility functions for Rust
-
delta-struct
Delta struct provides a rust-lang Deriveable trait, Delta, that can be used to compute the difference (aka delta) between two instances of a type
-
prefixes
Attribute-like macros imitating literal prefixes, e.g. #[f]"Hello, {world}"
-
tinytest
Write more compact unit tests with a small macro
-
iter_columns
Iterate over columns easily
-
underscore_args
Macro for underscore named argument syntax, aka Dyon
-
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. -
borrow_channel
A channel for borrows
-
traced_result
Proof-of-concept error tracing using the
Trytrait -
eeric-interpreter
A front-end abstraction layer over eeric
-
chain_linq
.NET's LINQ in rust as a declarative macro
-
into-a-byte
Build a byte from tuple of Into<u8>
-
expand_array
Macro to convert a static array to a fixed-size array
-
n-functor
Faux-derive a
mapfunction for types with one or more type parameters -
serde-struct-tuple-enum
Procedural macro for deserializing an enum of structs from tuples
-
every_variant
EveryVariant trait that provides the every_variant method on types. Allows you to easily generate every combination of variants in structures that contains Enums, or in nested enum trees…
-
debug-map-sorted
Sorted Debug impl for HashMap
-
dyn-eq
Test equality between trait objects
-
and_then_some
extension trait for
boolwith methods that returnOption<T> -
cursor
A more free Rust-Iterator
-
lifelink
Erase covariant lifetime parameters from anything, with generic associated types
-
string_error_wrap
providing a macro for an error type wrapping a String
-
test-macro
macro for writing Rust test code in an easy way
-
init-token
one-time safe initialization of static, without overhead
-
encoding_index_tests
Helper macros used to test index tables for character encodings
-
custom-string
This macro generates string types with custom validation
-
memory-size-type
A data type for dealing with memory sizes
-
maller
that calls closures depending on the input data
-
anymap
A safe and convenient store for one value of each type
-
hex-display
Display impl for byte slices which provides a hexdump
-
firedbg-lib
FireDBG Support Library
-
nstd_env
NSTD env crate
-
alias-ptr
(Mostly) safe manually-freed shared pointers in Rust
-
introspectable
Basic introspection via the Introspectable trait
-
phtm
Re-exports for common uses of
PhantomData -
internship
Interned string and more
-
devela_depend
Optional external dependencies for
devela -
lgio
Lightweight, generic, no_std IO
-
fehler
error-handling syntax in Rust
-
const_power_of_two
working with constant generics that are powers of two
-
asserts-rs
Asserts utilliy macros for Rust
-
array_ex
Easy and powerful compile-time array initialization
-
easyerr
easier creation and transformation of error types
-
default-test
A default trait that can be used in tests
-
display_container
implement Display
-
variadic_closure
Support for dynamically created and called closures with variable number of arguments
-
expandable-impl
What if we could check declarative macros before using them?
-
bpack
Fast, simple and easy to use data compression library meant to work with byte slices of String and str types
-
generic_once_cell
A bring-your-own-mutex version of once_cell
-
runtime_injector
Runtime dependency injection container
-
iex
Idiomatic exceptions
-
assert_cfg
static assertions for crate features, with descriptive errors
-
strflags
A string-enum and string-flags with fixed variants that can also accept arbitrary data
-
bos
Flexible Borrowed, Owned or Shared (B.O.S.) smart pointers. Like std's Cow but with Rc/Arc and without the ToOwned requirement
-
enum_properties
A macro for declaring static properties on enum variants
-
try_all
Extends iterators with
try_allto convert iterator of results into result of iterator of okays -
stur
functions for working with strings
-
multiref
Multireferences: a safe way to do [&T] -> &[T]
-
html5ever-atoms
Static strings for html5ever
-
static-include-bytes
Like the built-in
include_bytes!macro but produces a static array definition -
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
anysafe
any safe
-
typed-builder-macro
Compile-time type-checked builder derive
-
mstr
2-word, immutable Cow<str>
-
tuple-fn
call functions and closures with tuple of arguments
-
dynamic
A dyanmically typed value with fast downcasting
-
bointer
Assorted pointer-related utilities
-
bin-pool
A small crate for interning binary slices
-
nuhound
Improve error handling capability
-
phantasm
Small lib that helps with variance
-
test-results
A series of utility macros for outputting testing results
-
cgp-sync
Async-generic primitives to support both sync/async in context-generic programming
-
no-std-thiserror
thiserror but no_std compatible
-
simple-life
async lifecycle trait and convenient macros
-
finite-state-machine
A type and trait based finite state machine macro
-
lifetime
Traits and derive macros to change the lifetime of a type, allowing efficient reuse of your stucts or enums with any lifetime requirement
-
rudeboy
Rlua User Data Extension Boy - Derive/attr macros and traits for easily exporting user data to RLua
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
scalar_map
mapfor scalar types -
selective_assertions
Macros for asserting equality of structs with the flexibility to exclude or focus on specific fields
-
generic_asset
A upgraded version of Tantans asset loading macro for bevy 0.12
-
cfixed-string
Pass Rust strings to C with potentially not needing heap allocation
-
failchain
Ergonomic companion library for failure
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
into-result
convenience trait for converting something into a
ResultorOption -
zerror_core
A complete implementation of the zerror:Z trait
-
thistermination
add the Termination trait to error enums inspired by thiserror
-
cobalt-async
collection of helpful functions for working with async Rust
-
frunk_utils
working with frunk
-
stacking-iterator
Iterator utilities for manipulating stacks
-
toto
conversion method between basic numerical types
-
validated-slice
Helper macros to implement std traits for custom validated slice types
-
ptr_iter
Iterators to simplify working with pointers
-
ortho_vec_derive
Derive orthogonal vector structure for better CPU cache usage
-
fn_name
Macros that produce the name of the function they're invoked within
-
literalext
A helper crate for interpreting proc-macro
Literalvalues -
sort-by-borrowed-key
Adds two convenience methods for sorting by a borrowed key
-
stringlit
A macro to convert from str to String
-
error-context
Methods and types that help with adding additional context information to error types
-
whiteout
macros that erase the type of any value into an impl Trait for a given trait
-
foreign-types-shared
An internal crate used by foreign-types
-
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
-
drop_some
.drop_somesyntax sugar forOption. It’s instead of.map(|_|()). -
opentalk-types-signaling-shared-folder
Signaling types the OpenTalk shared_folder module
-
async_fn
Collection of helper annotations and macros for concise and yet explicit
async fnsignatures -
tested-trait
Associate tests with traits
-
asserter
New assertion library for rust
-
notugly
generic pretty-printing library
-
min-specialization
Experimental implementation of specialization
-
orderless
Orderless/named functions in Rust.
add!(b = 2); // 4. -
bifurcate
A general, extensible and performant implementation of bisect
-
string-literals
Rust macros to more easily create String types
-
studs
collection of extenstions to the Rust standard library
-
intentionally-empty
An intentionally empty crate
-
slice_trait
A generic trait for any slice, with item as a type parameter
-
soft_assert
Non-panicking assertions
-
extract-variant
Destructure expressions into, and return assignments from, a single pattern
-
using
A macro for simpler builders with method cascading
-
stated-scope-guard
A more flexible RAII pattern for stated resouce management
-
stable-pattern
Stable port of std::str::Pattern and friends
-
slice-ext
Useful extensions to slices and iterable types
-
bigfactorial
Precalculated compile-time factorial macro for numbers upto 99
-
string_from
A three-letter macro for String::from
-
spidermeme
Traits to test for type equality and type inequality
-
const-units
that lets you check the dimensions of your quantities at compile time and run time
-
tooples
Array functions for tuples
-
apply_method
Allows you to apply any function given as a parameter to the object
-
ref-portals
Safely use (stack) references outside their original scope
-
localization
t! macro, the easiest way
-
read-cell
Read-only Cell counterpart
-
uninit
A collection of tools for a safer usage of uninitialized memory
-
enum_const
enum const trait
-
oneoff
one-off types
-
dev_bestia_url_utf8
url utf8 encode/decode
-
wrapped-list
Macro for wrapping elements of a list with an object, function, or another macro at compile time
-
const_map
Macro to define compile-time associated constant maps
-
dynerr
Macros for dynamic error handling
-
boulder
Like a builder, but heavier
-
big_s
Rust’s missing
Stringliteral -
moveslice
A one-function crate to move chunks in a slice around
-
enum-rotate
Rotate and iterate your enums
-
local-or-heap
type with a pre-specified size, regardless of the size of the T type it contains, using heap allocation if necessary
-
loopcell
cell for multiple routes of access that are only used one-at-a-time in sequence
-
delay_init
Macro to declare lazily initialized types
-
sub-array
Extract a sub-array out of an array
-
replace_err
Adds a
replace_errmethod toResultwhich throws away the current error and replaces it -
code-docs-rs
reading field names, types and comments
-
tlist
Type-level linked lists (of types) and type-level 'functions' to manipulate them. Because TList is implemented using GATs, usage is very ergonomic.
-
keepops
Extension traits for keeping the input of mapping functions
-
nutype_macros
The newtype with guarantees
-
multiple_errors
Propagate multiple errors instead of just the first one
-
slicefields
Allows for data structures whose members are sub byte aligned (e.g. a one bit alignment)
-
mixed_array
Construct arrays of mixed types
-
traitobject
Unsafe helpers for working with raw trait objects
-
own-ref
&own references with ergonomic macro construction
-
error-doc
proc macro to generate #[doc] comments from #[error] messages
-
lazy-attribute
convenient attribute macro for lazy function execution
-
lifterr
A small set of adapters extending Rust's error-handling capabilities
-
gamo
A Range like struct for user defined types
-
enum-extract-error
A companion crate for
enum-extractthat exports an error type -
typeable
Exposes Typeable, for getting TypeIds at runtime
-
ts_static
Wrapper macro for lazy static and a struct to aid in accessing a static in a thread safe way
-
anon_enum
Enum types with fully-generic variants
-
umbra_slice
An owned slice type with German string optimizations
-
rustring_builder
string builder
-
aspect-weave
An Aspect Toolkit for Rust
-
dom_renderer
rendering html (or other DOMs) strings
-
nyavascript
Lisp implementation. Called NyavaScript because I'm a monster