-
bitflags
A macro to generate structures which behave like bitflags
-
thiserror
derive(Error)
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
once_cell
Single assignment cells and lazy values
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
ordered-float
Wrappers for total ordering on floats
-
bytes
Types and traits for working with bytes
-
memoffset
offset_of functionality for Rust structs
-
glib
Rust bindings for the GLib library
-
predicates
boolean-valued predicate functions
-
darling
A proc-macro library for reading attributes into structs when implementing custom derives
-
anyhow
Flexible concrete Error type built on std::error::Error
-
async-stream
Asynchronous streams using async & await notation
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
pin-project
safe and ergonomic pin-projection
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
human-panic
Panic messages for humans
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive
-
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… -
shellexpand
Shell-like expansions in strings
-
typed-builder
Compile-time type-checked builder derive
-
snafu
An ergonomic error handling library
-
libloading
Bindings around the platform's dynamic library loading primitives with greatly improved memory safety
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
enumflags2
Enum-based bit flags
-
approx
Approximate floating point equality comparisons and assertions
-
smol_str
small-string optimized string type with O(1) clone
-
ouroboros
Easy, safe self-referential struct generation
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
zerocopy
zero-copy parsing and serialization
-
dyn-clone
Clone trait that is object-safe
-
tap
Generic extensions for tapping values in Rust
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
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.
-
similar-asserts
assert_eq! like macros with colorized diff output
-
beef
More compact Cow
-
arrayref
Macros to take array references of slices
-
macro_rules_attribute
Use declarative macros in attribute or derive position
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
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
-
az
Casts and checked casts
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
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…
-
bitfield
macros to generate bitfield-like struct
-
compiler_builtins
Compiler intrinsics used by the Rust compiler. Also available for other targets if necessary!
-
error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
extendr-api
Safe and user friendly bindings to the R programming language
-
retry
retrying operations that can fail
-
nonempty
Correct by construction non-empty vector
-
assertables
macros
assert…!
for better testing, quality assurance, and runtime reliability -
valico
JSON Schema validator and JSON coercer
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
if_chain
Macro for writing nested
if let
expressions -
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]
checks -
flagset
Data types and a macro for generating enumeration-based bit flags
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
bounded-collections
Bounded types and their supporting traits
-
safer-ffi
Write safer FFI code in Rust without polluting it with unsafe code
-
inventory
Typed distributed plugin registration
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
cascade
Dart-like cascade macro for Rust
-
orchestra
Generate an orchestra of subsystems from a single struct
-
inlinable_string
inlinable_string
crate provides theInlinableString
type – an owned, grow-able UTF-8 string that stores small strings inline and avoids heap-allocation – and theStringExt
trait… -
parse-display
Procedural macro to implement Display and FromStr using common settings
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
la-arena
index-based arena without deletion
-
backon
Retry with backoff without effort
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits
-
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 -
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
async-once-cell
Async single assignment cells and lazy values
-
fragile
wrapper types for sending non-send values to other threads
-
writeable
A more efficient alternative to fmt::Display
-
fallible_collections
adds fallible allocation api to std collections
-
doc-comment
Macro to generate doc comments
-
swift-rs
Call Swift from Rust with ease!
-
stdext
Extensions for the Rust standard library structures
-
konst
Const equivalents of std functions, compile-time comparison, and parsing
-
polonius-the-crab
Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust
-
float-ord
A total ordering for floating-point numbers
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
async-recursion
Recursion for async functions
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
iri-string
IRI as string types
-
opaque-debug
Macro for opaque Debug trait implementation
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
rustrict
profanity filter for Rust
-
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
-
joinery
A small crate for generically joining iterators with a separator
-
sptr
Strict Provenance Polyfill
-
virtue
A sinless derive macro helper
-
environmental
Set scope-limited values can can be accessed statically
-
k9
rust testing library
-
lazy_format
lazily formatting values for later
-
tlua
Zero-cost high-level wrapper for Tarantool-LuaJIT
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
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…
-
derive-where
Deriving with custom trait bounds
-
field-offset
Safe pointer-to-member implementation
-
rustler
Safe Rust wrappers for creating Erlang NIF functions
-
nutype
The newtype with guarantees
-
nonmax
Numeric types that cannot hold maximum values
-
xcb
Rust safe bindings for XCB
-
buffered-reader
A super-powered Reader
-
recursion
cache-aware stack safe recursion
-
bounded-integer
Bounded integers
-
aws-smithy-types-convert
Conversion of types from aws-smithy-types to other libraries
-
crevice
Create GLSL-compatible versions of structs with explicitly-initialized padding
-
async-trait
Type erasure for async trait methods
-
const-gen
generating (relatively) complex compile-time constants in rust
-
aide
A code-first API documentation library
-
error-code
Error code
-
dlib
Helper macros for handling manually loading optional system libraries
-
extism-pdk
Extism Plug-in Development Kit (PDK) for Rust
-
constcat
concat! with support for const variables and expressions
-
inout
Custom reference types for code generic over in-place and buffer-to-buffer modes of operation
-
validify
struct validation and modification functionality through the use of derive macros
-
tynm
Returns type names in shorter form
-
indoc
Indented document literals
-
volatile
wrapper types for raw pointers
-
derivative
A set of alternative
derive
attributes for Rust -
pyo3-polars
Expression plugins and PyO3 types for polars
-
arrow2_convert
Convert between nested rust types and Arrow with arrow2
-
retour
A cross-platform detour library written in Rust
-
speculoos
Fluent test assertions
-
bevy_reflect
Dynamically interact with rust types
-
moveit
safe, in-place construction of Rust (and C++!) objects
-
lazy-static-include
lazy_static_include_bytes
andlazy_static_include_str
macros to replaceinclude_bytes
andinclude_str
macros -
bit_field
bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
arrow-array
Array abstractions for Apache Arrow
-
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… -
peeking_take_while
Like
Iterator::take_while
, but calls the predicate on a peeked value. This allows you to useIterator::by_ref
andIterator::take_while
together, and still get the first value… -
safelog
Conditionally suppress confidential information from logs
-
fallible-streaming-iterator
Fallible streaming iteration
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator
-
core_extensions
Extensions for core/std library types, and other miscelaneous features
-
rustdoc-types
Types for rustdoc's json output
-
thiserror-core
derive(Error)
-
testresult
type for concise and precise test failures
-
doku
A framework for documenting Rust data structures
-
lending-iterator
Fully general lending iterators in stable rust: windows_mut!
-
static_cell
Statically allocated, initialized at runtime cell
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
iter-read
A Read implementation for iterators over u8 and related types
-
tuples
many useful tools related to tuples
-
lender
A lending-iterator trait based on higher-rank trait bounds, with full std::iter::Iterator functionality
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
mem_dbg
Traits and associated procedural macros to display recursively the layout and memory usage of a value
-
sp-panic-handler
Custom panic hook with bug report link
-
octseq
Abstractions for types representing octet sequences
-
gumdrop
Option parser with custom derive support
-
pin-utils
pinning
-
float-cmp
Floating point approximate comparison traits
-
libc-print
println! and eprintln! macros on libc without stdlib
-
as-any
provide the AsAny trait
-
maybe-owned
MaybeOwned
(andMaybeOwnedMut
) type similar to std’sCow
but it implementsFrom<T>
andFrom<&'a T>
and does not requireToOwned
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
st-map
Runtime for a stack-alocated map
-
vercel_runtime
Vercel Rust Function Runtime
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
k8-client
Core Kubernetes metadata traits
-
fixed-hash
Macros to define custom fixed-size hash types
-
userfaultfd
Rust bindings for the Linux userfaultfd functionality
-
conjure-object
Runtime support for generated Conjure objects
-
one_err
OneErr to rule them all
-
vtable
Helper crate to generate ffi-friendly virtual tables
-
metered
Fast, ergonomic metrics for Rust!
-
const-random
compile time random number generation
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
arr_macro
Initialize arrays with ease!
-
assert_approx_eq
assert approximately equal
-
refined_type
imbuing rules into types and elevating them to more robust types
-
tiny-fn
Type erased closures on stack
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
gazebo
A collection of well-tested utilities
-
shopify_function
write Shopify Functions in Rust
-
psm
Portable Stack Manipulation: stack manipulation and introspection routines
-
aoc-parse
A little library for parsing your Advent of Code puzzle input
-
formatx
A macro for formatting non literal strings at runtime
-
autosurgeon
working with data in automerge documents
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
kind
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
result-like
Option/Result-like monad interface for your own enum
-
generativity
Generation of unique invariant lifetimes
-
dync
An efficient alternative to
dyn Trait
for containerized types -
rustversion
Conditional compilation according to rustc compiler version
-
cl-format
Use Common Lisp format in Rust
-
hooks
Compile-time, async hooks
-
cel-interpreter
An interpreter for the Common Expression Language (CEL)
-
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
semval
Semantic validation
-
ra_ap_stdx
TBD
-
with_locals
Function attribute to return references to locals by using CPS
-
try_match
An expression macro to match a pattern and return the bound variables in
Result
-
rutie
The tie between Ruby and Rust
-
buildstructor
Macro to derive a builder from a constructor function
-
socketpair
Cross-platform socketpair functionality
-
unwinding
in Rust and for Rust
-
data-rw
io buffer write reader
-
nanvm
NaN VM
-
arrow-cast
Cast kernel and utilities for Apache Arrow
-
entrait
Loosely coupled Rust application design made easy
-
soa_derive
Automatic Struct of Array generation
-
ruva
Event Driven Message Handling
-
funty
Trait generalization over the primitive types
-
tryhard
Easily retry futures
-
jnix
High-level extensions to help with the usage of JNI in Rust code
-
bilge
Use bitsized types as if they were a feature of rust
-
copyless
Ways to eliminate memcpy calls when using the standard library
-
tokenlock
cell types that decouple permissions from data
-
deptypes
Dependent types
-
snowflaked
creating and working with snowflake ids
-
naan
A fast, easy, and tasty functional programming prelude
-
simple-mermaid
Mermaid diagrams RustDoc integration
-
cowstr
Copy-on-Write shared strings
-
windows-targets
Import libs for Windows
-
atom
A safe abstraction around AtomicPtr
-
rust-fsm
A framework for building finite state machines in Rust
-
more-di
support for dependency injection (DI)
-
swipl
A high-level library for building SWI-Prolog extensions and embedding SWI-Prolog in rust applications
-
iter-chunks
Extend Iterator with chunks
-
sugars
An useful collection of macros to make tasks easier
-
downcast
Trait for downcasting trait objects back to their original types
-
easy-cast
Type conversions which are expected to succeed
-
chainerror
Make chaining errors easy
-
proc-bitfield
expressively declare bitfield-like structs
-
thiserror-no-std
derive(Error)
-
zoet
Adds
#[zoet]
macro to reduce boilerplate when implementing common traits -
itermore
🤸♀️ More iterator adaptors
-
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
wallee
Flexible concrete Error type built on std::error::Error with caller location tracking
-
anyerror
A type of any error for transport
-
o2o
Object to Object mapper for Rust. Derive 'From' and 'Into' traits.
-
enum-display
A macro to derive Display for enums
-
drop_bomb
A runtime guard for implementing linear types
-
reborrow
Emulate reborrowing for user types
-
display-error-chain
Formats a standard error and its sources
-
inline-c
Write and execute C code inside Rust
-
carboxyl
functional reactive programming
-
rudi
out-of-the-box dependency injection framework for Rust
-
flex-error
Flexible error definitions using macros and traits
-
const-field-offset
Wrapper around field-offset crate and const-field-offset-macro
-
ropr
A blazing fast multithreaded ROP Gadget finder. ropper / ropgadget alternative
-
smarterr
Smart error handling library
-
components-arena
creating complex domain-specific self-referential data structures
-
bellframe
Fast and idiomatic primitives for Change Ringing
-
crony
cron runner that spawns another thread to run your cron jobs
-
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
-
dylint_linting
writing Dylint libraries
-
orx-closure
An explicit closure with absolute seperation of the captured data from the function
-
exponential-backoff
A small and flexible backoff function
-
fp_rust
Implement fp features for Rust
-
condtype
Choose types at compile-time via boolean constants
-
codegen
generating Rust code
-
soapy
Structure-of-arrays derive macro
-
macro-attr-2018
macro_attr!
macro that enables the use of custom, macro-based attributes and derivations -
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
defer
excecution of code, inspired by go's defer statement
-
wipe-on-fork
A replacement to OnceCell, LazyCell, Once, OnceLock, LazyLock that wipes itself when being forked in Unix
-
intern-arc
An interner that deallocates unused values
-
fatality
extension to
thiserror::Error
-
expunge
redact and transform struct fields declaratively
-
qualifier_attr
Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_parts
andVec::into_raw_parts
-
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
random-number
Generate random numbers quickly
-
tinyvec_macros
Some macros for tiny containers
-
indexed_valued_enums
Create enums resolving into values, and get their variants back through their values or their discriminant, inspired by Java
-
atc-router
Versatile DSL based rule matching engine used by the Kong API Gateway
-
overload
macro to simplify operator overloading
-
wrap-match
A procedural macro to wrap a function in match statement to make error logging super easy
-
olis_string
Small-string optimization for Rust, aims to replace std::string::String
-
null-kane
currency crate with the option to add your own currency localization logic
-
concat-with
Extend the function of the
concat!
macro instd
-
sealed
Macro for sealing traits and structures
-
rustc_utils
working with the Rust compiler
-
capture-it
Modern c++-ish capture syntax for rust
-
globals
Painless global variables in Rust
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
twitch_types
common types for Twitch
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
sudo_plugin
Macros to easily write custom sudo plugins
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
self-rust-tokenize
Turns instances of Rust structures into a token stream that creates the instance
-
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
-
awint_macro_internals
Internal macro utilities for the
awint
system of crates -
pi_null
define trait is named Null. u8,u32,u64,Option...is implements Null
-
mapper
Mapping macro to help to reduce mapping boilerplate
-
radiation
Convert Rust type into raw bytes and vice versa
-
struct-field-names-as-array
generating the field names of named structs as constants
-
sosecrets-rs
Secret
wrapper type that reveals the secret at mostMEC: typenum::Unsigned
times with compile time guarantees -
lib_aoc
trait-based framework for the annual Advent of Code programming challenge
-
ambient-authority
Ambient Authority
-
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
simple-error
error type backed by a string
-
mydi
MyDI. Dependency Injection library
-
indicator
Abstractions for stream aggregation, we call them
Indicator
s -
tuplex
Rust tuple extension
-
devise
devising derives and other procedural macros
-
rust2fun
functional programming in Rust
-
funcmap
Derivable functorial mappings for Rust
-
blanket
macro to derive blanket implementations for your traits
-
nbio
Non-Blocking I/O
-
tupletools
functions for tuples
-
bash-builtins
implement loadable builtins for bash
-
yup-hyper-mock
testing clients using hyper
-
pared
Projected reference counted pointers
-
conv
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
culpa
error-handling syntax in Rust
-
auto_enums
allow multiple return types by automatically generated enum
-
leptos-mview
A concise view macro for Leptos
-
devela
A cohesive Rust development layer
-
quick-error
A macro which makes error types pleasant to write
-
destructure_traitobject
Unsafe helpers for working with raw trait objects. (Forked from traitobject)
-
syrette
The convenient dependency injection framework
-
value-box
Allows developers to pass Rust-allocated structures over ffi
-
ra-ap-rustc_index
Automatically published version of the package
rustc_index
in the rust-lang/rust repository from commit c8f0d492a74efd98df11287108b7f68c76d937dc The publishing script for this crate lives at:… -
closure_example
A short description of my package
-
coi
Dependency Injection library
-
sugar_path
Sugar functions for manipulating paths
-
version-sync
ensuring that version numbers in README files and other files are kept in sync with the crate version
-
bma-benchmark
Benchmark for Rust and humans
-
zzz
Fast progress bar with sane defaults
-
collate
Traits and a data structure to support collation and bisection
-
inline-python
Inline Python code directly in your Rust code
-
proto-mapper
A Macro library for easier mapping between custom models and proto generated code
-
shared_singleton
trait provides singleton pattern state management with shared container
-
iter-comprehensions
iterator comprehensions
-
dilib
A dependency injection library for Rust
-
docsplay
A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc
-
functor_derive
A derive macro to derive a functor for a type
-
nameof
macro to determine the string name of a binding, type, const, or function
-
dyn-dyn
Flexible trait object downcasting using ptr_metadata
-
timelang
A DSL (Domain Specific Language) and grammar for parsing and rendering human-readable date/time and duration values
-
strong-type
Procedural macros for naming and strong-typing pritimives and strings
-
custom-format
Custom formatting for Rust
-
format-bytes
A macro to format bytestrings
-
ghost
Define your own PhantomData
-
retry-error
An error type for an operation that can fail more than once
-
copy_from_str
An extension trait to copy a string into another string
-
lmml
LMML Music Macro Language
-
iterator-sorted
Stable functions for checking iterator sorting
-
fauxgen
write your own generators in stable rust
-
gen_ops
Macros for operator overloading for generic types
-
auto_ops
Macros for easy operator overloading
-
chasa
A parser combinator with
many
taking iterator, conditional branching, and method chain -
bool_ext
defines and implements a complete set of
Option
/Result
-style Boolean functional combinators on Rust’sbool
primitive type -
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
dialogue-macro
An extension to dialoguer that simplifies command-line interaction interfaces
-
lazycell
providing a lazily filled Cell struct
-
structural-convert
Derive conversion traits (From, Into, TryFrom, TryInto) when fields are structurally similar in enums or structs
-
by_address
Wrapper for comparing and hashing pointers by address
-
rtoolbox
functions for other crates, no backwards compatibility guarantees
-
generics
macros for parsing generics (with optional where clause) in
macro_rules!
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
index-ext
Index slices with arbitrary ints and as arrays
-
egui_struct
EguiStruct is a rust derive macro that creates egui UI's from arbitrary structs and enums
-
steel-core
Core compiler and VM implementation for steel
-
moonshine-spawn
A lightweight spawn utility for Bevy
-
crustal
generating C/C++ code
-
orfail
Error handling library for portable unrecoverable errors
-
ownable
Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
aerosol
dependency injection for Rust
-
armc
that facilitates Mutex access to variables
-
interned
generic Interned<T> which can intern practically any type including &str, slices, and primitives, plus memoization via Memoized<I, T>
-
nolife
open a scope and then freeze it in time for future access
-
void
The uninhabited void type for use in statically impossible cases
-
overloaded_literals
Overloaded Literals to construct your datatypes without boilerplate and with compile-time validation
-
fiberplane-pdk
Fiberplane Provider Development Kit
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
methods-enum
Two macros for easy implementation of 'state' design pattern and other dynamic polymorphism using enum instead of dyn Trait
-
nade
Adding named and default arguments to Rust functions
-
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
cynic-querygen
Generates code for using cynic from GraphQL query input
-
dolby_vision
Dolby Vision metadata parsing and writing
-
cursive-extras
Extra views for the Cursive TUI library as well some helper functions and macros
-
ff_ce
building and interfacing with finite fields
-
prima_bridge
implement the bridge pattern
-
intuple
Convert structs and enums into tuples (of refs) and back - recursive, ignore fields
-
derive_destructure2
Destructure structs that implement Drop
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
cve-rs
Blazingly fast memory vulnerabilities, written in 100% safe Rust
-
ice_code
A macro to mark code paths as cold, allowing the common case to be inlined
-
derive_constructors
Deriving From, TryFrom and create new_with_*args* functions
-
qed
Compile-time assertions
-
macon
builder macro-based generator with its own idioms
-
frayed
Unfused and unashamed iterators
-
model-mapper
Derive macro to map between different types
-
rcss-layers
Part of Rust CSS embedding library that allows saving styles as seperate layers
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
ra_ap_hir_expand
TBD
-
hs-bindgen
Handy macro to generate C-FFI bindings to Rust for Haskell
-
r3bl_redux
Redux library built using Tokio, concurrent & parallel
-
garde-fr
Validation library
-
byondapi
Idiomatic Rust bindings for BYONDAPI
-
merge
multiple values into one
-
thiserror-nostd-notrait
derive(Error)
-
ex_em_ell
Provide macros for serializing and deserializing XML
-
gramma
Generate a scannerless parser by declaring types
-
set_derive
Using Macros to Implement List comprehension Similar to Python Language
-
shard-ecs
The Shard Entity Component System
-
chassis
Compile-time dependency injection framework
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>
to simplify your code -
phantom-type
A
PhantomData
analog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData
-
ffi_helpers
help make working with FFI easier
-
cexpr
A C expression parser and evaluator
-
genrc
refcounted pointer type that allows subobject pointers
-
first-err
Find the first Err in Iterator<Item = Result<T, E>> and allow iterating continuously
-
openapi_type
OpenAPI type information for Rust structs and enums
-
io-streams
Unbuffered and unlocked I/O streams
-
structx
Simulating anonymous struct and named arguments in Rust
-
safe-transmute
A safeguarded transmute() for Rust
-
singleton-manager
A programatical singleton manager
-
valued-enums
Macros collection and specify trait for creating valued or python-like enums
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
include-flate
A variant of include_bytes!/include_str! with compile-time deflation and runtime lazy inflation
-
argp
Derive-based argument parser optimized for code size
-
crevice_notan
Create GLSL-compatible versions of structs with explicitly-initialized padding
-
dispose
wrapper for values that must be consumed on drop
-
dpc-pariter
Parallel iterator processing
-
ref_wrapper
Wrapper of dynamically borrowed data
-
intertrait
Allow for inter-trait casting
-
munge
Macro for custom destructuring
-
type_cell
Attach values statically to a type using static get/set methods
-
panic-analyzer
an audit tool to scan your crate or workspace searching for potential panic points in your codebase
-
itermap
Iterator tools for maps (
HashMap
,BTreeMap
, etc.) -
pipe-trait
possible to chain regular functions
-
dynarg
mechanism for dynamic robust argument handling
-
cooked-waker
A safe interface for creating async Wakers
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
burrtype
A framework for exporting types to other languages
-
assert_matches2
A version of the assert_matches! macro that brings variables from the pattern into scope
-
gat-lending-iterator
iterators who's items can [mutably] reference the iterator
-
railsgun
Excessive tooling for Result handling - If you want rails you got RAILS!
-
ungrammar
A DSL for describing concrete syntax trees
-
custom_float
Custom floating-point types
-
objid
Generate a random object identifier
-
renege
Tracking cache validity using fast concurrent invalidation propogation
-
sodium
FRP (Functional Reactive Programming)
-
parsel
Zero-code parser generation by using AST node types as the grammar
-
collection_literals
macros for initializing std::collections
-
mini-macro-magic
Export tokens to other modules and crates. Now with 100% less proc macros!
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
rust_examples
rust 的学习中的一些例子
-
range_checker
derive-macro crate aimed to provide declarative bounds checking and filtering for structure
-
evcxr_repl
A REPL for Rust
-
problem
Error handling for command line applications or prototypes
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
documented
Trait and derive macro for accessing your type's documentation at runtime
-
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
-
nu-std
The standard library of Nushell
-
consclr
console text colorful
-
maybe-single
A singleton. Maybe.
-
ownedbytes
Expose data as static slice
-
bump-into
a no_std bump allocator sourcing space from a user-provided slice
-
soa-rs
A Vec-like structure-of-arrays container
-
copstr
COpy STRing module
-
rust_info
Extracts the current rust compiler information
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
flexi_func_declarative
exposes the fb! macro to create a function with a flexible signature
-
simplicio
Gets rid of the boilerplate in rust
-
binread
helping read structs from binary data using ✨macro magic✨
-
lemurs-8080
An emulator for the Intel 8080 microprocessor
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
ort_custom_op
writing custom operators for the onnxruntime in Rust
-
deltoid
calculate and apply deltas to structs and enums
-
jnat
A wrapper around the jni crate
-
lyneate
beautiful code underlining and error reporting
-
list_comprehension
A macro for Haskell-like list comprehensions in Rust
-
simple_parse
A declarative converter for Rust type to and from binary
-
vcell
Cell
with volatile read / write operations -
airbag
handling errors and panics using 3rd party services
-
subplotlib
functions and types for
subplot codegen
generated Rust based test suites. Relies onsubplotlib-derive
for associated macros. -
typed-sql
A strongly typed sql serialization/deserialization framework
-
benri
Convenient macros wrapping the standard library
-
peak-result
trait that extends the standard Result enum to allow you to run some code in case of error or success
-
chandeliers-sem
Semantics of Candle, a shallow embedding of Lustre in Rust
-
algorithmify
Create specifications for algorithms defined using Rust code
-
irox-enums
Traits for better Enumerated Types
-
element-ptr
A macro to make accessing elements through raw pointers easier
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
cap-std-ext
Extension APIs for cap-std
-
cock-lib
Measure the power level of a peen
-
sod-actix-web
Service Oriented Design - Actix Web
-
soulog
polished, clean and colourful console logging and error handling
-
mode
A behavioral state machine library written in Rust
-
stack-vm
A generic, reusable, stack-based virtual machine
-
outref
Out reference
-
surrealdb-extras
additional functionality for working with SurrealDB
-
swift-bridge-build
Parse Rust files for swift-bridge modules and generate the corresponding Swift and C code for them
-
typeables
type aliases. By SixArm.com.
-
easy-error
error utilities
-
flaky_test
atttribute macro for running a flaky test multiple times
-
rs_envflag
An easy way to define flags by environment variables
-
more-itertools
python more-itertools
-
hex_lit
Hex macro literals without use of hex macros
-
never
A stable version of the unstable never type (!)
-
append-only-bytes
Shareable append-only bytes
-
error-iter
Error::sources on stable Rust
-
arrow-udf-js
JavaScript runtime for Arrow UDFs
-
macroex
An extractor based low level macro parsing crate that provides high level parsing support through derive macros
-
tighterror
A minimalistic error representation framework
-
sqlx_query
Expands to either sqlx function
query
or macroquery!
call depending onsqlx_compiletime_checks
has been enabled during the build -
cargo-cabal
that helps you to turn in one command a Rust crate into a Haskell Cabal library
-
thiserror-ext
Useful extension utilities for
thiserror
-
fmap
Functors in Rust
-
colourado-iter
A small and minimalistic library to generate a random color palette of infinite size
-
random_variant
To be used with all variant, contains the derive macro
-
expression_engine
An expression engine written in pure rust
-
rdftk_names
set of modules that contain the
IRI
s andQName
strings for commonly used vocabularies. It also provides macro support for defining new namespaces in the same style as this library. -
remit
Rust generators implemented through async/await syntax
-
glam-traits
Traits for the vectors in glam
-
ucsi
SI-based unit typing system
-
cond
Rust macro to use a match-like syntax as an elegant alternative to nesting if-else statements
-
ddi
Dynamic dependency injection library for rust
-
pergola
abstract types for join-semilattices
-
avocado-schema
A schema DSL which can be interpreted to implement multiple purposes
-
enumeration
An extension to rust enum
-
andex
Safe, strongly typed array indexes and wrappers for rust with zero dependencies
-
ascent_base
support library for the ascent package
-
smallvec-wrapper
Macro and common structs to play with
smallvec
-
hermit-sync
Synchronization primitives for kernels
-
getfn
generating function pairs to refer to functions via custom expressions
-
seqgen
Sequence generation library
-
conv2
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
opentalk-kustos-prefix
Derive macro for defining kustos prefix
-
hyperide
Builds strings from embedded HTML in Rust
-
calendrical_calculations
Calendrical calculations in Rust
-
pinned-init
facilitate safe pinned initialization
-
goof
A reusable, composable, aggregate and
no_std
-friendly error library -
enum_common_fields
Macro for easy access to common fields of enums
-
funkjon
One of the worst macros this world has ever been (dis)graced with
-
traitsequence
Traits to abstract over sequences
-
bossy
Opinionated convenience wrappers for
std::process::Command
and friends -
friperms
framework for creating typed permission models for whatever system you could phatom
-
is-odd
Returns true if the given number is odd
-
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
-
accursed-unutterable-type-id
A worse version of std::any::TypeId
-
closure
A macro for capturing variables on a per variable basis
-
c-types
Re-exports of cross-platform types, gathered from libc and winapi
-
combin-iterator
Some usefull facilities for combining iterators
-
certain-map
A typed map which can make sure item exist
-
pathbuf
A macro to conveniently build PathBufs
-
implementation
The implementation crate
-
cast
Ergonomic, checked cast functions for primitive types
-
rrplug
wrappers and functions for R2Northstar plugins
-
opaque_typedef
Supports defining opaque typedefs
-
retrying
General-purpose retrying library for Rust with macros and functions
-
pegination
cursor pagination
-
as_num
Checked conversions between Rust's numeric types
-
aoc_driver
helper macros and functions for AoC
-
arch-into
safe type conversions between pointer-sized types (usize/isize) and types with fixed size
-
TSPL
The Simplest Parser Library
-
simple-logging
logger for the log facade
-
refl
refl
encoding 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 -
conerror
macro that automatically adds context to errors
-
janus-plugin
creating plugins for Janus, the WebRTC gateway
-
elor
Base generic implementation of an Either type
-
turbostate
Finite State Machine
-
surreal_devl
Contains core logic of surreal derive
-
preprocess
Preprocesses a struct with built-in preprocessors
-
extended-primitives
providing primitive-like types for use
-
defile
Proc-macro helper to ungroup macro metavariables
-
binf
that adds utilities for dealing with binary flags
-
expect-exit
Result.expected(): display an error message and exit without a panic
-
dioxus-class
Dioxus class
-
zerror
error interface for context-aware error-reporting
-
cflp
A context-free-language parser generated by procedural macros
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
ux2
Non-standard integer types like
u7
,u9
,u10
,u63
,i7
,i9
etc -
take-until
A take_until extension for iterators
-
lichen
Scripting DSL (for Dialogue Graphs, et al)
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
permeable
A permission-demand trait. Decouples the permission-demander from the permission / auth provider.
-
pusherator
Push-based version of Rust iterators
-
will_exit
work on program will exit
-
thisctx
Easily create error with contexts
-
genmesh
A package for generating 3D meshes
-
lucchetto
easily call a rust function without holding the GVL lock
-
explicit-endian
Transparent traits to explicitely declare in-memory endianness for a virable or struct record
-
illicit
An implicit thread-local environment which is indexed by type
-
type-sets
Sets implemented in the rust type-system
-
partially
Partial trait, and an optional macro to mirror a struct, wrapping each field in an Option
-
rustcomp
Adds vector, map, set, and iterator comprehensions to Rust
-
jealousy
A wrapper arount the envy crate, providing an easily implementable trait
-
error-info
Centralized error information ready for internationalization
-
term_grid
formatting strings into a grid layout
-
custom_derive
(Note: superseded by
macro-attr
) This crate provides a macro that enables the use of custom derive attributes -
failed-result
A small crate for converting various failed value to result with corresponding error type
-
hubpack
A predictable serialization format
-
even_bigger_s
Better String Literal
-
nougat
(lifetime) GATs on stable Rust
-
io-close
An extension trait for safely dropping I/O writers such as File and BufWriter
-
cfg-iif
A macro for defining
#[cfg]
if-else
functions -
core_float
based on the Rust Core Library and aims to provide an identical set of APIs for f32 and f64 floating-point types
-
polars-utils
Private utils for the Polars DataFrame library
-
option-ext
Extends
Option
with additional operations -
rc-box
Known unique versions of Rc and Arc
-
re_tuid
128-bit Time-based Unique Identifier
-
asm_block
Translate tokens to string for Rust inline assembly
-
panda-re
The official library for interfacing with PANDA (Platform for Architecture-Neutral Dynamic Analysis)
-
progress-streams
Progress callbacks for types which implement Read/Write
-
tosserror
derive(Toss)
-
safecast
Traits to define safe casting between types
-
unwrap_or
Four easy unwrap Result and Option macros that allow for any inline-scoped code for things like return, continue, and break
-
macro-asm-builder
macro-assemblers
-
ddd-rs
Domain-Driven Design (DDD) building blocks, for Rust applications
-
const-default
A const Default trait
-
algar
Algebraic structures, higher-kinded types and other category theory bad ideas
-
portrait
Fills an
impl
with the associated items required by the trait -
nova
Macro to derive newtypes with support for serde and sqlx
-
cstr-argument
A trait for converting function arguments to null terminated strings
-
type_description
Machine-readable type descriptions
-
macro-bits
performing macro-based bit manipulation
-
winconsole
A wrapper for console-related functions in the Windows API
-
add_macro
adds the some useful macros for easily work
-
psl-types
Common types for the public suffix implementation crates
-
tor-basic-utils
General helpers used by Tor
-
ferment
Syntax tree morphing of FFI-compatible stuff
-
recvmsg
Traits for receiving datagrams reliably, without truncation
-
bitty_write_macro
A drop-in
write!
replacement that optimizes non-formatting writes for code size -
rdcl_aoc_helpers
Helpers for Advent of Code
-
assume
Macro for stating unsafe assumptions in Rust
-
type_enum
Create tagged unions consisting of different types
-
fixnum
Fixed-point numbers with explicit rounding
-
kinded
Generate enums with same variants, but without data
-
openai-func-embeddings
A companion crate for async-openai to ease the composition of function calls by leveraging Rust's type system and enums
-
engineer
master builder!
-
impl-tools-lib
Helper macros: autoimpl
-
frunk_laws
contains laws for algebras declared in Frunk
-
lexi-matic
A Lexer Library
-
descriptive_toml_derive
Procedural derive macro for serializing a struct into a TOML template with field descriptions that is easily edited and deserialized
-
konst_macro_rules
detail of the konst crate
-
netherite
A tokio implementation of the Minecraft Protocol with derive macros
-
tuplify
Generic hlist/tuple library
-
prev-iter
Iterator which allows you to view the previous element
-
error_handling
Macro used to clean and centralize error handling within async processes
-
enumn
Convert number to enum
-
rsconnect
Fine-grained reactivity in Rust
-
htmxpress
Procedural macros for generating htmx strings
-
nshare
Conversion between n-dimensional types in different Rust crates
-
cast_checks
A procedural macro to check for invalid casts
-
fmt-derive
A more robust and versatile derive macro for Debug and Display
-
vitasdk-sys
Raw bindings to vitasdk
-
brug
enum command generation for implementation blocks
-
vsprintf
Rust bindings to the libc vsprintf function
-
no_std_strings
no_std version of crate fixedstr: strings of constant maximum size that can be copied and stack allocated
-
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
vmm
A math library focused on vectors and square matrices
-
callable
closures implementing PartialEq and argument operations
-
const-units
that lets you check the dimensions of your quantities at compile time and run time
-
rawpointer
Extra methods for raw pointers and
NonNull<T>
. For example.post_inc()
and.pre_dec()
(c.f.ptr++
and--ptr
),offset
andadd
forNonNull<T>
, and the functionptrdistance
. -
kittycad-execution-plan-traits
Types for KittyCAD execution plans
-
fmu_from_struct
A derive macro for automatically setting up FMU models in Rust
-
cryptify
A procedural macro library to obfuscate Rust code. Provides compile-time string encryption and random flow obfuscation.
-
erasable
Type-erased thin pointers
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
igc_parser
A high-level parsing/deserializing crate for IGC flight recorder files
-
frunk_utils
working with frunk
-
inline_dyn
A container type for storing dynamically-sized types inline
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
partial-default
PartialDefault, a trait similar to Default but with fewer guarantees
-
tf2-enum
enumerated types for models related to the Team Fortress 2 item schema
-
mstr
2-word, immutable Cow<str>
-
type-fn
Allows for simpler coding of type-level logic, e.g. for type-number systems.
-
ordes
treating arrays and tuples a little bit more like vectors
-
range-cmp
Trait that allows comparing a value to a range of values
-
tupley
Extension for primitive tuple (Hlist based on recursive structure)
-
throwing
Create explicit errors easily with a handy macro
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
effective
An effects library, an alternative to keyword generics
-
check_keyword
A trait for String-like types to check if it is a reserved keyword and convert it to a safe non-keyword if so
-
bezier_easing
port of Gaëtan Renaudeau's bezier-easing from https://github.com/gre/bezier-easing
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
try-unwrap
A revolutionary new crate that allows you to unwrap() without making your stupid software panic
-
human-errors
An error library focused on providing your users with relevant advice for any problem
-
round
your floats with precision from 1 to 10
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
accountable-refcell
A RefCell wrapper that provides actionable information for dynamic borrow failures
-
case_insensitive_string
A case insensitive string struct
-
tc-error
TinyChain's generic error struct
-
partial_application
partial function application via the partial! macro
-
typestate
A proc macro DSL for typestates
-
scale-typegen
Type Generation for SCALE encoded Rust Types
-
syllogism
allow for some specialization using stable Rust
-
filters
Build filters/predicates with the builder pattern
-
type-safe-id
A type-safe, K-sortable, globally unique identifier
-
chisel-common
Chisel common macros, types and functions
-
sitrep
Frontend-agnostic progress reporting
-
capnp_conv
capnp write/read traits to convert from structs to readers/builders
-
assert-eq-float
assert_eq_float!
macros that support floats -
gerber-types
Types and code generation for Gerber files (RS-274X)
-
seoul
trait Isomorphism
-
impls
Determine if a type implements a logical trait expression
-
graphannis-capi
C-API to the ANNIS linguistic search and visualization system
-
fileslice
Slices of files
-
xx
A collection of useful Rust macros and small functions
-
version
A very simple library who's job is to return the version of your crate if you're building with Cargo
-
swapbytes
swapping the endianess of structures
-
iprint
debugging utility that prints indented text based on function call depth
-
onechatsocial-result
Revolt Backend: Result and Error types
-
ftkit
A small set of utilities for newcomers learning Rust
-
static_assertions_next
Compile-time assertions to ensure that invariants are met
-
count-to-non-zero
Extends Rust’s Iterator trait to include a
count_to_non_zero
method, returning an Option for a more expressive and type-safe way of counting elements. This crate provides… -
apply_conditionally
Chain and apply methods on objects conditionally
-
introspect-core
containing the core functionality used for
introspect
and supporting crates -
tartan-bitfield
Define structures with accessors for particular bits or bit ranges
-
as-is
An abstraction over ownership
-
neoncore
Core utility library for working with binary data streams
-
codes-agency
This package provides a common code representing standards agencies
-
term-inquiry
Quick and easy way to make terminal inquiries using builder pattern
-
str-macro
The str!() macro, similar to vec![] but for strings
-
checked-float
making invariant-enforcing floating point wrappers
-
with_drop
Nostd wrapper for using a closure as a custom drop function
-
gs11n
Utililties need for GS11N
-
openai-magic-instantiate
Use LLMs to instantiate well-typed values
-
windows-helpers
Helpers for the windows crate
-
loupe
Profiling tool for Rust
-
derive_environment
modifying structs via environment variables
-
hotswap
Easy code swapping in running executables
-
summum-types
A sum-type macro crate with all the conversions, accessors, and support for abstract methods across variants, and interoperability between sum-types
-
newstr
macros for declaring String-base new types
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
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…
-
assert_unordered
A direct replacement for
assert_eq
for unordered collections -
range_check
bounds-checking and range helpers
-
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
gull
type generation
-
enum-ptr
Ergonomic tagged pointer
-
html_tag
An Enigmatic Way to use HTML in Rust
-
runestr
User-perceived characters related types and data structures
-
multer-derive
derive for constructign type from multer Multipart
-
name-it
Give a name to async fn return types
-
dyn-eq
Test equality between trait objects
-
derive-enum-from-into
Derive for From and TryInto for enums with single fields
-
ra_ap_hir_def
TBD
-
elain
Set a type's minimum alignment with const generics
-
any_cmp
Support dynamic type comparisons
-
shoulda
derive macro for test assertions
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
nz
Collection of 100% safe macros for creating core::num::NonZero{Integer} types more easily
-
replace_err
Adds a
replace_err
method toResult
which throws away the current error and replaces it -
iter-identify_first_last
A helper iterator, flagging first and last elements
-
apparat
A lightweight event-driven behavioral state machine
-
jkcenum
Rust enum library
-
trait-gen
Trait implementation generator macro
-
reductor
Generic abstractions for combining and nesting reduction patterns for iterables
-
ra_ap_span
TBD
-
type-handle
Regular and reference-counted type handles
-
simple-life
async lifecycle trait and convenient macros
-
unroll_range
Repeats a block of code for each number in a specified range
-
aquamarine-demo-crate
A demo crate for aquamarine -- the mermaid.js integration for rustdoc
-
dyn-context
mechanism for lifetimes erasing
-
io-arrays
Random-access I/O
-
oxi-types
Rust bindings to types used by Neovim's C API
-
timed
Macros to time function execution
-
retoken
Build &str tokenizers using regex
-
bitbag
A useful struct for dealing with bit flags
-
value_unit
every unit imaginable. Also contains a handy macro
-
ffizz-header
FFI helpers to generate a C header for your library
-
tokio-go
a golang like macro: go! (closure) backed by tokio. Supports threadpool dedication.
-
gobble
A Combinator based parser for strings that gets out of the way, and leaves your code looking like a grammer
-
memtable
Inmemory tables for use in Rust
-
maplit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
aprox_eq
determining aproximate equality between floating point types and deriving this capability to struct comprised of floating point numbers
-
advancedresearch-path_iter
A cocategory enumeration library based on path semantics
-
e
Provide some utility tools
-
cast_trait_object
Cast between trait objects using only safe Rust
-
early_returns
Macros to make early returns easier to work with in Rust
-
interning
Thread-Lcoal and Global Interning Library
-
structmap
Procedural macro library for converting between Rust structs and associative containers
-
clone_cell
A Cell that works with a restrictive form of Clone
-
merge-hashmap
Merge multiple values into one
-
ref-ops
An escape hatch for implementing
ops
traits for references to newtypes -
tremor-common
Tremor common functions
-
oop
Object-Oriented Inheritence in Rust
-
hexchat-plugin
Lets you write HexChat plugins in Rust
-
rayleigh_macro
Macros for the rayleigh crate
-
chalk-macros
Macros for Chalk
-
event-listener-primitives
Low-level primitive for building Node.js-like event listeners
-
ointer
Steal the high bits of a pointer to store an extra value
-
namewise
Derived trivial name-wise conversions for Rust types
-
dyn-clonable
Attribute wrapper for dyn-clone
-
cdc
performing Content-Defined Chunking (CDC) on data streams
-
autofolder
Single-element folding wrapper
-
head-tail-iter
An iterator that repeatedly splits head & tail
-
precomputed-hash
intending to be a base dependency to expose a precomputed hash
-
mist-pdk
mist plugin development kit
-
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
-
rt-format
Fully-runtime equivalent of the format! macro
-
direction
Representations of directions
-
qbdi-sys
QBDI library rust binding (use rust bindgen)
-
internal
fields in Rust
-
wherr
Enhance Rust errors with file and line details using the
#[wherr]
macro for clearer debugging -
typemap-meta
compile-time macro to create type-to-value maps
-
aoko
extension library
-
mongo_indexed
derive macro to declaratively index mongo collections
-
const_fn
An attribute for easy generation of const functions with conditional compilations
-
named-tup
Create named tuples using the tup!() macro
-
to-syn-value
Defines a derive macro to implement a trait converting values to instances of syn::ToDeriveInput
-
almost
comparing floating point numbers
-
nonicle
Tools for type-safe, canonical data representations
-
macroland
macro shorthands of various types in Rust
-
hrbf
Hermite Radial Basis Functions with higher order derivatives
-
intern-all
A safe and predictable interner for data of mixed and arbitrary type
-
rvs
defining and evaluating random variables using a simple DSL
-
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
light_enum
provide a derive keyword to generate a light enum
-
shaku
Compile Time Dependency Injection for Rust
-
softfloat-sys
Rust bindings for Berkeley SoftFloat 3
-
cron_macro
cron macro
-
plain_hasher
Hasher for 32-byte keys
-
vmprotect
Unofficial VMProtect SDK for Rust
-
variadics
Variadic generics on stable Rust using tuple lists
-
enum_index
Trait and macros for extracting Enum variant index
-
get-field-by-type
Get a value of field, based on the type of a field
-
wave_func_collapse
wave function collapse algorithm
-
adventage
Advent of Code, easier!
-
standalone-syn
Fork of syn that turns of the proc-macro feature in proc-macro2 and standalone-quote so as to remove the rustc dylib dependency
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
pyadvreader
Split text file into text sequences, strings and (line) comments
-
maybe-uninit
MaybeUninit for friends of backwards compatibility
-
ra_ap_hir_ty
TBD
-
re_error
Helpers for handling errors
-
positional
author/parse positional files
-
asserteq_pretty
An assert_eq macro that prints more helpful diffs on mismatch
-
pathext
A small path trait extension with some convenience methods
-
astr
A const lenght stack str
-
read_buffer
ReadBuffer, a wrapper to safely read into a buffer from a Read
-
primitive-from-enum
macros for get primitive enum from complex
-
reax
A reactivity system for Rust that infers dependencies between functions
-
json-query
Run jq programs to extract data from json strings
-
iter-progress
Calculate progress of your iterators
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
vec_vec
When dealing with
Vec<Vec<T>>
is unavoidable -
lazy-init
Lazy initialization
-
eventmill
Event sourcing and CQRS for Rust applications
-
entrance
A command line argument parser library which provides type assisted tools
-
tao-of-rust
《Rust编程之道》随书源码
-
rnet
Easily call into Rust from C# or other .net langauges
-
autoproto
Replacement derive macros for
prost::Message
, and supporting traits and types to make implementing this trait easier -
slice-utils
A collection of slice utils, like itertools
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
thin_cstr
An experimental crate which provides a truly thin std::ffi::CStr
-
cfg-or-panic
Replace function bodies with
unimplemented!()
when condition is not met -
mat-rs
no_std implementation of mathematical matrix types
-
trait_cast_rs
Get your own Any with support for casting to trait objects
-
yansongda-utils
rust 中一些关于我自己的常用工具
-
dyn_ord
Equality and ordering for trait objects
-
field33_rdftk_names_temporary_fork
set of modules that contain the
IRI
s andQName
strings for commonly used vocabularies. It also provides macro support for defining new namespaces in the same style as this library. -
forward-traits
A general trait-forwarding crate
-
coded
concrete error type with an
ErrorKind
enum matching Google’s “canonical error codes” -
width_counters
Atomic counters with variable bit widths and customizable atomic ordering
-
squeak
providing types allowing execution of callbacks in response to values being broadcast or mutated
-
value-enum
Macro for generating enums associated with values
-
iterpipes
Compositional, pipes-style stream processing
-
borrowme
The missing compound borrowing for Rust
-
mightrix
treat continous memory as a matrix
-
match
in rust
-
jmespath_community
JMESPath is a query and transformation language for JSON
-
sod
Service Oriented Design
-
k8s-controller
lightweight framework for writing kubernetes controllers
-
enum-assoc
Procedural macro to associate constants with enum variants
-
oofs
Error handling library that generates and injects context for you
-
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.
-
ebacktrace
error wrapper which captures a backtrace and can carry an optional textual description
-
lootr
RPG-like looting system
-
partial-borrow
Partially borrow a struct
-
thread-scoped-ref
that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
async-iterator
An async version of iterator
-
roopert
object-oriented toolkit for Rust
-
moddef
Macros for convenient nested module structure declaration
-
lazy_thread_local
Lazily initialised per-object thread-local storage
-
rtlola-hir
A high-level intermediate representation for RTLola specifications
-
tupperware
Storage traits for your types
-
polyline-ffi
FFI bindings for the polyline crate
-
try_utils
The try! macro descends into an enum variant. It's more flexible than ? and unwrap(), and it works with your enum, too!
-
struct_scheme
structure scheme display
-
genz
Uniqueness of types via invariant lifetimes
-
libipld-macro
ipld macro
-
gur
A undo-redo framework
-
okey
Everything is Result::Ok
-
scientisto
A light-weight Rust implementation of the github/scientist library used for careful refactoring of critical code paths
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
lsdata
LSD (Less Syntax Data) configuration/data transfer format
-
cli_input
Various functions for gathering user input in the terminal
-
os-thread-local
OS-backed thread-local storage. This crate provides a
ThreadLocal
type as an alternative tostd::thread_local!
that allows per-object thread-local storage, while providing a similar API… -
ferrite-session
Session Types DSL for Rust
-
no-std-thiserror
thiserror but no_std compatible
-
object-safe
Implement object-unsafe traits for trait objects
-
anymap3
A safe and convenient store for one value of each type
-
partial-context
Partial Context Types
-
agoraui-runtimes
AgoraUI reactive runtimes
-
selfref
Semi-pain-free self-referential pinned types
-
quack
Duck typing traits
-
generic-global-variables
tools for implement generic global variables
-
borrow-or-share
Traits for either borrowing data or sharing references
-
eventually
using Event Sourcing in Rust applications
-
const-chunks
Extension trait to chunk iterators into const-length arrays
-
tuple_utils
A set of utilities to enable higher level operations over tuples
-
ni-fpga
Safe Rust interface to NI FPGAs with FXP support
-
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
try_map
try_map
andflip
methods forOption
. These allow more ergonomic error handling when mapping functions that returnResult
overOption
. -
fluent-asserter
write tests assertions with a fluent interface
-
market
Infrastructure for producers and consumers
-
pin-init
Safe pinned-initialization in Rust
-
physical-quantity
dimension and unit system for general physical physical quantities
-
tcs-dhbw
Modules for a model traffic control system project at DHBW Stuttgart
-
regi
Regi
-
quasi_iter
that contains supplementary iterator objects and methods
-
named-block
Macro implementing early-exit-from-any-block
-
quick-error2
A macro which makes error types pleasant to write
-
rsor
Reusable slice of references
-
rs-measures
macros to encapsulate numbers in measures, provided with units of measurement, allowing any meaningful operation, but statically forbidding meaningless operations with them
-
tracerr
Custom compile-time captured error tracing
-
arc-interner
An interner that deallocates unused values
-
ptrplus
Additional funtionality for pointer types
-
macro_lisp
Lisp-like DSL for Rust language
-
consume_on_drop
A zero-cost abstraction that allows Drop::drop to consume self by value
-
re_query
Querying data in the re_data_store
-
error-window
proc macro that will make your main function output errors as dialog boxes as well as errors to the console
-
dyn-any
An Any trait that works for arbitrary lifetimes
-
adhesion
A set of macros for design by contact in Rust. The design of this library was inspired by D's contract programming facilities.
-
pack1
Byte array newtypes for different primitive types
-
procedural-masquerade
macro_rules for making proc_macro_derive pretending to be proc_macro
-
defmac
A macro to define lambda-like macros inline
-
messages
Runtime-agnostic actor library
-
panic-message
Get a panic message from a panic payload
-
ref_thread_local
A macro for declaring thread-local
static
s like using both oflazy_static!
andRefCell
-
bidir_iter
Bidirectional iterators
-
ieee-apsqrt
Square root functions for IEEE floats using rustc_apfloat
-
closure_attr
An attribute macro to simplify closure captures
-
cprint
Cargo-like print
-
arr_ty
Macros for smart array initialization (best for trait object element types)
-
rustc-ap-rustc_errors
Automatically published version of the package
rustc_errors
in the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
async-fn-stream
Lightweight implementation of
async-stream
without macros -
iter_fixed
Iterator of fixed length
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
delfi
Conveniently writing data to csv-files
-
asset-derive
asset handling derive macro for enums, and a proc-macro learning resource!
-
flatty-base
Flatty traits and primitives
-
mini-config
Minimalistic Dynamic Configuration Library for Rust
-
shell-tools
shell tools for Rust
-
hlist2
Compile-time heterogeneous list implementation
-
fracpack
Convert to and from the fracpack format
-
min-max
max! and min! macros
-
propositional_logic
generate truth tables for compound propositions
-
inherent
Make trait methods callable without the trait in scope
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
char-device
Character Device I/O
-
document_validator
A small library to help you implement document validation
-
enum_pipeline
way to use enums to describe and execute ordered data pipelines
-
enumx
Ad-hoc enum extension
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
heterob
conversion between bytes/bits and heterogeneous lists (tuples)
-
pretty-error-debug
Write out the
Error
message and chain -
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…
-
wei-result
wei result
-
validus
A string validation library
-
sendable
Rc and Option equivalents that facilitate sending data between threads
-
rtml
(r)ust macros for h(tml) expansion => rtml. (r)ust type safe (css) => rcss
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
easy_retry
easy to use retry library for Rust
-
num-sign
enum Sign { Positive = 1, Negative = -1 }
-
local-type-alias
Local type aliases in impl blocks
-
enum-derived
Generate random instances of your enums and structs
-
exhaust
Trait and derive macro for working with all possible values of a type (exhaustive enumeration)
-
qm-utils
functions and macros
-
hexhex
hexadecimal conversion 🪄
-
hb_error
Useful macros and traits for creating and handling errors
-
rcrefcell
Wrapper type for Rc<RefCell<A>>
-
therror
derive(Error) with a twist (based on thiserror)
-
ad-hoc-iter
Ad-hoc exact size owning iterator macro and other optional utils
-
desaturate
This package aims to makes it easier to maintain a single code base for both regular and async functions
-
egui-probe
Trait and derive macro for exposing value editing in egui
-
columnation-master
An experimental columnar arena
-
destruct
structs and enums for simpler combinator implementation
-
equator
Composable assertion library
-
mutify
Macro for coercing a
mut var: T
orvar: &mut T
into a&mut T
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
cheap-clone
A trait which indicates that such type can be cloned cheaply
-
metastruct
Abstractions for iterating and mapping over struct fields
-
projecture
Easy arbitrary type projections without proc macros
-
loop_chain
Macro for writing nested Loop expressions
-
tstr
Type-level strings
-
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
-
curerr
easy error handling
-
scope-exit
The util to call procedure when exit current scope. scope exit. like defer in go.
-
irox-structs
Traits for Struct Types - linearly serialized big endian bytes
-
dioxus-shareables
Hooks for sharing structures between components
-
vec_filter
Vec Filter is a Rust library to filter a vector of structs based on a query string. It allows you to specify filter conditions on struct fields with a simple query syntax. The library provides a custom derive macro…
-
sawp-ffi
FFI helper macros and traits
-
grouping_by
allows the user to group an iterator by various ways
-
once
assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
swaggapi
Auto-generated OpenAPI documentation
-
cryo
Extend the lifetime of a reference. Safely.
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
hxdmp
A small utility to create hexdump output from byte slices
-
stable-inline-python
Stable Variant of inline-python
-
cronjob
scheduling your methods
-
packed_streaming_iterator
Additions to streaming_iterator
-
stringlit
A macro to convert from str to String
-
tailsome
Blanket traits providing
.into_ok()
,.into_err()
, and.into_some()
for happier method chaining -
separator
Formats numbers into strings with thousands separators for readability
-
escher
Self-referencial structs using the async/await transformation
-
chainer
A cursed crate that allows for global call chaining with access to chained function results
-
termcolor_output
Interface crate for styled output to termcolor through macro
-
jni-mangle
Mangle Rust functions for use with JNI
-
impl-converter-helper
declarative macro library to help you implement the
From
orTryFrom
trait for your type -
ghost-lite
custom PhantomData types
-
better_any
Type id and Any for non static types
-
squote
A clone of the quote crate that uses a String as its backing store
-
cantor
A general toolkit for working with types that have a small number of values
-
canpack
Canpack Rust utilities
-
but
A common utils lib
-
degeneric-macros
Hides struct generics into trait associated types
-
unique_ptr
smart pointer implementation in Rust
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
fallthrough
Pattern match with fallthrough, in the style of C switch
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
osu-file-parser
parse an osu! beatmap file
-
tenacious
[RETIRED: Will not work with MIR] A plugin to prevent certain types from being moved
-
async_pipeline_for_lucas
Easy way to pipeline sync and async functions
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
derive-name
Derive macro to get the name of a struct, enum or enum variant
-
scalar_map
map
for scalar types -
rust_io
Macro implementation for [rust_io] defining several operators to be used emulating Haskel [do notation]
-
selfie
Experimental, macro-free and allocation-free self-referential structs
-
python-packaging
Python packaging primitives implemented in Rust
-
io-adapters
Adapters to convert between different writable APIs
-
plain_enum
Mimicing Java's enum::values() and EnumMap
-
except
The only one
Error
-
itermacros
Some useful macros related to iterators
-
struct-metadata
Macros for attaching metadata to structs
-
dec-number
Decimal Floating Point Arithmetic for Rust
-
regex-macro
A macro to generate a lazy regex expression
-
try-partialord
Safe failable sort, min, max, binary_search functions for PartialOrd. No need to wrap f32, f64 to sort any more.
-
dsl
build your own dsl
-
firedbg-lib
FireDBG Support Library
-
async-time-mock-async-std
Mockable time for use in async runtimes (async-std compatibility)
-
drop-bin
Defer running expensive destructors until later
-
edgedb-query
that provide a bunch of traits and structs used by edgedb-query-derive crate
-
code-path
A code path macro
-
gandiva_rust_udf_common
A basic library for gandiva rust udf macro
-
rxml_validation
Plumbing crate for rxml and rxml_proc crates
-
chandeliers-err
Internal error message generators for the Chandeliers project
-
const-type-layout
Derivable const trait to view and compare the layout of a struct, union, or enum
-
readonly
Struct fields that are made read-only accessible to other modules
-
byte_set
Efficient sets of bytes
-
ever
Print the build information of your program with minimal boilerplate
-
zero_v
implementing iterators over function outputs for collections of types implementing a common trait, without using vtables/ dynamic polymorphism
-
alternating-iter
Provide an iterator adaptor which alternate between two iterators
-
defer-lite
A lightweight high-performance implementation of Go's defer statement
-
rustils
Utilities for rust
-
shoogah
Add some syntactic 'shoogah' to Rust
-
macro-utils
Some macros to make code writing more elegant and funny
-
lef21
Exchange Format (LEF) Integrated Circuit Layout Parser & Writer
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macros
when automatically deriving types -
matr
A metaprogramming library for Rust
-
macaroni
The missing macro std library for Rust
-
std_io_iterators
An iterator for
STDIN
and a wrapper forSTDOUT
. Allows easy piping, and graceful closing of application if pipe breaks -
goxoy-interpreter
Sistem bilgisini veren kitaplik
-
exposed-macro
Contains macros required by "exposed"
-
teloc
compile-time DI framework for Rust
-
standback
New standard library, old compiler
-
printc
Print-clean macro. Like
println!
but cleaner input. -
integer_or_float
A data type holding an ‘integer or float’ (a data type in the Unified Font Object specification, among others)
-
microtype
simplify the creation of microtypes
-
unc-stdx
contains polyfills which should really be in std, but currently aren't for one reason or another
-
enum-derive-2018
macros for deriving additional functionality for enums
-
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
default-impl
A macro for implementing traits with their default implementations
-
vnum
Create enums with a constant value associated to every variant
-
tuple_list
macro-free variadic tuple metaprogramming
-
sly_static
Seamless Rust Static Initialization: Effortless and Efficient
-
batch_oper
some batch operation macro for some operations
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
visibility
Attribute to override the visibility of items (useful in conjunction with cfg_attr)
-
oxydized-money-macros
Companion library to oxydized-gains providing convenience macros
-
close-err
Add .close() to file-like types, for error handling
-
throw
Efficiently add statically-calculated stack traces to errors
-
atruct
macros for anonymous structs in Rust
-
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)
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
podio
Additional trait for Read and Write to read and write Plain Old Data
-
for-loop-iterator
Iterators like traditional for loops
-
concat-string
macros for concatenating string slices into owned strings
-
refs
My vision of reference counting
-
rs2glsl
Conversion from Rust code to GLSL
-
bevy_cell
Attach Bevy's Handles/Entities statically to Types
-
noders
NodeJS-like event loop environment for Rust
-
versioned-file
adding versions and upgrade schemes to files
-
gha_main
Convenience macros for writing GitHub Actions in Rust
-
enum-extract-error
A companion crate for
enum-extract
that exports an error type -
hado
Monadic do notation using a macro
-
polars-core
Core of the Polars DataFrame library
-
take-static
Static items that provide mutable access only once
-
simple_scan
Iterator extensions for simple scan operation
-
ebml-iterable-specification
base
EbmlSpecification
used by theebml-iterable
andebml-iterable-specification-derive
crates -
rancor
Scalable and efficient error handling without type composition
-
prometheus-metric-storage
Derive macro to instantiate and register prometheus metrics without having to write tons of boilerplate code
-
enums_arena
enums_arena
is an arena that enums can be stored efficiently -
recur-fn
that provides you a more flexible way to construct and extend the recursive function
-
array_ex
Easy and powerful compile-time array initialization
-
new_type
Experimental implementation of newtypes by type level logic
-
rsyntax
-
displaythis
derive(Display)
-
smartcow
a cow for smartstrings
-
const_sort_rs
Sort slices in const items
-
smurf
SMall Useful Rust Functions
-
match_any
declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
tch-tensor-like
Derive convenient methods for struct or enum of tch tensors
-
guest_cell
Storage space for externally-owned private data
-
dbus-strings
Rust native implementation of different D-Bus string types
-
constructor-lite
Generate minimal constructors for structs
-
koute/nes
emulator written in Rust
-
wext
web-sys extension traits, convenience functions and types
-
vlq-bij
Bijective Variable-Length Quantity encodings
-
fullypeek
Peek forward in an iterator as far as you'd like, memory allowing!
-
do-not-use-testing-rosidl_runtime_rs
Message generation code shared by Rust projects in ROS 2
-
piston-float
Traits for generic floats in game development
-
include_data_uri
include a file as a data uri
-
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
rate-limit-core
companion crate to
rate-limit-macro
with primary purpose to provide tests -
macroquest
Write MacroQuest plugins in Rust
-
unc-primitives
base set of primitives used by other framework crates
-
corlib
A general purpose library
-
tinypointers
Pointer implementations that take 8 or 16 bits
-
interpolate
form of string interpolation
-
derive-attribute
A set of macros to automatically deserialize standard attributes
-
steel-repl
REPL library for steel
-
frust
Functional Programming in Rust
-
hereditary
Procedural macros for emulating OOP Inheritance in Rust
-
enum_delegate
Easily replace dynamic dispatch with an enum, for speed and serialization
-
phantom_newtype
Lightweight newtypes without macros
-
easy_node
Smart pointer for graph nodes
-
enum_downcast
Safe downcasting for enums
-
inter-struct
Automatically generated traits for arbitrary structs
-
imgref-iter
A small crate for iterating over the rows or columns of
imgref
buffers -
to_tokenstream
An interface for creating a compiler within a Rust macro
-
rs_transducers
transducers for Rust
-
enum-unitary
Trait and macro for unitary enums
-
pointer-identity
Wrapper type to treat the pointer address of types as identity rather than the value
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
unc-chunks-primitives
hosts NEAR chunks-related error types
-
veccell
variant of Vec with interior mutability
-
jsona-openapi
A openapi dsl in jsona
-
ouroboros_examples
Examples for the ouroboros crate
-
utils-results
The easiest and most intuitive error handling solution
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
kuchikiki
(口利き) HTML tree manipulation library
-
pad-adapter
that provides pad adapter
-
wgsl-types
WGSL Types
-
anonymous-trait
Anonymous trait implementation with capturing the environment
-
posix-errors
Posix error codes and handy functions for using them
-
forgejo-api-types
API types of the forgejo API
-
conditional-assignment
very simple, small crate to help make conditional assignments more ergonomic
-
to_snake_case
that transforms strings to snake_case
-
type_reflect
Extensible runtime reflection through a Derive macro
-
notzero
macro for constructing
std::num::NonZero*
from constants -
brain_flak_macro
Brain-Flak macro
-
kmacros
Useful macros
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
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
-
typers
Type level programing
-
genesis
generating statically-typed ECS worlds
-
eager
macro expansion
-
ordbog
lossy dictionary codes for accelerated scans
-
suitest
quality of life test suites
-
simplebyteunit
A thin encapsulate for integer primitives to facilitate a fast, simple, yet ergonomic byteunit implementation
-
snapup
Abstractions for handling snapshots with streams of subsequent updates
-
map_tuple
Map individual elements of a tuple
-
padded-iterator
An iterator that can be padded to a specified length
-
phenotype-internal
Defines
Phenotype
trait forPeapod
crate -
rerast_macros
Macros for use in Rerast rules
-
base64_type
type wrapper for Vec<u8> that uses base64 for serialization
-
trove-classifiers
Python packaging classifiers as an Enum
-
effing-mad
The hottest algebraic effects library in Rust
-
bioneer
An Open-Source Rust Implementation of Bionic Reading
-
rustrix
Supportsc macro and basic operations for matrix
-
kube-core
Kube shared types, traits and client-less behavior
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
lens-rs
lens implemented in rust
-
strck
Checked owned and borrowed strings
-
trigram
Trigram-based string similarity for fuzzy matching
-
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…
-
rust2fun_laws
Laws for rust2fun
-
xie
A common utils lib
-
pythonic-helper
that provides Python-like functions (and some surprises)
-
lurk-ipld-macro
lurk-ipld macro
-
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
fastrand-contrib
Extension functionality for fastrand
-
match-commutative
Match on patterns commutatively, reducing the use of duplicated patterns. ↔️
-
repeated
Allows you to repeat a block of code a number of times
-
apply
A tiny library for chaining free functions into method call chains
-
cudd-sys
Bindings for CU Decision Diagram library (CUDD)
-
nofmt
nofmt::pls
, a macro that does its best at preventing a code block from being mangled -
eternal_iterator
Trait implementation to promise that the iterator iterates forever
-
try_as
Macros and traits to ease using enums whose sole purpose is to enumerate a set of types
-
tryvial
Small crate for ok-wrapping and try blocks
-
diesel_derives_traits
Traits for diesel_derives_extra
-
macro-dep-test
testing version resolution for associated macros
-
macro_clap
Command-line argument parsing to its simplest
-
bitmask
generator for enum scoped bit flags
-
signed_distance_fields
SDFs (signed distance fields) and some operators to play with these SDFs
-
zkp-macros-decl
Procedural macros
-
ad-hoc-iterator
Create an ad hoc iterator
-
enum_macro
Useful macro for enum
-
sycamore-state-core
sycamore-state core types and trait definitions
-
ident-util
macro to determine the string name of a binding, type, const, or function
-
merge2
Merge structs into single by values
-
struct_iterable
providing a proc macro to make a struct iterable
-
teo-teon
Object notation for Teo
-
tagged-pointer-as-enum
A set of structs, traits and macros to implement tagged pointers
-
validator_types
Basic type for validator and validator_derive
-
ratbaseconfig
lib with base ratatui config for my (mb your) apps
-
laby_common
Shared code required by laby
-
also_sync
Macros to automatically wrap async functions as sync
-
datafet
Few functions that we use in all of our Rust applications
-
garando_pos
Backport of libsyntax_pos
-
see-through
traits to provide access to internal fields of generic structs
-
dict
Exercise crate implementing real associative arrays, also known as dictionaries
-
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)
-
ordered_iter
Ordered iterators
-
eiffel-macros
Eiffel is a library for Eiffel language inspired guard clauses with Rust macros. This is the macro rules part of the library.
-
dupe
Marker for types which are cheap to clone
-
hex-slice
Extends the std::fmt::*Hex traits to slices
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
menv
Pulling in arguments from environment variables
-
racros
Collection of rust macros
-
string-utility
substring implementation (with the RangeBound trait), keep string before or after a specified string, etc
-
const_typed_builder
Compile-time type-checked builder derive using const generics
-
lawn-constants
error and logging types, traits, and codes for Lawn
-
internship
Interned string and more
-
vec-utils
vector utilities
-
control-flow
A hack to control control-flow outside closures
-
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
-
wasmer-wit-bindgen-gen-core
wit-bindgen-gen-c
-
emboss
A small macro to embed metadata as an ELF/Mach-O section in your final binary
-
easy_switch
A macro for traditional C-style switch statements
-
ld_preload_helpers
Macros to run code at load time and override C functions
-
knife
An iterator that divides things evenly
-
mapper-api
Api of the
mapper
crate -
rustc_errors
reuse rustc_errors
-
orderless
Orderless/named functions in Rust.
add!(b = 2); // 4
. -
linear_type
Linear types for rust
-
scan-rules
some macros for quickly parsing values out of text. Roughly speaking, it does the inverse of the print!/format! macros; or, in other words, a similar job to scanf from C.
-
bronzeflow
Bronze: A workflow scheduler in rust
-
py-comp
A macro implementing a Python-like generator expression
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
vm6502
A 6502 virtual machine backend
-
eeric-interpreter
A front-end abstraction layer over eeric
-
impl_ops
Macros for easy operator overloading
-
dev_bestia_url_utf8
url utf8 encode/decode
-
string_morph
string case transformations with an emphasis on accuracy and performance. The case conversions are available as functions as well as traits on String types.
-
serde_extra
Various de/serialization methods
-
string-join
A python-like way to join items in an iterator with a separator
-
is_empty
Easily check if the struct is empty
-
high_mem_utils
bunch of mem safe abstractions,some involving transmute
-
linq
Language Integrated Query in Rust
-
crdts_macro
CRDTs proc_macro
-
hadean-std
Hadean stdlib. Requires Hadean Rust.
-
whiteout
macros that erase the type of any value into an impl Trait for a given trait
-
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
coercible_errors
Zero-cost error handling for generic traits
-
type-variance
Marker traits for subtype variance
-
cute
A macro for Python-esque comprehensions
-
ip-family
IP family enum with functions to get special ips of the right family
-
uni_tmp_jni
It's temporary fork for https://crates.io/crates/jni. Don't use!
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
unwind_safe
Readable unwind-safe code thanks to a try-finally-looking builder pattern
-
rexpr
Rust Json Object access Runtime
-
simplify
simplify-js port to rust
-
tor-async-utils
Async/futures helpers for use with Tor
-
wutil
A lightweight library that contains potentially useful functions, wrappers, and macros
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
xldenis/creusot-contracts
deductive verification of Rust code. (semi) automatically prove your code satisfies your specifications!
-
sconcat
String concatenation
-
sendkeys-rs
A macro to send keystrokes using the windows crate
-
rustc-std-workspace-core
Explicitly empty crate for rust-lang/rust integration
-
cpp_core
interoperability with C++
-
vec_split
Splits arrays of vectors into arrays of items
-
roopert_macro_common
object-oriented toolkit for Rust (common data)
-
type-factory
unique opaque types
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
look_inside
Look inside structs, enums, and unions!
-
cfgenius
Conditional compilation with macro support in Rust
-
is_none_or
function for the Option type
-
traverse
Proof-of-concept trait for internal iterators called traversals
-
extension
methods for (foreign) types
-
standalone-proc-macro2
Fork of proc-macro2 that uses rustc-ap-proc_macro so as to remove the rustc dylib dependency
-
beetle-iter
A collection of basic iterators
-
redis-om
Redis ORM-style library that simplify the development process and reduce the amount of boilerplate code needed to build programs that leverage [redis] powerful capabilities and use cases
-
easy-min-max
Easy to use macros for min, max and clamp. Works with no_std
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
beancount-parser-lima-python
Python bindings for beancount-parser-lima
-
iter_from_fn
Create iterator from repeatedly aplying a function that takes no parameters
-
toast-cell
Zero-cost type-branded cell with no runtime checks
-
dittolive-ditto-sys
Native bindings to Ditto library
-
typestr
type-level strings and slices
-
ctrlgen
Generate enums for message-passing services
-
dynstack
A stack for trait objects that minimizes allocations
-
try-drop
Batteries included error handling mechanisms for drops which can fail
-
stringreader
wrapper for strings so that they can be consumed via the std::io::Read trait
-
open-ambient
Open files and directories with constant paths
-
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
whiskers-widgets
Dynamic UI sub-system for whiskers
-
grade
A convenience macro for gtk-rs
-
enum_cycling
Small macro for working with enums
-
marker_trait
Implement a blanket implementation for a marker trait
-
twitter/rustcommon-atomics
Atomic primitives unified by traits
-
as_base
Cast trait objects to some base class
-
morphism
A structure for suspended closure composition in Rust
-
apperr
A thin special-purpose wrapper around Any
-
open-cl-low-level
OpenCL low-level bindings
-
gamo
A Range like struct for user defined types
-
e_macro
A module for e library, it provides some utility macros for Rust
-
haz
A thin abstraction over polymorphic environments
-
fuzzy_match_flex
Fuzzy matching library based on the popular
FuzzyWuzzy
library for python -
smol-symbol
compile-time globally unique, 25-character, 128-bit symbols similar to the Symbol type in Crystal Lang
-
identity_verification
Verification data types and functionality for identity.rs
-
tyenum
Attribute macro for type enums
-
multi_try
Safely combine results
-
mod_use
pub mod xxx; use xxx::*;
-
error-ex
designed for those who desire clear, explicit, and easy-to-use error creation and handling
-
sqlx-executor-alias-macro
SQLx Executor alias macro
-
resultit
Iterator adapters for iterators over results
-
destruct-drop
Macro for dropping the fields of a struct or enum without dropping the container
-
exonum_leveldb
An interface for leveldb
-
todo_using
A super small crate only exporting a single macro to "use" parameters
-
big_s
Rust’s missing
String
literal -
symtern
Fast general-purpose interners for every use case
-
helper
provided some useful proc macros for Rust
-
gramatika
A minimal toolkit for writing parsers with Rust
-
classes
Dependency-free macro that simplifies the process of building class strings for DOM elements
-
butcher
An easy way to interact with structs and enums wrapped in Cows
-
flexpiler
Deserialiser aiming at high customizability
-
libmw
constructing a pipeline of middleware functions
-
retry-policy
Retry Policy
-
ffizz-string
FFI string implementation
-
blackboxmc_general
Helper functions for BlackboxMC
-
rust_c
Write C code inline in your rust code (hacky fork of rust-cpp / cpp crate)
-
aether_primitives
Helpers for common SDR and signal generation operations
-
ribbons
unwrapping
Option
andResult
types with a formatted error message. (less boilerplate thanunwrap_or_else
) -
mvutils
made from commonly used functions in my projects
-
slicemath
element-wise operations on arrays of numeric values
-
atomic_ref_box
Box with thread-safe, immutable weak references
-
nu-errors
Core error subsystem for Nushell
-
xkcd_unreachable
macro xkcd_unreachable!() inspired by https://xkcd.com/2200/
-
sha2-derive
exporting a derivable
Hashable
trait that works withsha2
-
beetle-nonzero
Combines the std
NonZero
structs into one struct -
aliri_macros
Macros used by the
aliri
family of crates -
err-convert-macro
Errors converting macros
-
enum-utils-from-str
Code generation for mapping from strings to arbitrary values
-
kvtree
Heterogenous in memory key value tree storage
-
bystr
macro to create compile-time, fixed length, byte array from a string
-
error_def
syntax extension for generating error-handling boilerplate code
-
builder-pattern
A derivable macro for declaring a builder pattern
-
async_fn_traits
Trait synonyms for “Fn[…]”-trait bounds returning futures
-
quick_io
facilitate input and output within programs, with a set of macros
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
sim_connect_rs
An easy to use, opinionated API for SimConnect
-
namedarg_rustc_macro
namedarg main package
-
printrn
A macro to replace
println!()
, that will replace all\n
with\r\n
, e.g. for crossterm or other raw terminal work. -
html5ever_macros
High-performance browser-grade HTML5 parser − compiler plugins
-
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
-
another-visitor
Lets you derive visitor pattern implementations
-
fallible
operations
-
rstgen
Even simpler code generation for Rust
-
derive_convert
Derives 'impl (Try)From for Self' and 'impl (Try)From<Self>'
-
split-iter
Allows splitting of iterators
-
targets
Some helpers to get you started with declarative programming in Rust
-
enum-tools
Automatically derive functions and trait implementations for enums
-
diva
Opinionated convenience wrappers for
std::process::Command
and friends -
as-result
Traits for converting types which may be interpreted as or into a result
-
auto-builder
A derive macro to implement the builder pattern for any struct
-
casual
parsing user input
-
qwutils
some utilities
-
iota-rs
macro for other Go refuges who miss const blocks and iota
-
dioxus-daisyui
Dioxus daisyui
-
mcurry
Macros for creating curried functions
-
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…
-
persian_str_rs
functions for working with Persian strings in Rust
-
debug_unwrap
Adds the method debug_unwrap for when you just want to make it compile
-
multi_stack_queue
Abstraction layer for a stack-allocated multi-queue with bounded length. WIP
-
stream_assert
Macros to simplify testing of
Stream
based APIs -
sod-crossbeam
Service Oriented Design - Crossbeam
-
iter-skak
Combines std::iter::Skip and std::iter::Take into one
-
iter_vals
On the fly iterator creation
-
enum-lexer
A proc_macro lexer generator. using
enum
-like syntax. -
cartesian_array_product
Arrays of the cartesian product of a set of items
-
gurkle_codegen
gurkle
-
error-ext
Error utilities
-
navigator
A Macro-heavy Domain-Specific Language for console apps with menu systems
-
xwebtransport-error
A suite of reusable error types that naturally emerge from the xwebtransport API. Use when you don't want/need your own more precise types
-
dntk-matrix
Statically sized matrix using a definition with const generics (only for nightly)
-
metatype
Helper methods to determine whether a type is
TraitObject
,Slice
orConcrete
, and work with them respectively -
read_lines_into
Read lines (from a Path, File, etc.) into a struct (a String, a Vec<String>), and with various ways to handle line endings and whitespace
-
replicante_util_failure
Helper functions to manage failures
-
flow-control
Declarative macros for common flow-control use cases such as break, continue, and return
-
try_convert
Auto-generate TryFrom and an error type, with minimal boilerplate
-
polimorphism
Function overloading via a procedural macro
-
larc
Lazy Arc/Weak pointers
-
log_err
Log error messages from Unwrap and Expect with log crate
-
tupleops
work with tuples
-
similarity
calculating similarity between numerical slices
-
iter-diff
Differences between iterators
-
self-reference
Helper
-
repr-trait
Traits to represent Rust reprs
-
string-eyre
Convenience traits for dealing with errors that don't want to eyre
-
flag-mast
Ergonomic Rust bit flags
-
schemars-zod
A few functions to aid Zod schema generation from rust types annotated with schemars
-
lucidity-core
A distributed orchestrator platform for Rust
-
wrapping_macros
A macro for wrapping arithmetic
-
pluck
Extract values conveniently
-
const-ft
Macro for wrapping const fn in a feature gate
-
generic_singleton
allowing for generic singleton patterns
-
pingora-error
Error types and error handling APIs for Pingora
-
heimdall_errors
Macros for From trait errors
-
rayon-join-macro
A convenience n-nary macro around
rayon::join()
-
picostring
A stack allocated string that requires no extra space to store length
-
makepad-internal-iter
Internal iterators
-
near-safe-cell
A more ergonomic 'UnsafeCell' wrapper/replacement
-
rustring_builder
string builder
-
btl
shell scripting in rust. Github Repo: https://github.com/znx3p0/btlsh
-
roadblk
Validator integration
-
ts_quote
Procedural macros for quasi-quoting TypeScript from Rust
-
variante
Statically-verified enum variant names as strings
-
page-turner
A generic abstraction of APIs with pagination
-
syscall_encode_traits
Traits and macros to help define a syscall interface for a kernel
-
safe_unwrap
allows unwrapping and annotating that the unwrap will never fail. Does not require
std
. -
tiago_functions
Algumas funções para uso externo
-
oneline-eyre
A fork of
simple-eyre
which outputs errors on a single line -
debug_utils
enhanced debugging in Rust
-
algebloat_macros
RustAlgebloat utility macros
-
disuse
The way to notify the implementation which return value is disuse
-
fmterr
Sane error reporting that just works
-
amethyst-inspector
unity-like inspector for amethyst
-
err-context
Lightweight context layers for stdandard library errors
-
localization
t! macro, the easiest way
-
variant_counter
Rust's Enum variant counter
-
aspect
Toolkit for Rust
-
pre
Compile-time assistance for working with unsafe code
-
target-cpu-fetch
Exposes a method for querying the CPU name from the current target specification JSON file
-
typed_macros
Adds typing to your macro's arguments, making it a lot less of a pain to deal with them
-
dependent_ghost
Matt Noonan's 'Ghosts of Departed Proofs'
-
commandspec
Rust macro to build std::process::Command objects with shell syntax. Uses macro_rules! and works on stable.
-
mapstruct
Create refactor safe derivatives of Structs with proc-macros
-
easify
Development tools. Includes various helper functions and proc-macros to simplify your code and boost your development
-
wgpu_bind_dsl
An experimental macro dsl for describing Bind layouts in wgpu-rs
-
win9x-sync
Windows 9x compatible synchronisation primitives for Rust
-
components-arena-traits
Does not intend for direct use
-
curmacro
usefull macros like struct getters and setters creation macros
-
default_macro
My default!() macro
-
hatch_result
A result-like struct that returns on Ok, instead of on Err when ? operator is used
-
crashreport
Automatic GitHub crash reporting system for any Rust crate
-
ra_ap_limit
TBD
-
racer-interner
thread-local string interner for racer-rust
-
en
The easiest numeric traits!
-
either_n
An Either enum with N variants
-
plist_plus
reading and writing plists, compatible with libimobiledevice
-
cassandra_macro
Create Cassandra tables and CRUD CQL prepared statements from Rust structs. (custom derive: cassandra_macro_derive)
-
rovv
provide the anonymous row type (poor-man's row polymorphism) in rust
-
shared_error
SharedError wrapper for cloneable Error
-
spidermeme
Traits to test for type equality and type inequality
-
functional-closures
composable pure functions with the signature f(T) -> T
-
fold-license
Folding licenses from multiple dirs with
cargo
/Cargo.toml andyarn
/package.json -
char_combinator
An iterator to create all combination of a given char range
-
iter_all
Iterate all enum vases
-
general-iter
An enum of iterators to avoid Box<&dyn Iterator>
-
defunctionalize
Defunctionalization as a proc-macro over modules
-
makero
A
macro_rules!
macro to aid in the creation of complexmacro_rules!
macros -
fluid-macro
Write long method chains as a series of steps instead, and more!
-
tectonic_errors
A boxed error type for Tectonic, with supporting utilities
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
pattern_code
Given a path patterm matched source code
-
retryiter
A wrapper lib on top of rust Iterator with added retry support
-
strong
Strongly typed String
-
derive_default_builder
derives a builder implementation relying on all fields implementing Default
-
wtflip
A language in a Rust macro... or something.
-
ignore-result
Adds a
Result<_, _>.ignore()
method to ignore the return value of a function call without panicking in case of error -
bytecoding
Derive macro for encoding and decoding instructions and operands as bytecode
-
rs-utilities
Some utilities
-
rucky
Macros for hasty, sketchy, funny Rust programming
-
rbtag
A procedural macro to add build DateTime and git commit information at compile time
-
stuff
Stuffing things into pointers
-
herbie-lint
A rustc plugin to check for numerical instability
-
fn_macro
函数宏
-
fortify
convenient way to bundle owned data with a borrowing type
-
maybe-uninit-ext
Extended maybe-uninit types
-
c-emit
Polished builder API to write C Code
-
stupiderators
Iterators for Indeedee, mostly
-
darkly
scanf-style scanner
-
termal_core
contains implementation for the termal library
-
fb_cloned
Cloned macro
-
onlyerror
Obsessively tiny error derive macro
-
std_prelude
prelude that the rust stdlib should have always had
-
partial_derive2
makes all the properties of a struct type an optional property
-
univec
A vector that can hold elements of any single type
-
whaterror
Customizable handling for fallible main
-
batbox-tuple-macros
Macro for calling your macro for all tuple sizes
-
derive_constructors_proc
Deriving From, TryFrom and create new_with_*args* functions
-
zngur-parser
Parser of the zng file
-
splop
Helper functions to determine the first/last repetition of something
-
tournaments
running tournaments
-
unused
Allows for unused generic parameters that do not act like they are owned
-
esvc-traits
Traits for ESVC
-
bitmatch
A macro to allow matching, binding, and packing the individual bits of integers
-
breakable-block
A shim library for a stable implementation of what is proposed in RFC 2046
-
zconvertenumn
Convert number to enum
-
panda_pile
Traits for lazily producing and consuming sequences
-
quantified
Specify the universe: None, Some, Excluding, and All
-
string_iter
An overly designed &str iterator made with zero-copy parsing in mind
-
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
-
pollock
An ergonomic and performant processing-like library for generative art and simple games in Rust
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
kelpdot_macros
Macros (color print) for KelpDot
-
serde_type_name
lookup name of type for any struct or enum that derives serde Serialize
-
displaydoc-lite
Implement the Display trait using your standard doc comments
-
path_semantics_std
type checked implementation of the standard dictionary of path semantics using constrained functions
-
flatty-portable
Flatty portable trait and primitives
-
argst
A one-macro crate for generating StructOpt boilerplate and binding args
-
phantomdrop
Go-like deferring of function calls
-
trait-alias-macro
Trait Bound Alias using Macros
-
tugger-snapcraft
Snapcraft packaging primitives
-
similar-structs-macros
Quality-of-life macros for more concise struct/enum definitions
-
namedarg_hack
namedarg main package
-
futures-signals-structs
Derives mutable versions of structs for the futures-signals crate
-
try_or_wrap_s
?
ortry!
macro, with an additional wrapping of the error in something else -
cli-failure
Failure(String)
implementingstd::error::Error
. Includes convenience macros making it perfect for usage withwrap-match
in CLIs. -
rassert-rs
macro for expressing Result-returning assertions
-
notosans
providing several of Google's Noto Sans true type fonts as slices of bytes
-
timed-locks
Smart pointers to
tokio::sync
locks that either panic or error after a timeout -
exun
Handle unexpected errors
-
rattish
Cast between trait objects
-
these
A three-way enum capturing This, That, or Both. Inspired by the Haskell package https://hackage.haskell.org/package/these
-
ferment-interfaces
Traits for FFI conversions and some helper methods
-
compound-error
Compound errors with flat hierarchy
-
negate
Attribute macro that generates negated versions of functions that return booleans
-
diman_lib
Commonly used types for internal use in diman
-
err-per-field
A more fine-grained control over field-level error handling
-
esrs
A Prima.it-opinionated library to achieve cqrs/es
-
thinnable
Thin references to unsized types
-
user-panic
Error messages
-
birds
Combinators using Rust macros
-
enumcapsulate
Safe casting for newtype enums and their variants
-
lua-macros
Useful macros to join Lua with Rust
-
signrel
Trait expressing relationship between integers of different signedness
-
todo
Minuscule
TODO!
macro that lets you type-check and test but prevent compiling in release mode -
digitize
Traits for accessing digits of primitive integers & floats
-
asyncsync
Runtime-agnostic synchronization primitives for asynchronous Rust
-
osm-geo-mapper-macros
Contains various helper macros for the osm-geo-mapper crate
-
fang_oost
implementing Fang and Oosterlee's algorithm for inverting characteristic functions
-
zoomer
Making Rust a true modern language™️ with revolutionary macros
-
anyhow_ext
Extension of anynow
-
labview-interop
Types and wrappers for interperating with LabVIEW when called as a library
-
dedup_iter
Deduplicating iterator adapters
-
arcmut
Introduce ArcMut, utility for FFI
-
env-var
Macros providing easier access to environment variables in rust
-
structural
Field accessor traits,and emulation of structural types
-
dims_macro
Macros for Generating Systems of Units
-
io-read-line-prototype
Prototype for io::read_line
-
polymorphic-constant
A macro to define a numerical constant in multiple types at once
-
detour3
A cross-platform detour library written in Rust
-
runtime_injector
Runtime dependency injection container
-
common_macros
common macros like
hash_map!
orhash_set!
(WIP) -
poison-guard
maintaining sane state in the presence of panics and failures
-
failchain
Ergonomic companion library for failure
-
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
rich-phantoms
Phantom types with control over variance and sync/sync inheritance
-
slots-slice
manipulating slices of optional values
-
cast_checks_convert
-
progressive
showing progress of iterators and loops
-
shoggoth
Generic and type-level programming for Rust
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
bty
Streamlined definition and usage of branded types in Rust
-
partial_function
A clean way to define function as a set of subfunctions where each has defined start and end bounds
-
value-bag-sval2
detail for value-bag
-
sentry-error-chain
Sentry integration that allows capturing error-chain errors
-
bail_macros
Bail macros for Options, Results and more
-
objc-macros
Handy macros for interacting with Objective-C from Rust
-
variant_count
Derive macro for enum which adds to it the count of variants
-
rw-exact-ext
Extension of std::io to read and write data types with exact amounts of bytes
-
simple-dmenu
macro to call dmenu
-
entity_rust
Event driven CES framework for Rust with a macro DSL
-
dyn-hash
Hash trait that is object-safe
-
gtk_widget_macro
A derive macro helps you handle Gtk widgets
-
partial-result
results that return success for non-critical errors
-
archway
Rust traits for Rc and Arc interoperation
-
cp_tricks
Tricks for competitive programming. Do not use this crate.
-
max_values
Struct and iterator extension trait for getting max values out of given
-
lucene_query_builder
A procmacro derive crate to generate lucene query builder for Rust structs :
-
swahili-dsl
A Swahili-based DSL made for educational purposes
-
typesafe-builders
Infallible compile-time checked builders for your structs
-
qcomms
small library that offers a simple, zero-cost message passing trait. no async-trait
-
ngram_iter
An iterator of arbitrary N-grams of rust Copy types
-
east
Full-stack web library for island architecture
-
sass-alt
A more powerful alternative to sass-rs that provides SASS functions, SASS importers and source map manipulation
-
thin-slice
An owned slice that packs the slice storage into a single word when possible
-
dev_bestia_string_utils
string manipulation
-
error-trees
Fail with multiple errors, istead of only the first
-
namespace
abstraction
-
for_each_repeat
Iterator::for_each
that can repeat current iteration -
units
Measure for Rust. Easy to use, type-safe and customizable.
-
enum_properties
A macro for declaring static properties on enum variants
-
staticinit
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
detach
helper type for being able to detach/reatach a member item
-
pfn
Provide fn_trait’s
call
,call_mut
, andcall_once
on Stable Rust -
context-rs
Pass values down the async call stack, with no_std and no_alloc support
-
stringy
A tiny Rust crate for generating byte-sized enums that represent a fixed, ordered set of &str data
-
forward_ref_generic
Generically forward references for operations on Copy types
-
nanocl_error
Nanocl error types
-
ataraxy
Discord slash commands framework for Serenity
-
codespan-derive
derive(IntoDiagnostic) for easy codespan integration
-
rustc-ap-rustc_expand
Automatically published version of the package
rustc_expand
in the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
stack-trait
Stack trait with entry API for the LIFO element
-
newtype-derive-2018
macros for deriving common traits for newtype structures
-
tmux-lib
Tmux helper functions
-
symm_impl
Attribute macro that automatically implements a symmetric trait
-
stringedits
Edit trait and associated iterators for small edits to strings
-
call-once
A type that can only be called sucessfully once
-
unwrap_let
macro for quickly unwrapping a refutable pattern
-
singleton-stepanov
isn't meant to be used by itself, but as template for your our types. Attempt to do Efficient Programming with Components: Lecture 2 Part 1, Efficient Programming with Components:…
-
magic_static
Global singletons initialized at program start, an alternative to lazy initialization
-
symbol
globally interned strings
-
tightness
Define types bound by arbitrary invariants and conditions
-
ruroonga_command
A tiny Groonga query builder and generator
-
allow
Alias/label lints (to disable) with your intentions. Reexported from allow_prefixed, grouped under rustc::, clippy:: and rustdoc:: modules.
-
intercom
writing COM visible Rust components
-
bparse
parsing bytes
-
memlib
An abstraction layer for interacting with memory
-
with-id
trait providing method for getting string id from struct
-
project-uninit
Macros for safe references to and initialization of fields in MaybeUninit structs
-
moveslice
A one-function crate to move chunks in a slice around
-
concat_strs
Macro for quickly building a String from components
-
sod-bus
Service Oriented Design - Single Producer Multi Consumer
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the *relative* difference
-
boolinator
trait, which lets you use Option and Result-style combinators with bools
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
macro-circom
Circom DSL providing macros used in Light Protocol
-
common_regex_rs
Set of common regex for Rust
-
default-env
The
env!
macro but with a default value -
input-macro
No-nonsense input!(...) macro for Rust
-
statenum
enabling enums in state-pattern logic
-
syn-test-suite
Test suite of the syn crate
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
enum-tryfrom
Error types and traits for use with enum-tryfrom-derive
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
kv-derive
Derive struct conversions from and to key-value vectors
-
duplicate_macrotest
Fork of the macrotest crate specifically to test the duplicate crate
-
bindgen-cfg
Specify bindgen settings using yaml
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
leafslug_time
Useful set of time-oriented functions, for my leafslug collection
-
flexible-io
Wraps values such that dyn-safe IO traits need not appear as static bounds
-
exprtk_rs
Rust bindings to the ExprTk C++ library (http://www.partow.net/programming/exprtk)
-
async-wormhole
Async calls across non-async functions
-
tyname
Retrieve type names during program execution on stable Rust
-
nullable-result
A replacement for Option<Result<T, E>> or Result<Option<T>, E>
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
thistermination
add the Termination trait to error enums inspired by thiserror
-
const-size-flatten
Flatten and FlatMap with constant inner iterator size
-
outcome
A Success/Failure type for rust
-
temporary_enum_delegate_0_3_0
trait delegation functionality for enums and structs
-
ratelimit_rs
The ratelimit package provides an efficient token bucket implementation
-
maybe-owned-trait
Either an owned or borrowed value, with type known at compile time
-
simple-counter
Macro for generating thread-local static counters. Useful for basic ID generation.
-
pl-lens
support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
lazy-attribute
convenient attribute macro for lazy function execution
-
memory-size-type
A data type for dealing with memory sizes
-
iter-python
Python generator expressions and 'list' comprehensions
-
ret_ty_attr
Specify the return type depending on configuration conditional checks
-
some-to-err
A set of traits for converting
Option
toResult
, providing methods to transformSome
values toErr
while handlingNone
values asOk
, either directly or using a closure to generate the Ok result -
eth2_ssz_types
types with unique properties required for SSZ serialization and Merklization
-
ambience
Lightweight library for passing ambient parameters
-
log-instrument
Offers an attribute procedural macro that adds
log::trace!
events at the start and end of attributed functions -
cmd_error
print an error message and exit while unwrapping Options and Results
-
audiotags-dev-macro
macros used during the development of audiotags
-
dyn_struct
Construct dynamically sized types safely
-
chunk_iter
Chunked iterator generic over any iterator
-
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
twinsies
Smart pointer providing 2-way joint ownership of an object
-
only_every
rate-limiter macro: only_every!(Duration::from_millis(200), expensive_expression)
-
lifted
Higher-kinded types in Rust
-
inner
The inner! macro descends into an enum variant. It's more flexible than try!() and unwrap(), and it works with your enum, too!
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
inference_graph
For building graphs of async tasks by having each node only refer to its own inputs
-
hs-bindgen-types
types behind hs-bindgen ergonomics
-
cove
Casts Of Varying Elegance (COVE): extension traits for casting numerical types
-
c_str
The old c_str functions
-
write-to-file
Write to a file, simple helper fn and traits lib crate
-
beaver
setting up Rust objects inspired by factory_bot
-
wrapping-macro
wrapping macro
-
cex
Checked exception simulation
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
the-newtype
The Newtype trait
-
current
setting current values for stack scope, such as application structure
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
oneline_str_enum
Format and parse enums as strings with macros
-
crossdylib
Cross-platform shared state across shared libraries/modules
-
albert_stream
minimal procedural macros parser that produce a convenient AST
-
retry-block
retry operations that may fail with configurable backoff behavior using macros over blocks of code
-
opcode-macros
Macros for opcodes encoded in bit fields
-
edgedb-composable-query
ComposableQuery trait for EdgeDB. Use with edgedb-composable-query-derive.
-
unsafe-storage
Maintain invariants in macros without modules
-
bitutils
Bitfield macro and utilities
-
switch_statement
switch statement macro
-
powerfmt
powerfmt
is 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… -
collect_array_ext_trait
Collect an iterator into an array
-
mods
Simpler module declaration
-
fmt-cmp
Traits and utilities for lexicographically comparing values in their
Display
representations -
err_tools
Helper traits and functions for building errors in rust
-
slashies
reduce the boiler plate code needed to create slash commands for a Discord bot
-
thiserror_core2
derive(Error) (no_std-enabled using core2)
-
static_option
An option type that is statically known to be Some or None
-
hs-bindgen-traits
traits behind hs-bindgen ergonomics
-
singleton-trait
Singleton trait for types with unique values and Erased type for zero-sized ownership proofs
-
unhtml_util
some utility traits and functions for unhtml
-
bset
Fast and compact sets of bytes or ASCII characters
-
ov-config
An ini/toml configuration parsing library that provide macros and convenience functions for generating configuration schema, sanity check, flush, refresh, etc
-
fixed_len_str_example
helper crate for document the expansion of a procedural macro one,don't use
-
should
Postfix assertion library for Rust
-
anygma
makes it easy to define arrays containing different types
-
error-chain-mini
error-chain for minimalist
-
aorist_primitives
Primitive macros for the aorist project
-
tlist
Type-level linked lists (of types) and type-level 'functions' to manipulate them. Because TList is implemented using GATs, usage is very ergonomic.
-
extern-c
Convert a zero-sized closure into an
extern "C" fn(…)
pointer -
nyavascript
Lisp implementation. Called NyavaScript because I'm a monster
-
number-types
A typenum clone I made for fun with some positive changes but much fewer features
-
quixutils
Common helpers and utils
-
with_capacity_safe
A safer alternative to Vec::with_capacity with into_raw_parts which can be used from stable
-
result-ext
Extends
Result
with additional operations -
maparr
macro to build a static
Map
based on const array -
conventus
Traits for assembling and disassembling items
-
make_option
turns any type into an option, only if it is not already one
-
transaction
abstraction library (a.k.a. transaction monad)
-
taker
Option-like taking for everyting with a default value
-
handlevec
Small abstraction over index-style iteration over a vector, with deletion, insertion, and other operations on the vector while iterating
-
cismute
Safely transmute type to itself in generic contexts
-
portrait-framework
Framework for implementing portrait fillers
-
safe-libc
Safe wrappers around the
libc
crate -
x-bow
Precise State Management Library
-
svgmacro
Write any SVG easily from Rust!
-
jmdict-enums
Autogenerated enums for the jmdict crate. Do not import directly.
-
vector2d
The spoon of 2D vector libraries, intended for simple game development
-
rustkell
haskell like functions in rust
-
rust-2018
Macro to use Rust 2018 from all editions
-
derive_from
derive(From) macro
-
xstd
eXtended STandarD library
-
linera-wit-bindgen-core
experimental fork of wit-bindgen-core
-
runtime-contracts
Structured, understandable runtime contracts
-
error_hook
error hook
-
trait_exerci
how to understand the trait for rust
-
vm_lang
interpreted language written in Rust
-
RustyEmitter
RustyEmitter is a basic implementation of a simple emitter. The module expose a Events trait with the on, off and emit methods, and a default implementation of that trait, called Emitter.
-
io-extra
An extension trait for
std::io::Error
, with shorthand constructors for variousstd::io::ErrorKind
s -
nested-ref
References to data contained in one or more nested RefCells
-
higher-kinded-types
"Generic generics" / higher-kinded APIs in stable Rust
-
general_tools
offers many functions for many different types of operations, such as operations with strings, numbers, files, and more!
-
pstr
Global String Intern Pool
-
big_mac
A metamacro toolkit for writing complex macros
-
query_interface
Dynamically query a type-erased object for any trait implementation
-
attr_alias
Reduce attribute repetition with aliases
-
proc_use
Semi-dynamic mod and use
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
ees
error-handling library
-
sensible-dbg
Fork of the std::dbg macro that has no effect on release builds
-
kg-symbol
Atomic strings in Rust
-
plexer
A Pattern-matching LEXER
-
visita
Elegant implementation of the Visitor Pattern
-
rangetree
Range-tree for storing non-overlapping scalar ranges
-
never-say-never
The never type (the true one!) in stable Rust
-
define_into_enum
Defines Into<T> on an enum where all variants wrap T
-
eliza_error
“Times are bad. Children no longer obey their parents, and everyone is writing an error handling library.” — Cicero
-
anystring
a macro for turning tokens into strings
-
refined-float
Refined float with a subset of functions of std float
-
slid
labeled IDs
-
spectral
Fluent test assertions
-
slablit
Literal for slab creation
-
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
parse-format
Format string parser used by rustc
-
appbiotic-code-error
A set of error types to build services that can be managed similarly
-
context-iterators
Iterators adaptors with associated read-only data
-
enum_index_repr
EnumIndexRepr provides a small macro which allows getting the index on an enum
-
check
Convenience assert!-like macros which return instead of panicking
-
cxx-symbols
detail of the
cxx
crate -
erreport
A Result helper to catch all the Err propagation path for Rust
-
csharp_binder
generate C# bindings for a Rust foreign function interface (FFI)
-
rhizo-types
A collection of common Structs and Enums used in the software components that comprise the Rhizo network
-
split_exact
splitting strings into arrays of slices
-
mac
A collection of great and ubiqutitous macros
-
burntnail-utils
Set of Utilities for Errors, and some cachers/timers/macros
-
to_unit
ToUnit; Any type to () syntax sugar
-
stack-tokens
stack token implementation for convenient TLS borrowing
-
scalar_types
A module that wraps scalar types in an endian safe type
-
rich-result
Rich result type differentiating between recoverable & fatal errors
-
msg
XSI message queue
-
sh-inline
Macros to run inline shell (bash) script
-
spans
Split an iterator into contiguous spans
-
unc-client-primitives
hosts NEAR client-related error types
-
function_string_builder
A string builder that takes a user-provided function
-
lit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
fixed-macro-types
Macro aliases used in the
fixed-macro
crate -
kalman-fusion
single-variable Kalman filtering for Float and Fixed types
-
bin-utils
A bunch of utility macros and traits for binary parsers
-
nvim-types
Rust bindings to the Neovim C types
-
zipped
recursively unzipping tuples, Options of tuples and Results of tuples
-
mogrify
macro for autogenerating a “Parse, Don’t Validate”
TryFrom
implementation for structs -
sensitive_trait
A marker trait for sensitive information
-
derive_di
realized the dependency injection pattern
-
ejni
working with JNI more pleasant
-
rsb_derive
An opinionated macro implementation for Rust struct builder pattern with compile-time validation
-
fused_error
working with composable errors
-
zst
Zero-sized generic type with the associated type exposing the type parameter
-
extract-variant
Destructure expressions into, and return assignments from, a single pattern
-
retry_macro
A set of declarative macros which retries executing a function upon failure
-
cause
A generic [std::error::Error] implementation
-
ewin-term
editor for Window(GUI) users.No need to remember commands
-
text-block-macros
Create a multiline string literal
-
typify
JSON schema to rust type code generator
-
generic_static
Generic static variables in generic functions
-
dicom-object
A high-level API for reading and manipulating DICOM objects
-
ghost123
Define your own PhantomData
-
final_fn
macro, what executes given code when leaving code block
-
bloock-blake-rs
Blake hash implementation
-
hlist
Heterogeneous list with type-directed search
-
yadi
dependency injection framework for writing applications with the Rust programming language
-
pin-projections
Declarative macro for creating projection functions for pinned objects
-
kinder
small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
byte-mutator
define staged mutations for a series of bytes
-
funlib
Rust functional library
-
sod-tungstenite
Service Oriented Design - Tungstenite
-
macon_api
builder macro-based generator with its own idioms
-
struct-convert
Auto Convert between structs
-
iter-tee
Make several clones of an iterator
-
truthy
Check if a value is "truthy"
-
size_hint
A very simple library to provide a size_hint for an iterator which does not provide it's own
-
unreachable_checked
unreachable!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won't panic.
-
global_var
macro for declaring a global variable
-
slicefields
Allows for data structures whose members are sub byte aligned (e.g. a one bit alignment)
-
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
-
namewise-common
Derived trivial name-wise conversions for Rust types
-
r-ex
Zero-bloat Rust core library extensions
-
slip
A hassle-free utility to encrypt error handling strings in your public binaries to protect your business logic
-
nanopre
A a zero-dependency, no-unsafe implementation of a minimal C-style text preprocessor
-
binstring
Binary strings
-
stackpin
data that should be pinned to the stack at the point of declaration
-
nstd_env
NSTD env crate
-
new_flattened
Macro to flatten nested calls of
new
s -
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
xops
procedural macros for overloading operators
-
fallible-option
Fallible is an Option with inverted Try-semantics
-
id-ish
Numeric ID types that can be swapped in & out
-
interpolate_idents_gnzlbg_fork
Useable macro identifier concatenation plugin
-
frankencell
An alternative to
qcell
andghost-cell
that instead uses const generics -
tap-trait
Inspect and mutate values without leaving the method chain
-
match_opt
A macro for turning a partial match into a full match returning an option
-
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
-
game_inventory
An inventory system independant of item data
-
unsafe-any-ors
Traits and implementations for unchecked downcasting
-
nias
closure generator library
-
select_indices
Iterators for taking multiple shared/exclusive references from a slice
-
rc-borrow
Borrowed forms of Rc and Arc
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
yolo-block
Like a
try
block, but automatically unwraps the result -
repository
all kinds of entities
-
assure
macros for Rust runtime checks and error handling
-
copypasteck
A plugin lint for detecting
if
andmatch
branches with duplicated conditions or contents -
timely-container-master
Container abstractions for Timely
-
cynic-proc-macros
Procedural macro crate for cynic - a code first GraphQL client for Rust
-
hemtt-preprocessor
A preprocessor library for hemtt
-
fuzzypath
Quick & dirty fuzzy path comparison
-
bracer
Macros to help write ARM assembly
-
oyashio
spmc streams
-
mdo
Monadic do notation for rust using macro and duck typing
-
always_equal
A wrapper for types that can't implement Eq
-
from_iter
Initialize arrays from iterators
-
djb_hash
commonly used Daniel J. Bernstein style hash functions.
-
supertrait
enables default associated types and const fn trait items in stable Rust
-
trait_enum
Easy enum wrapper that implements all traits that the wrapped objects implement
-
soapy-shared
Custom types used by soapy macros
-
restate
state machine library
-
appro-eq
Approximately equal traits and assertion
-
string-builder
string builder type
-
dyn-ptr
A box that stores types like pointers, forgetting everything besides
Self: Unsize<dyn Trait>
-
map-self
Map a value itself instead of its contained value in usual closure style
-
deflect
Reflection in Rust via DWARF debug info
-
dynerr
Macros for dynamic error handling
-
cor_iter
Correlate of two iterators
-
inew
Macroses for constructor generation
-
gitoxide-core
implementing all capabilities of the gitoxide CLI
-
standalone-quote
Fork of quote that allows disabling the proc-macro feature in proc-macro2 so as to remove the rustc dylib dependency
-
infix_macro
macro that generates the neccesary boilerplate to use "*operator*" infix functions
-
extension-eyre
Re-export of color-eyre that introduces Extensions (type-map) to eyre::Report
-
edisp
Dispatch-on-collect for Rust enums
-
dyn_struct2
Construct dynamically sized types safely. Supports arbitrary unsized types, not just slices
-
specialize
Type specialization macros and helpers
-
import_file_macro
Macro from compile-time file loading
-
tagname
get the name of a variant in your enum as a string
-
interior_mutability_pointer
A wrapper around
Rc<RefCell<T>>
allowing immediate access to inner methods -
deep-struct-update
Struct update syntax with nesting
-
lifelink
Erase covariant lifetime parameters from anything, with generic associated types
-
rusty-peg
A macro for defining PEG parsers
-
pyphen-rs
A pure Rust port of Pyphen, a Python hyphenation library
-
trait-set
Support for trait alias feature on stable Rust
-
incomplete
incomplete!(), a compile-time checked version of unimplemented!()
-
plmap
Parallel pipelined map over iterators
-
lambek
Type-Level Programming in Rust
-
uptown_funk
Define host functions compatible with Wasmer and Wasmtime
-
model_macro
traits collection
-
crowbook-intl
An internationalization library to localize strings, translating them according to runtime option, using macros
-
lubeck
Functional programming framework written in cutting edge rust
-
borrowck_sacrifices
Necessary sacrifices to keep the Borrow Checker happy and developers sane
-
cosmian_std
Cosmian std lib to write Rust MPC programs with easier abstractions and helpers
-
infinite-iterator
A trait for iterators that never end
-
try_all
Extends iterators with
try_all
to convert iterator of results into result of iterator of okays -
option-cell
OptionCell: OnceCell but derivable from Option
-
ctrl_macros
Control flow macros for Option and Result
-
zhi_enum
derive macros to easily use enum
-
polyhorn-style
Shared types for Polyhorn style
-
failsafe
A circuit breaker implementation
-
finite-fields
Traits and types for computations on finite fields
-
substrs
substring functionality for the str type in Rust
-
merged_range
rangeset that can merge overlap
-
piping
Pipeline syntax in Rust.
4isize |> double(__) |> __ as usize
. -
enum_to_enum
Derives possibly effectful conversions between enums
-
nommy
Type based parser
-
clonelet
macro to capture by clone in closures
-
kwarg_macros
Keyword argument plugin
-
docgen
made for dynamically documenting Rust items created by a macro
-
handler_map
Map from types to functions that receive them
-
iterator-ext
An extension to Rust's Iterator
-
identifiers
working with rust identifiers and keywords
-
unty
Explicitly types your generics
-
anymap
A safe and convenient store for one value of each type
-
quark
Types for manipulating numeric primitives at the bit level
-
detour2
A cross-platform detour library written in Rust
-
beginnerror
error-handling crate for beginners
-
dry-mods
Macros to make your module management DRY
-
hashmap_macro
hashmap macro for creating hashmap from provided key/value pairs
-
citadel
-
abort_on_panic
Intercept panic! from unsafe locations and abort the process
-
overflow-error
Common overflow error types
-
vesta
Extensible pattern matching
-
io-trait
I/O traits
-
tapir
Adding tapping functionality to rust
-
unwrap_or_do
Unwrap the Result or do an expression followed by returning the result
-
extended_matrix_float
Float trait for extended_matrix lib
-
fat_type
A type which permits thin references to arrays and dynamic types
-
multindex
Index slices with multiple const indices/ranges
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
rust-fp-categories
A Functional Programming Library in Rust, Category
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
u-plus
Pretty Unicode code point literals: U+12345 instead of '\u{12345}'
-
lua53-ext
Extension to jcmoyer's Lua 5.3 bindings
-
flow_impl
Definition of an Implementation trait for flow functions, and a derive macro
-
bytebuff
usefull derive macro for serializing data to send ower network
-
fastperm
A dead-simple, extreme fast permission flag system for Rust with no dependencies
-
plugger-ruby
Ruby bindings to Plugger
-
injectify
impl Trait in structs
-
zkp-macros-lib
procedural macros implemented using
proc_macro2
-
read-restrict
Restrict the number of bytes read from a reader
-
try_ops
try catc... ops macro
-
lox_utils
General helpers used by Lox
-
source-chain
Formats StdError with it's source chain
-
easy-conv
Cut down on trivial
impl From<A> for B
boilerplate code -
trait-union
Stack-allocated trait objects
-
arcmutex
A convenience library for working with
Arc<Mutex<T>>
s -
upget
Super simple trait that patterns the value "updae" and "get"
-
checked_clamp
Clamp alternative that returns a result instead of panicking
-
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
-
html5ever-atoms
Static strings for html5ever
-
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.
-
morseclock
not-so-intuitive clock
-
macro-attr
macro_attr!
macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derive
crate. -
fallacy-clone
fallible clone
-
summavy-sstable
sstable implementation
-
fs_util
A package providing a few useful functions that std::fs does not
-
const-concat
Heinous hackery to concatenate constants
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
mapstruct-derive-lib
A derive macro for mapstruct
-
encoding-next_index_tests
Helper macros used to test index tables for character encodings
-
parameterized_test
A macro to support providing arguments to test functions
-
mixed_array
Construct arrays of mixed types
-
ripin
that handle Reverse Polish notated expressions, compiles, and evaluate them
-
swiss-army-knife
Common utility code to support linux-support and other projects
-
try-continue
Allows processing of iterators of Result types
-
fluent_builder
builder API
-
error-utils
Some rust macros to simplify common error handling patterns
-
ufcs
Helper trait to call free functions using method call syntax
-
formy
derive macro to turn structs into html forms
-
spawn_interval
Call a subroutine at a constant time interval
-
generator_extensions
Basic extensions to Generator types to bring parity with Iterators
-
rstring-builder
String builder type
-
beam_bvm_util
A light wrapper around beam_bvm_interface with some extra utilities that would be useful for interacting with the bvm
-
contains
A Container trait
-
lazy_transducer
Lazy, parallel, indexable, generic data iterators
-
iter-opt-filter
Adds an optional filter to iterators
-
eater_rangeset
work with set's of ranges
-
foot-gun
Friendly aliases for your unsafe code
-
yasi
String Interner
-
politeness-macro
Isn't it time to be a bit nicer to rustc?
-
proc-easy
Macros to make writing proc-macro crates easy
-
apply_attr
A syntax extension providing higher-order attributes to Rust
-
push_mut
Push a value to the back of the vector, and return a mutable reference to it
-
xplane_plugin
types and a macro for creating X-Plane plugins
-
cfg_matrix
Procedural macro to generate permutations of supertraits based on cfg flags
-
static_assert_macro
so-called
static_assert
-
newtype-enum
Traits to convert between enums and their variant types
-
ass
Useless crate for casting
-
inline-const
Inline consts implemented as a macro
-
stivale_rs
Rust bindings for the stivale boot protocol
-
deref_owned
Generalization of std::borrow::Cow
-
aggregate
attributes of structs for runtime
-
has_fields
Some macros helpful for processing forms with optional fields
-
zerror_core
A complete implementation of the zerror:Z trait
-
axmac
Readable indexing macros for 1-4 dimensional data structures
-
on_drop
on drop
-
rustollens
A small and experimental library with a type-level representation of booleans with companion connectives for compile-time sort-of fun with logic
-
stable-step
Step for stable rust
-
iter-scan
Iterator scan methods that don't suck
-
external_mixin_umbrella
Backing library for
rust_mixin
andexternal_mixin
to keep them DRY -
fake-enum
creating FFI safe "fake" enum types
-
errer
Flexible error management for Rust. An middle-ground between failure and SNAFU
-
nes
New Error System for rust
-
lifterr
A small set of adapters extending Rust's error-handling capabilities
-
try_fold_impl
macro for deriving Iterator::next and ::fold from a ::try_fold implementation
-
loop_unwrap
macros for unwrapping in loops
-
byteorder_slice
Byteorder like crate for &[u8]
-
steel-gen
Code generation crates for use within steel
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Option
s and enforcing invariants -
meritrank2
Meritrank library with additional experimental functions
-
irox-types
Enums and structs to describe Rust's basic type system
-
cargo-verify
Prettier error messages for the verified crate
-
rustspec
BDD style test library
-
future-union
Use future::Either with
impl Future
-
derive-alias
Alias multiple derives as one
-
cursor
A more free Rust-Iterator
-
bpack
Fast, simple and easy to use data compression library meant to work with byte slices of String and str types
-
gpp
A generic C-like preprocessor for Rust
-
eieio
Error Implementing
Eq + Clone
replacingstd::io::Error
-
ninja-files-kustomize
Ninja file functions for kustomize
-
enum_variant_macros
Macros to generate From & TryFrom for enums
-
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. -
error-context
Methods and types that help with adding additional context information to error types
-
to_trait
A trait with methods similar to .into() and .try_into(), except they take type arguments
-
flat_vec
macro to flatten nested Vecs. Particularly useful when you want to write a rules of egg which contains rules both => and <=>.
-
custom_enum_traits
A set of traits for dealing with enums
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
one-of
Macro to represent a type that can be converted either
From
orTryInto
the given types -
is-impl
Rust macro to check that a type conforms to an impl
-
yield-return
Implement a coroutine like C#‘s
yield return
using Rust’sasync
,await
-
iterx
that provides several functions on the Iterator trait not found in std::iter or Itertools
-
err-with
🤔 Trait for adding context to errors
-
improved_slice_patterns
A tiny crate that provides macros to help matching on Vecs and iterators using the syntax of slice_patterns
-
ghosts
Type-check non-existing
Phantom
code for Fun And Profit™ -
predicates-core
An API for boolean-valued predicate functions
-
effect_cell
Container that runs effects when updated
-
tiny-error
A small crate for simple error handling
-
transformable_channels
Rust channels are a convenient abstraction, but for many uses cases, they miss high-level transformations such as
map
,filter
, … . This crate introduces them. -
typestring
String constants lifted into types. This is a stopgap until const generics support strings.
-
token_store
A token-based store for arbitrary values
-
inline_newtype
newtype macro inspired by kotlin's inline class
-
dbg_mac
Handy debug only macros
-
reglex
lexer generator using regex
-
array-lit
Macros for array and
Vec
literals with superpowers -
slice-diff-patch
providing utility functions for diff and patch of slices
-
mauzi
Experimental i18n library using proc-macros
-
is_send_sync
Macro to tell if a type is Send/Sync
-
modifier
Fluid chaining APIs for both mutable ownership types
-
shedron
A DSL for dice rolls
-
take-if
A tiny utility for conditionally taking the contents of an option
-
cfor
A macro that gives Rust a C-style for loop, with initialisation, condition and step. This correctly handles control-flow like continue and break.
-
brain_rust
A BF transpiler to rust written as a rust declarative macro
-
ext-trait
Annotation to easily define ad-hoc / one-shot extension traits
-
simple-xml-builder
XML builder/writer
-
encdec-base
encdec simple encoder/decoder base types and traits
-
hacspec-lib
The hacspec library
-
error
A fancy error type for highly generic cases
-
garando_syntax2
Backport of libsyntax
-
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… -
fn_block
defining macros for calling blocks or expressions in a closure
-
cubob
Structured output helpers for display mode
-
total_float_wrap
Floating point wrapper implementing Hash and Ord according to IEEE 754 totalOrd
-
hexf-parse-libm
Parses hexadecimal floats (see also hexf)
-
postgres-mapper
Struct mapping for postgres
-
type-record
A type-level record (see documentation for details)
-
diff-ba-rs
macros to get the difference of variables caused by a procedure
-
sum_error
Derive macros for fast summing of error types into error enum
-
scanio
console input macros with the goal of being implemented in the standard library
-
furtif-core
Flexible User-oriented Rusted Toolbox for Information Fusion: a data fusion toolbox based on asynchronous and interacting processes, particularly focused on belief functions fusion
-
fstrings
Python3 fstring interpolation in Rust
-
catch_panic
A helper macro for safe Java-Rust interop that "catches" Rust panics and rethrows them as Java exceptions
-
factory
Factory
trait and its implementations -
peekable_next
An extension for Rust iterators to peek at the next element without advancing
-
ternop
A tiny macro that implements a ternary operator for Rust
-
unwrap_all
Unpack multiple levels of
Result<T, E>
andOption<T>
at once -
derive-from-ext
Derive macro implementing 'From' for structs
-
ryu_floating_decimal
Fast floating point to floating decimal conversion. See the crate 'ryu' for more details
-
enum_primitive
Macro to generate num::FromPrimitive instances for enum that works in Rust 1.0
-
typesets
Enables generating subtypes and supertypes of a given type via derive macros
-
unsafer
Convenience library for Unsafe Rust
-
xwt-error
A suite of reusable error types that naturally emerge from the xwt API. Use when you don't want/need your own more precise types
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
float-derive
that allows deriving Eq and Hash for types that contain floating points
-
uncheck-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
rvs-c-api
C-API for Rvs - A library for defining and evaluating random variables using a simple DSL
-
derive-attribute-utils
derive-attribute
-
bagel
Compile-time evaluation and other tools
-
label
functions and iterate over them
-
ioctl-gen
macros for generating ioctl numbers
-
display_macro
Like print! macro but always flushing
-
retour-utils
creating hooks with
retour
-
deferrer
defer! macro for deferring functions
-
html_stack
A stack based dsl for writing html. This is not an html template!
-
shank_gov_idl
Converts information extracted via shank derive macros to a solita compatible IDL
-
jrust
macro that parses Java-like syntax and runs it as a Rust program
-
hazmat
A collection of helpers for working with hazardous materials in Rust crates
-
chained
lazily chaining functions
-
orion-async
Eliminate this constraint for performance - the local variables of asynchronous functions must implement Send Trait
-
overflower_support
A bunch of specialized traits + impls to allow automated overflow handling without type inference. Nightly only
-
transfer
that exposes a Transfer trait, that is to move what Clone is to copy
-
sbnf
A BNF-style language for writing sublime-syntax files
-
pathsep
a small macro to enable easy path construction in other macro calls
-
nstd_str
NSTD strings crate
-
autowired
Rust dependency injection
-
dyn_size_of
report approximate amount of memory consumed by variables, including the memory allocated on heap
-
compost
Adds a macro to decompose tuples into tuples containing a subset of their values
-
bin-pool
A small crate for interning binary slices
-
slice-copy
Go style copying for slices
-
minipre
Minimal C-preprocessor in Rust
-
dynamic-struct
A derive macro for creating push-based reactive properties for structs with named fields
-
if_empty
Replace if/else checks for emptyness with a simple method call
-
rusty-matrix
A generic matrix implementation
-
with-api
macro for shrinking scope
-
phantom-enum
macro library for creating phantom enums
-
cargo-emit
Talk to Cargo easily at build time
-
checked_ops
Automatic checked arithmetic operations in Rust
-
i-codegen-code
Common tools supporting the
derive-codegen
crate -
parametrizer
safe crate for parsing properly-formatted math strings representing parametric functions into Rust functions
-
throws
A macro for easy creation per-function errors
-
rust-hl7
HL7 Parser and object builder? query'er? - experimental only at any rate
-
git-ref-format
Everything you never knew you wanted for handling git ref names
-
fsize
fsize
is aliased to the floating-point type of pointer size -
expecto-patronum
add beatiful animals to your panic outputs
-
kalgan_string
A collection of functions for string manipulation used by Kalgan Framework
-
extrude
A macro for unwrapping an enum value into an Option
-
more_io
Additional functions to read and write as primitive types
-
shrinkwraprs
Auto-derive for Rust conversion traits -- make working with newtypes a breeze
-
fix_fn
Macro to create recursive closures (similar to the Y combinator)
-
vect
providing vectors for game development that use a Unity-like API
-
koption_macros
Some macros that are useful for working with
Option
s -
anon_enum
Enum types with fully-generic variants
-
impl_serde_serialize_error
Macro for fast implementing error methods in serde::Serializer trait
-
vector3d
3D vector type
-
scout-audit-clippy-utils-soroban
For internal usage by cargo-scout-audit
-
struct_baker
enable ergonomic creation of compile time parsers
-
what-i-want
Some tools to help with the return value
-
structinator_traits
traits allowing transfer of data from iterators to structs
-
verified
types to facilitate the development of verifiable rust
-
foreignc_util
error handling in foreignc
-
namable_closures
types and macros to create namable closure types
-
volcell
A container type that can hold volatile data and allow for safe reads and mutation of its contents with support for use in packed structs
-
letr
The macro for the lazy
-
maybe-unwind
A wrapper of catch_unwind that also captures the panic information
-
tested-trait
Associate tests with traits
-
set_slice
A macro for assigning values to slices
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
arrayinit
Robust and simple API to initialize arrays
-
giveup
User-geared error messages and hints
-
default-option-arr
Macros for simple default initialization of arrays of option types
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
predicate
Use enum to predicate something, support & and | operator
-
eset
flags like enums
-
dyn_partial_eq
PartialEq macros for trait objects
-
kmacros_shim
Useful macros
-
abi_stable_shared
detail of abi_stable
-
show-option
displaying Options
-
cvars
Configuration variables - a simple and ergonomic way to store and edit configuration at runtime
-
unsafe-any
Traits and implementations for unchecked downcasting
-
unnest
Macros for an unnested control flow
-
derive-sql-common
Common functions supporting
derive-sql
and associated crates -
type-layout
Derivable trait to view the layout of a struct, useful for debugging
-
envoy
Conveniences for manipulating environment variables
-
mixed-num
A trait for generic implementations of numerical methods
-
duplex
trait: interactive streams
-
endian_trait
A trait for Endianness conversions that can be implemented on most types
-
check-ends-macro
A couple of macros to simulate match with starts and ends of a string
-
do_while
macro allowing clean 'do-while' loops in Rust
-
clonesure
A helper macro to create closures which will clone its environment
-
respan
Macros to erase scope information from tokens
-
tuple_tricks
A couple of traits on tuples that allow inductively building new traits
-
shorten
A collection of convenience functions, macros and traits to shorten repetitive code
-
result-inspect
Adds the missing Result::inspect() function
-
byte-array-struct
Macro to create a byte-array backed struct
-
maelstrom-test
Test macros for Maelstrom
-
explicit_cast
explicit widening, truncating, and sign casting of primitive integers
-
std-io-peek
Peek trait
-
fn_zip
zip trait for functions, allowing two functions to be combined at compile-time before being called
-
static-include-bytes
Like the built-in
include_bytes!
macro but produces a static array definition -
aliri_braid_examples
Examples demonstrating usage of the
aliri_braid
crate -
split-optional
It split from a source
str
toOption<&'a str>
per an element -
specialize-call
A macro to invoke a function with type-arguments substituted according to a runtime value
-
actify
An intutive actor model with minimal boilerplate
-
tt-call
Token tree calling convention
-
cmd_lib_core
Common rust commandline macros and utils, to write shell script like tasks easily
-
ez-err
error handling library with support for ergonomic and fast error handling
-
adrop
fast dedicated thread drop
-
stringer
An easy way to turn an Unsafe *const c_char into a Rust String type and return a pointer
-
entwine
Generic slice-like interface for operating on multiple slices at the same time
-
rust_hawktracer_normal_macro
helper crate for hawktracer profiling library
-
nagios-range
types to parse and operate on Nagios ranges
-
tearor
Easily turn data races into data corruption!
-
virtual-io
Mock stdin/out/err for testing
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
event-observer
observer pattern by rust
-
common-strings
Macro for storing common strings as enum variants
-
unreachable
code optimization hint in stable rust
-
udf-sys
UDF system bindings
-
wurm
Non-fatal, strongly typed errors
-
demo-duang
Demo of duang
-
assert-impl
Macro for static assert types implement a trait or not
-
null-terminated
slices and UTF-8-encoded strings with thin references
-
byteorder_core_io
reading/writing numbers in big-endian and little-endian
-
displaydoc-watt
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
disown
Drop ownership via a method
-
kind-derive
Derive generator the kind compiler
-
slice-string
A String backed by a slice
-
unique
ptr::Unique for stable Rust
-
partial_eq_dyn
Two traits to enable PartialEq for types with trait objects as fields. Best used with the derives in partial_eq_dyn_derive
-
named_constants
Procedural macro makes enums behave like named constants in languages like C/C++ or C#
-
passable_guard
A Guard to help you catch leakage of pointers that you pass over a FFI boundary
-
ttype
quick macro for printing or returning the type of a variable
-
collected
Summation, product, maximum and more special collectors for Rust iterators
-
precisej-printable-errno
Printable system call errors for nix
-
regex-bnf
A deterministic parser for a BNF inspired syntax with regular expressions
-
block_effects
A macro to chain block effects
-
hlua-badtouch
badtouch specific fork of hlua
-
fancy-ip
Fanciest way to initialize IP addresses
-
tracing-assert-macros
A macro for capturing trace logs
-
status
Error container
-
scanfmt
easy to use macro for parsing a string
-
bail-out
Macros to help keep code clean for validations and error handling
-
mistake
An error handling crate for functions that produce multiple errors
-
partial-functional
A small collection of Semigroups and Monoids for rust
-
laxcow
Clone-on-write smart pointer with relaxed trait constraints
-
vecmerge
A macro for merging vectors
-
zigbee2mqtt_types_base_types
Common definitions for zigbee2mqtt vendors
-
handle-error
An error handling helper macro to avoid the constant if let Err(e) pattern
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
assert-parse
The util to assert macro parsing
-
retryable
Automatic function retry macro
-
transitive_from
Helper macros for creating hierarchies of transitive
From
implementations -
stable_borrow
A marker trait indicating that borrows are address-stable
-
reinterpret
Low level utility functions to reinterpret arrays of data
-
num-conv
num_conv
is a crate to convert between integer types without usingas
casts. This provides better certainty when refactoring, makes the exact behavior of code more explicit, and allows using turbofish syntax. -
friendly_safety_buddy
A fun macro to write safe code with
-
arbintrary
Proof of concept for arbitrary integer sizes using generic const
-
trace-error
Extensions to Rust's error system to automatically include backtraces
-
stable-pattern
Stable port of std::str::Pattern and friends
-
is-same
A trait for comparing object equality
-
rustility
A collection of utilities I often find myself using in Rust
-
inline_default
Macro for inline Default implementation
-
maybe_static
Initialize a lazy static with params, create Meyer's singleton
-
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.
-
assert-cmp
Convenient assertion macros that print the failed expressions and their evaluated values
-
type-level-logic
Primitive types and operations for type-level logic
-
constrained_type
On the fly value objects in Rust
-
col_proc_macros
A bunch of procedural macros for declare collections of various kinds from their contents as fast as possible
-
keepops
Extension traits for keeping the input of mapping functions
-
meticulous
Result extension to add more meaning to unwrapping
-
any_ref
To capture and move things that are NOT 'static with memory safety
-
omniswap
swap values between possibly-overlapping references
-
forwarding_gen
Syntax processing for emulating OOP Inheritance in Rust by forwarding trait methods
-
derive-for
Macro for defining structs using the same derive procedural macros
-
spawn_timeout
Call a subroutine after a constant time interval
-
febits
containing small utilities to help with certain tasks to make things easier. Primarily the tools will consist of ways to manipulate primitives and other data types.
-
rustpy
Bindings of Rust programming language primitives
-
vec3
-
fmt_adapter
newtype adaptors to and from any formatting trait
-
assert_ne
assert not equals
-
sod-mpsc
Service Oriented Design - Multi Producer Single Consumer
-
clamped_values
generic
ClampedValue
struct that stores a value and ensures that it is always within the specified minimum and maximum values -
bpx-api-types
Backpack Exchange types
-
unify
Trait-based equality constraint for Rust
-
macro-while-mut
Macro that allows create while-cycle with mutable condition state
-
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
ptr
Unique pointer
-
pipette
Polymorphic function pipelines without traits or macros
-
tool
A grab-bag of tools for functional programming
-
mut_family
A GAT-based library for writing code that is generic over exterior/interior mutability and mutability of references
-
try-blocks
macro to emulate the upcoming
try
block feature on stable -
nonzero
Statically checked non-zero integers
-
errors_rust
Just a simple library for error mapping
-
pod
Plain Old Data (POD) encoding and I/O
-
parser-c
Macros for parser-c
-
prange2
Parse numeric ranges for indexing
-
derive_empty_traits
derives an empty trait on structs / enums
-
sashay
Type-erased and lifetime-erased references and slices
-
tia
tia; trait, impl, accessors | automatic
-
try-traits
Alternatives to std lib traits that can fail
-
davenport
Ergonomic thread-local workspaces for intermediate data
-
into-result
convenience trait for converting something into a
Result
orOption
-
stringish
A smaller and easier copy-on-write string
-
shpat
sasha's solution to common patterns
-
erroneous
Minimalistic helper for using errors
-
smart
dynamically-dispatched smart pointers
-
stripmargin
but elegant multiline string in Rust à la Scala
-
tartan-c-enum
Define FFI-safe enums that support unknown values
-
vertigo-html
Html2Vertigo conversion macro usable re-exports
-
krunner
writing KRunner plugins in Rust, easily
-
rand-gen
Allows for easy creation of random data for structs!
-
borrown
Borrowed or owned, simplified for no-std
-
clap-action-command
A command-map pattern layered on Clap subcommands
-
introspectable
Basic introspection via the Introspectable trait
-
numeric_cast
safe cast between numbers
-
enum_derive
macros for deriving additional functionality for enums
-
io-ensure
Prototype of the
std::io::ensure
family of macros -
trackr
Track changes on a struct as bitflags
-
rudeboy
Rlua User Data Extension Boy - Derive/attr macros and traits for easily exporting user data to RLua
-
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
sanitizeable
derive structs without certain fields
-
useful_macros
My useful macros
-
trait-theories-std
A collection of invariants of Rust std traits
-
test-results
A series of utility macros for outputting testing results
-
keypath
Derivable, type-safe Swift-style keypaths
-
kimari
Universal DSL for writing rules against the context in Rust
-
bitfields
Helpers for storing sub-byte enums in primitive types
-
chemistru-macro-api
API for chemistru macros, generating element constants and maps
-
u16cstr
A macro for creating c-style u16 wide strings at compile time
-
is_trait
Add a macro to check if a type implements a trait at runtime
-
johalun/module
FreeBSD kernel module in Rust
-
fast-map
Map-like structs
-
anyflux
Generic flux-like state management
-
convi
Convenient (but safe) conversion (
From
-like) traits -
khtml
macros for simple html generation
-
mic
Facilitates answering to competitive programming problems
-
uninitialized
Opt-in unsafe uninitialized memory
-
vec_remove_if
Extract elements from a vector based on supplied criteria
-
cpp_to_rust
Automatic generator of C++ library wrappers
-
and_then_some
extension trait for
bool
with methods that returnOption<T>
-
refid
Newtype enabling identity comparison (e.g. through pointer equality)
-
error_log
struct-based Error-Handling
-
futility
Functional Utility types, macros, and functions for common tasks or needs in Rust
-
init_with
Helper trait to initilize an array with a function
-
correct
A number wrapper that has correct bitwise shift behaviors rather than the primitives in rust language
-
thiserror_lite
Almost drop-in replacement for thiserror, implemented using 100% declarative macros
-
static-cond
Macro for performing comparisons during macro expansion
-
close
Trait + smart pointer for manual object destruction
-
comptools
Create iterators using Python's list comprehesion style
-
monomo
Explicit trait monomorphization
-
derive-ex
Improved version of the macro to implement the traits defined in the standard library
-
sim_connect_data
containing Rust-esk data types for use with SimConnect via sim_connect_rs
-
lifetime
Traits and derive macros to change the lifetime of a type, allowing efficient reuse of your stucts or enums with any lifetime requirement
-
tindex
Vec
, slice and bitset with custom index types -
option-filter
Option::filter polyfill for Rust 1.26 and older
-
evaluator
interfaces and implementations for logic constructs that return values without accepting arguments, either via closure captures, global state, calculation or otherwise
-
jstring
JavaString uses short string optimizations and a lack of a 'capacity' field to reduce struct size and heap fragmentation in certain cases
-
generic_error
A package containing a generic error type that can be dropped in to simplify error handling
-
errormake
A macro for automatically creating Error structs
-
better-as
Explicit type casting
-
tagged_cell
Fast, initializable, and thread safe static variables
-
debug-tag
Debug-only tagging for tracking values
-
conditional
conditional! macro which lets you use the syntax of the conditional operator (also known as the ternary operator) in Rust
-
conform
Macro to transform struct string fields in place
-
underscore_args
Macro for underscore named argument syntax, aka Dyon
-
kaguya_rs
Functional Programming tools and ADTs
-
set_field
Set fields on structs by string
-
chain_linq
.NET's LINQ in rust as a declarative macro
-
mapcomp
Python-like list comprehensions for standard containers
-
bounded_types
type representing bounded integers, implemented using const generics
-
many_op
do an operation on many variables
-
string-error
A minimal rust library to create errors out of strings
-
schnauzer_ui
A DSL for browser based automated testing
-
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
kvfmt
A helper macro for stringifying variables into a key=value style string
-
drop_ok
.drop_ok
syntax sugar forResult
. It’s instead of.map(|_|())
. -
bos
Flexible Borrowed, Owned or Shared (B.O.S.) smart pointers. Like std's Cow but with Rc/Arc and without the ToOwned requirement
-
unchained
Iteration
-
collections_macros
a collection of macros to make making collections easier
-
colmac
Macros to work with
std::collections
-
raml
Direct OCaml FFI bindings and runtime functions in Rust, without any C
-
convertable-errors
defines an ergonomic macro for deriving From<Foreign> conversions for variants of Rust enums
-
newtype_derive
macros for deriving common traits for newtype structures
-
shellexpand-fork
Shell-like expansions in strings
-
io_resp
A RESP parser implementation, written with edge performance in mind
-
size
expressing, formatting, and interacting with file sizes
-
enum_const
enum const trait
-
deep-bind
A macro for using threadlocals to deeply bind contextual values
-
bool-mappings
Useful extensions to convert
bool
to other Rust types -
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
unwrap_helpers
Helper macros for unwrapping
-
box-macro
Literally just the macro
box_!
which isBox::new
-
type-uuid
Safe, stable IDs for Rust types
-
assert_exists
Useful macro to assert that a certain symbol exists in the source code. This is useful to strictly couple otherwise loosely coupled functions and symbols that depend on each other.
-
fn-compose
A small macro for function composition
-
peano
numbers implemented in Rust's type system. Consider using typenum instead for much faster type-level numbers.
-
join_to_string
Join a list of items to string/buffer
-
cpp_to_rust_generator
Automatic generator of C++ library wrappers
-
rle
run-length encoded data
-
eso
Type machinery to build Cow-like containers
-
cereal
data serialisation library
-
refute
Add a refute! macro(Elixir inspired). Essentially assert!(false).
-
gilder
Golden testing library
-
vec2
-
sc2-macro
Procedural macros for rust-sc2 API
-
drop_some
.drop_some
syntax sugar forOption
. It’s instead of.map(|_|())
. -
scones_examples
Examples (and tests) for the Scones crate
-
with-thread-local
A micro crate that simplifies a bit the use of the std macro
thread_local!
-
audi
Generic listener abstraction
-
should-be
Postfix assertions of equality
-
take_mut
Take a T from a &mut T temporarily
-
hash-that-set
Implements hashing for sets and maps themselves. Enables a map of maps to values, or a map of sets to values.
-
tupl
Perform generic operations on tuples
-
zc_io
zero-copy I/O
-
newtype
Custom Derive to give tuple structs newtype semantics
-
forward-methods
A derive macro for forwarding methods from composed objects
-
layout-lib
view the data layout of a struct
-
atomic_refcell_try
Threadsafe RefCell
-
const-identify
Generates unique ids that can be used at compile time
-
plugin
Lazily evaluated, order-independent plugins for extensible types
-
then
bool::then functions but named properly
-
iterator-endiate
Extension method for (exact size) iterators which yields tuple containing whether item is last in iterator
-
type-path
Get the string array representation of a Rust type path
-
uzero
UZero
-
fstrings-rust
Python3 fstring interpolation in Rust
-
byterepr
trait for converting PODs to and from their byte representation, with low (usually no) cost
-
encoding_index_tests
Helper macros used to test index tables for character encodings
-
from_int
A package to easily add a from_int method to enums with #[derive(FromInt)]
-
stats_traits
Traits for collection-like types to calculate statistics
-
cmp_any
Comparison for &dyn types
-
purescript_waterslide
Generate Purescript types from your Rust types
-
tuple-conv
Allows converting tuples of one element to vectors
-
litenum
minimal convertion utilities between literal and enum
-
raise
yeet!
all the things -
nstd_time
NSTD time crate
-
collect_array
Allows for collecting an Iterator into an exactly sized array
-
duktape
Embedded JavaScript interpreter with a small footprint
-
atomik
Generic Atomic type
-
template-builder
making idiomatic, declarative, builder-like patterns that use the struct literal syntax
-
matrix_match
Macro to match on two values at the same time
-
std1
-unofficial- additions to the rust standard library, via a quickly typeable name
-
rusty_state
state machine for rust
-
eaip
Fetch, parse and handle data from electronic aernautical information packages (eAIPs)
-
mutable-constant
Mutable access to a constant value
-
if-let-return
macro for
if let ... pattern
-
polymorph
A set of utilities to better enable polymorphic behavior in Rust
-
stackvec
stack-allocated Vectors (performance and/or no-std)
-
serde_str_helpers
Helpers for using serde with strings
-
exclusive
Place code into an exclusive context that won't collide with another context
-
discard-while
Get the first non-matching element, and the amount of discarded elements
-
beard
Handy macro to generate formatted text in rust
-
bointer
Assorted pointer-related utilities
-
clone-into-box
cloning trait objects
-
wrapped_enum
Useful macro to wrap existing types in an enum (common use for quick error handling)
-
typester
Convert Rust types to Typescript types. This crate is meant as a teaching tool and not for production.
-
transition-table
transition table utilities for keyword parser
-
bit_fiddler
Macros for common bit operations with multiple convenient patterns
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
try_wrap_ok
?
ortry!
macro, with an additionalOk
wrapping -
enum-code
derive(Code) simplifies error handling by providing an easy-to-use enumeration of error codes
-
cart_prod
Cartesian product of iterators
-
zoozle
Some I/O macros like C++ cin/cout
-
derive_is_enum_variant
Automatically derives
is_dog
andis_cat
methods forenum Pet { Dog, Cat }
-
capture
A macro for adding explicit capture clauses to a (closure-) expression
-
const-anonymous-functions
macro to create const anonymous functions
-
packetrs
Macro-based struct serialization/deserialization
-
rust-enum-derive
(and program) for generating rust enums and associated traits from text files
-
generic-lexer
A generic lexer using a simple match function
-
vecc
macro to create a vector of vector
-
tylar
Type-Level Arithmetic in Rust
-
md_match
A macro to support md-match syntax
-
iteritor
Helpers for more advanced use of iterator combinators and other more functional control flows, including things that may not really fit in the std iterator library or itertools, but…
-
arg_attr
Specify the accepted arguments depending on configuration conditional checks
-
struple
Convert structures from and to tuples
-
derive_destructure2_examples
Examples for crate derive_destructure2
-
adhocerr
construction of efficient single use static/dynamic error types per callsite
-
unibox
Universal Box that can store any type using static or dynamic memory
-
iter-flow
Functional programming utilities for Rust
-
into_variant
Easily convert your types into the corresponding enum variant
-
ndless-static-vars
storing static, program-wide parameters for Ndless
-
rudi-core
Rudi core types
-
cmp_macro
This macro allows you to write a summary comparison, just like in Python
-
manifest-dir-macros
function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
test-macro
macro for writing Rust test code in an easy way
-
apply_pub
syntax extension for applying the
pub
visibility modifer to many items at once -
enum_str
Creates a unitary enum and conversions from enum variants to string and vice versa
-
init-token
one-time safe initialization of static, without overhead
-
tokio-stream-extra
stream extensions
-
type-vec
A type-safe vector with type-level length
-
sgr-const
A convenience macro to generate string sequences for colored and stylized terminal output
-
power-assert
Power Assert in Rust. Provides better assertion message.
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
if-none
Early break/continue/return if an optional expression evaluates to
None
-
delegatemethod
Delegate method calls to a field
-
async_t
zero-cost async-traits
-
ref-map
Helper trait for Option and Result to map references
-
iter2
Iterator
chain
ing,cmp
ing and more as free functions taking twoIntoIterator
s -
float-lerp
Lerp and InverseLerp functions for floats
-
mononym
Type-level named values with partial dependent type support in Rust
-
builder_macro
A macro to generate structs and a corresponding builder
-
collections-fromstr
Derives FromStr for collection types like Vec<T> or HashSet<T>
-
read-primitives
traits to read primitive types from any type that implements std::io::Read
-
rbuwu
rust macros but in uwu
-
crab-errors-rs
handle errors in rust
-
rxs
Reactive extensions library for Rust with Object-safe traits
-
kizuna
service locator
-
variadic_monoids
Construct variadic functions using monoids
-
backtracer_core
acquire a stack trace (backtrace) at runtime in a no-std Rust program
-
autorand
Automatic random generation for any struct or enum. Make your fuzzing easier!
-
async-retry
Async Retry
-
validated_newtype
newtypes with checked predicates (primarily for serde)
-
anysafe
any safe
-
nom-fields
single function-like macro that removes some boilerplate from a common pattern when using nom
-
cow_arc
CowArc can be useful for decreasing memory allocations by sharing immutable memory
-
const-assert
Assert struct for const generics
-
into-a-byte
Build a byte from tuple of Into<u8>
-
typebitset
Type-level bitset implementation
-
verifier
Macros that provide common software verifier primitives
-
labelled-enum
Converting an enum to/from String
-
match_all
match_all! macro for matching multiple patterns
-
buffer
Safe, write-only, generics-free buffer abstraction
-
typesum
Utilties for enums, targeted at sum types
-
lazy_cat
Lazy concatenation of strings and other things in Rust
-
slingshot
Abstraction for async runtime that works with std types
-
tinytest
Write more compact unit tests with a small macro
-
pyo3io-macros
I/O utilities bindings for PyO3
-
nuhound
Improve error handling capability
-
iter_columns
Iterate over columns easily
-
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
rand
crate. -
apply_method
Allows you to apply any function given as a parameter to the object
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
multizip
Zip 3, 4, 5 or more Rust iterators
-
c-closures-build
Generates C/C++ FFI compatible
*Closure
structures from rust closures, useful for cross language functional programming -
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
nonminmax
Primitives types which cannot be their minimum/maximum value
-
currying
anything implementing FnOnce. Arguments can be passed one at a time, yielding a new something implementing FnOnce (and possibly FnMut and Fn) which can be called with one less argument.
-
into_inner_drop
A helper library for implementing into_inner method for drop types safely
-
srce
Self-Ref Cell Environments
-
validated-slice
Helper macros to implement std traits for custom validated slice types
-
vg_errortools
Helpers for better error legibility in std/tokio io errors and error handling in main functions
-
comparator
A Java-like Comparator type
-
match_to_str
match pattern to str
-
relevant
A small utility type to emulate must-use types
-
jabba
Async dependency injection framework
-
uninit-tools
that allows working with uninitialized memory entirely in safe code
-
vet
Arbitrary type validation
-
sod-log
Service Oriented Design - Log Integrations
-
string_mac
A lazy man's String macro
-
ffi_reflect_csharp
C# code generator for the
ffi_reflect
package -
rvs-parser
Parser for Rvs - A library for defining and evaluating random variables using a simple DSL
-
num_alias
macros to declare 'type checked' aliases for integers and floats
-
free_function_pipes
a bunch of traits that makes composing functions together easier
-
map_for
macro that implements for comprehensions similar to Scala's
-
rev_slice
A newtype for operating on a reversed view of a slice
-
iterware
middleware for iterators
-
a1_notation
A package for converting to and from A1 spreadsheet notation
-
type_name_value
A package for assigning type names to values
-
optargs
Easily create macros for functions with optional arguments
-
ogma-libs
Ogma DSL builder libs
-
rusty-value
Create a generic inspectable value from any rust type
-
typify-impl
typify backend implementation
-
dynamic
A dyanmically typed value with fast downcasting
-
bruh_moment
Re-export of the anyhow crate, but with Bruh as the error type
-
existential
quantification over lifetimes
-
mint
Math interoperability standard types
-
literal
Literals for Rust's collections
-
icee-container-rs
Container service for custom DI
-
pass_by_catastrophe
Please do not use this
-
num_bound
Add bounds fn to anything implementing
Ord
that bounds a number to a range -
hermes_ru
A very convenient string parsing crate that can parse function and variable references in strings into corresponding values
-
pipe-chain
Combinators & parser library
-
zkp-criterion-utils
Criterion helpers to benchmark over size and number of processors
-
cio-api
Helper functions and types for doing the activities of a CIO
-
iterr
Combinators for dealing with iterators of
Result
s -
raw_pointer
Safely handling raw mutable pointers to a generic type
-
typechain
Create chains of trait objects
-
io-arc
Proof of concept Arc with IO trait delegation
-
impl-enum
Macros that make using enums like trait objects more convenient
-
dangerous_option
DangerousOption - a type similar to ! in Swift language. It's basically an Option which panics if dereferenced while containing None. no_std compatible.
-
assert_into
For when writing .try_into().unwrap() feels too long
-
borked
convienient error handling library for rust
-
dynamic-cast
The fifth pillar of OOP: dynamic casting
-
upa
Macro that removes the hassle of creating long pointer chains
-
substr
Handle substrings as ranges without lifetimes
-
dot-generator
the set of macros to generate dot files
-
UpdateFunctions
A small package for calling a function at a desired interval
-
lit-vek
iter! and vek! macros for nicer literal syntax
-
thunk_simple
alternative to the
thunk
crate’s lazy evaluation types -
alias-ptr
(Mostly) safe manually-freed shared pointers in Rust
-
makeit
Compile-time checked Builder pattern
derive
macro with zero-memory overhead -
asserts-rs
Asserts utilliy macros for Rust
-
composing
Tools to compose functions
-
rwtypes
Adds methods to read/write binary numbers to the Read and Write traits
-
stacking-iterator
Iterator utilities for manipulating stacks
-
rewrap
Result<Result<T, E>, F>
->Result<T, F>
-
sort-by-borrowed-key
Adds two convenience methods for sorting by a borrowed key
-
frunk
developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
nerror
Nanocl error types
-
portaldi-core
Core functionalities for portaldi
-
tugger-debian
Debian packaging primitives
-
enum-to-types
Macro for generating pseudo-enums for type-level programming
-
wrapped-list
Macro for wrapping elements of a list with an object, function, or another macro at compile time
-
fatal-error
Differentiate errors and fatal errors
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
bidirectional_enum
Automatically generates conversions between an enum type and any other type
-
bassert
A Better Assert macro This macro will print out the values of each side of an expression and also the values of function arguments
-
sid_vec
Tiny library providing id types and an id-based vector
-
ironplc-dsl
Domain-specific language objects for IEC 61131 language elements
-
anyint
traits and structs for working with integers of any bit size
-
aspect-weave
An Aspect Toolkit for Rust
-
async-injector
Reactive dependency injection for Rust
-
sus
A declarative macro that wraps any input with an unsafe block
-
trait_adapters
newtype adapters for modifying interactions with traits
-
struct2map
Procedural macro library for converting between Rust structs and associative containers
-
extrust
intended as an extension of the standard library
-
cell-project
Safe interface for cell projection
-
input-stream
IO streams similar to C++'s streams
-
bswap
byte-swapping integers, pointers, and slices
-
arrays
Construct an array from an iterator
-
hcstatic-str
compact storage for short static strings
-
alternator
Tools for building effect system -like functionality by abusing async
-
enum_variant_eq
Determining that enumerations only have Variant equal
-
grit-junk-drawer
Collection of small utilities, types, traits, helpers, etc
-
radicle-std-ext
Monkey patches of std types
-
mybench
(and very primitive) benchmarking macro
-
derive
providing a minimal example of a derivable trait (via companion crate derive-derive) for testing and illustration
-
error-macro
error macro
-
propresenter
Unofficial library for interacting with ProPresenter 7
-
hkt
Simulated higher-kinded types for Rust
-
rewind
Strong exception guarentee support types
-
user_stable_vtable
A partial implementation of [RFC 2955], written in stable rust
-
generics2
macros for parsing generics (with optional where clause) in
macro_rules!
- enhanced fork of generics -
no-panics-whatsoever
Statically assert that a program written in Rust does not panic
-
ufo
unsigned floats
-
integer-atomics
allows you to compile code that needs the unstable integer atomics types (Atomic{U,I}{8,16,32,64}) with the stable compiler
-
cri-ref
Embedded-friendly equivalents of URIs
-
plugger
Plugger
-
iter_from_closure
Iterator<Item = Item> from FnMut() -> Option<Item>
-
multiref
Multireferences: a safe way to do [&T] -> &[T]
-
snaptest
Dead simple snapshot testing
-
once-cell-regex
just gives you the
regex
macro from theonce_cell
docs! -
simple-string-builder
Super basic string builder based on my memory of Javas
-
ref-portals
Safely use (stack) references outside their original scope
-
sssstd
🐍 - A better analogy for resizeable arrays
-
smart-pointer
Traits for smart pointer functionality
-
nclosure
composable, nameable closure types with separated states and functionality for use in APIs where anonymous types are unavailable
-
xpr
A general purpose generic expression template library
-
opera
Marker types that are easy to understand
-
parity-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…
-
join-lazy-fmt
Lazy
separator.join(iterable)
method andlazy_format!
for Rust -
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
TypeHash
trait is implemented… -
debug-map-sorted
Sorted Debug impl for HashMap
-
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
-
asserter
New assertion library for rust
-
multi-structs
Macro for generating a merged struct from multiple sub-structs
-
static-cow
Cow
at the type level: a framework of traits for writing types that are generic over ownership of their contents -
enum-tags-traits
Traits for enum-tags crate
-
enum_extract
Helper macros for extracting single enum variants of an enum
-
panicking
std::thread::panicking
analog available in theno_std
context -
with-macro
Syntactic sugar for calling methods
-
serde_newtype
Macro for generating newtypes with validity checks for use with serde
-
funki_lang
A customisable embeddable functional langauge
-
async-pipeline
Easy way to pipeline sync and async functions
-
scones
Generates simple constructors for structs
-
to_vec
convenient to_vec, to_set and to_map methods on iterators
-
disjoint-borrow
Disjoint mutable borrows of slices
-
struct-variant
Minimal helper macro to generate an enum out of a list of structs
-
offsetter
Macro for creating structs with fields at specified offsets, by automatically inserting padding
-
field-projection
Field projection experiment
-
ts_static
Wrapper macro for lazy static and a struct to aid in accessing a static in a thread safe way
-
default-test
A default trait that can be used in tests
-
arrutil
Functions for manipulating arrays from slices
-
mutslices
ability to create many mutable slices of a vector
-
constany_blank
Convert any function to constant
-
abi_stable_derive_lib
detail of abi_stable
-
rs_envflag_macros
An easy way to define flags by environment variables
-
assert_ok
A macro that asserts a Result is Ok
-
rand_macros
#[derive]
-like functionality for therand::Rand
trait -
literalext
A helper crate for interpreting proc-macro
Literal
values -
unborrow
Macro for calling a &mut self method with transient &-borrows of self in the parameters
-
qol
Quality Of Life functions and macros
-
const_type
define enum-like const-types, but with aliases for variants
-
derive-debug-extras
More customisable #[derive(Debug)]
-
funfun
Macros for working with closures
-
valibuk
set of macros implementing the correct-by-construction pattern
-
simple-builder
A procedural macro for creating a builder-pattern struct for any struct
-
very-bad-error-propagation
Using the panic system to implement error propagation (please don't actually use this)
-
is_option
Tell you if your type is an
Option<_>
-
prim_int_kind
Enumeration whose variants represent kinds of primitive integers
-
enum-tags
A Derive-Macro library that generates a companion tag-enum for any enum so that variants can be referred to without specifying fields
-
phantasm
Small lib that helps with variance
-
traitful
A collection of helper macros for trait patterns
-
accompany
with
-like macro for Rust -
set-error
A very simple trait that overwrites errors
-
persian-rug
Framework for bringing together disparate objects with inconvenient relationships
-
batbox-cmp
Traits & functions related to Ord
-
tci
Teaching C Interpreter
-
vars
variadic & functional programming via tuple
-
heredom
Tuple notations to describe XML-like trees
-
pinpoint
pinned references
-
separable
trait for enums
-
wdl-macros
Macros used within the
wdl
crate ecosystem -
constant
evaluation tools for Rust
-
resize_slice2
Resize a slice given a larger slice in safe Rust
-
generic
Higher level serialization of rust values to rust values
-
struct2vec
Rust structure to slice
-
pokeapi_types
a collection of structs used to aid in the creation of data from the PokeAPI service
-
io_err
serializable
std::io::Error
with improved ergonomics -
finte
convert between integer and Rust enum
-
lmbd
A macro that computes everything at compile time.Based on lambda calculus
-
sapp-jsutils
Helper functions for working with js objects in miniquad based apps
-
scopefunc
A trait defining kotlin-like scope functions
-
mjb_gc
Garbage collected pointers with immediate dropping
-
ortho_vec_derive
Derive orthogonal vector structure for better CPU cache usage
-
prec
A generic operator-precedence parser library
-
constmuck_internal
internal implementation detail of constmuck, all of this is unstable
-
pure_cell
Alternative to GhostCell that provides safe interior mutability via const expressions
-
collect-all
vec! for everything: easily make literals of any collection!
-
cobalt-async
collection of helpful functions for working with async Rust
-
scrapmetal
Scrap Your Rust Boilerplate
-
slice-ext
Useful extensions to slices and iterable types
-
unchecked_unwrap
Adds an unchecked version of
unwrap()
andexpect()
to Option and Result -
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
-
turbonone
macro for calling functions with Option<T> arguments
-
matches
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
pino_utils
general rust utility functions and macros
-
isnt
Inverted versions of boolean-valued stdlib functions
-
quartet
Nibble (quartet, u4) slices
-
vec_box
A single macro to create a vec of boxed elements, for trait objects
-
unwind-context
Macro to add colored panic context to your functions
-
npp
A safe rust wrapper for NVIDIA Performance Primitives (NPP) APIs
-
error_mapper
standardized Results and Errors handling accross all your projects
-
isrepr
Generating validation from arbitrary memory to repr(C) types
-
glasses
Macros for writing lots of tests (or specs!)
-
raw
unsafely manipulating raw representations in Rust
-
optarg2chain
Converts optional arguments to chaining style
-
refmove
An experimental implementation of library-level by-move references
-
graphfind-rs
finding patterns in graphs
-
fast_fmt
faster, more flexible and more correct alternative to core::fmt
-
oops
Lightweight error-handling. Provides
Option<T> -> std::io::Result<T>
. -
strong_rc
Reference counting smart pointer without weak count
-
tiny_fail
Fail type
-
credibility
A thin wrapper around assert to support table-driven tests
-
bind_match
Convenience macro similar to
matches!
but binds to variables in the pattern and returns anOption
of the result -
adante
A versatile, small options parser for use in the command line
-
fn_name
Macros that produce the name of the function they're invoked within
-
unsaef
Macros to erase scope information from tokens
-
static_leak
Leak references with static lifetimes from static Mutexes and RwLocks
-
emplacable
Return unsized values from functions
-
string-cases
String case conversion utilities
-
hax-frontend-exporter
hax frontend exporter helper crate
-
velcro_core
Core dependencies used by the
velcro
crate. Seevelcro
for documentation. It is not advised to depend on this crate directly; it is an internal dependency ofvelcro
and may be subject to breaking changes. -
take-cell-option
taking the value from a cell of a option without cloning
-
errorcon
A small crate for scoping errors and easier error conversion
-
mopa-maintained
My Own Personal Any: get your own Any with additional functionality
-
raekna-parser
code needed to parse string slices into Expressions that can later be evaluated
-
boow
Borrow Or oWned
smart pointer. Alternative to Cow. -
ctti
Compile-time type information
-
zkp-logging-allocator
Wrapper around the system allocator that logs large allocations
-
struct_update
export a macro to instantiate a struct with others which have common fields
-
unstringify
Procedural macro implemention of the reverse operation of
stringify!
-
gemstone
collection of utilities
-
not_empty
Slices and vectors that are statically guaranteed to be not empty
-
simput
input parser from stdin
-
tuple-map
map methods for tuple
-
stack-vec
Ad-hoc compile-time sized
Vec<T>
like types on the stack -
conventional-commits-types
defining conventional-commits types
-
result
Helpers for dealing with nested Result and Option types
-
variadic_closure
Support for dynamically created and called closures with variable number of arguments
-
primitive-from
trait PrimitiveFrom that is what From is to Into for num_traits::AsPrimitive
-
enum_parse
Procedural macro generating boilerplate code for parsing enum variants
-
tensor-macros
A compile time optimised tensor library
-
macro_const
A macro for creating corresponding macro definitions for constants which evaluate to the same values
-
tuple-arity
Get the arity (number of elements) of tuple types with 0-12 elements
-
dyn_safe
Take control of the Semver hazard of the
dyn
safety of your traits! -
container_literals
vec! like macros for creating maps and sets
-
easy-ffi-wrapper
Types and utilities to enable writing C FFI wrappers easily
-
bounce-iterator
Bouncing iterator for concisely mutably revisiting an array of pointers
-
strided
slices. This library provides two types
Strided
andMutStrided
as generalised forms of&[T]
and&mut [T]
respectively, where the elements are regularly spaced in memory, but not necessarily… -
soft
non-panicking assertions
-
nearly_eq
Nearly(Approximately) equal traits and assertion
-
nutype_macros
The newtype with guarantees
-
checked_array
A checked API for array types
-
distinct
Two traits for enforcing that two types either must be the same or must be different
-
bg
builder + generics
-
into_string
Helper crate to convert values into strings avoiding extra allocations
-
zisvalidator
A validator for struct and enum
-
uninit
A collection of tools for a safer usage of uninitialized memory
-
negative-type-bound
negative type bound
-
arcow
Atomically Reference-counted Copy-On-Write shared pointer
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
constduck
Compile-time ducktyping and reflection using const generics
-
assert-type-eq
Macro to assert types across potentially different crate versions are compatible
-
libsugar
syntactic sugar in the form of a library
-
boulder
Like a builder, but heavier
-
forests
Forest types and operations in Rust
-
byte_conv
conversion traits to bytes
-
fehler
error-handling syntax in Rust
-
cartesian
QOL macro that creates the cartesian product of multiple iterators
-
brev
helpers for quick and dirty scripting
-
ptr_iter
Iterators to simplify working with pointers
-
display_container
implement Display
-
iterify
Turn any type into an iterator with closures!
-
none-array
a very cursed way to create an array of None values
-
foreign-types-shared
An internal crate used by foreign-types
-
mark_last
extension to rust iterator's to mark the last element of an iterator
-
once_cell_serde
Single assignment cells and lazy values
-
array_init_macro
initialization macro for arrays
-
result-extensions
that provides extensions for the Result<T,E> type
-
kai
My personal prelude and utilities
-
object-type
struct Object - wrapper for anything type
-
libc-stdhandle
Helper functions for retrieving stdin, stdout, stderr
-
another_pipe_macro
Adds a macro for composing functions
-
clone-fields
Fields-wise types cloning
-
envload
Automatically fill structs from env variables
-
bigfactorial
Precalculated compile-time factorial macro for numbers upto 99
-
safe_cell
Safer than std::cell::UnsafeCell!
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
new_york
Home of the dollar slice
-
packer
Pack static files into your binary at compile time
-
on_demand
A macro to generate aux macros for on-demand usage
-
array_manipulation
Methods for manipuling arrays in a Vec-like fashion. It will (probably) get into core once const expressions get less experimental.
-
lang_extension
Rust Lang Extension
-
maller
that calls closures depending on the input data
-
my-desire
poc generic and injection-proof interpolation API for Rust
-
struct-pad
Padding types to enable memory layout optimizations
-
update_cell
A Cell<Option<T>> that you can update
-
async_fn
Collection of helper annotations and macros for concise and yet explicit
async fn
signatures -
hetseq
Defines traits and types to work with heterogenous sequences
-
dfdi
Dependency For Dependency Injection
-
size-trait
Traits for restricting the size of type parameters
-
blue_typemap
A TypeMap Dependency Injection method for dynamic function parameters
-
sub-array
Extract a sub-array out of an array
-
cslice
slices with a stable ABI for interfacing with C
-
arraytools
A variety of helpful methods for working with fixed-size arrays
-
captur
Macro to capture whole structs from disjoint fields in a closure
-
deluxe-core
Core traits and helpers for Deluxe procedural macro attribute parser
-
doc-type
A small Rust crate for generating documents from your types
-
wrap
Generic function wrapping
-
pure_pursuit
generic Pure Pursuit in no_std Rust
-
wraited-struct
Read and write
struct
with byte array -
dispatchtable
Small library used to specify function dispatch tables HashMap<K, Box<Fn(..)>>
-
generic_once_cell
A bring-your-own-mutex version of once_cell
-
type_at
trait to index type of Rust tuples
-
pluginator
easier creation of plugins in Rust
-
datastore
A generic store wrapper
-
curry-macro
Have fun currying using Rust's native closure syntax
-
stackbox
&own
ing references in stable Rust - no_std-friendly Box -
wrap_result
easy to wrap Ok(value) , Err(value) or Some(value)
-
arraybox
A box with fixed capacity, backed by a byte array (it can be stored on the stack too). Implements fixed capacity
ArrayBox
. -
fn_chain
Helper macro/function to create function chaining
-
into_ext
Extension trait for the “Into” trait, offering a method “.into_::<T>()” to specify the target type of conversion
-
ddmw-types
some basic DDMW types
-
imm_gc
Garbage collected pointers with immediate dropping
-
zkp-error-utils
Assertion like macros for returning
Result::Err
-
bit
helpers to manipulate bits and bit ranges
-
soft_assert
Non-panicking assertions
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
any-opt
macro to get the first value from a list of options
-
ldtk_deser_json
Just a 1:1 translation of LDTK project to a rust struct. Only from JSON
-
sugar
Rust syntax sugar collections
-
kaydle-primitives
Low level primitive parsers for KDL, intended as a building block for higher level parsers or deserializers
-
tooples
Array functions for tuples
-
type-nats
Type-level natural numbers in Rust
-
ownref
Provide the smart pointer type that bundles the data with its owner
-
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!
,include!
, orconcat_idents!
) -
error-type
macro for constructing unifying error types
-
rust-secure-code/mem-markers
marker traits about types layout in memory
-
ferrum-plugin
Lazily evaluated, order-independent plugins for extensible types
-
concurrent-slice
Extend slice-type types with methods for concurrent processing
-
ascii-literal
Compile time checked ASCII strings
-
nested-struct
Create nested structs using a macro
-
duration-macro
Compile-time duration parsing
-
tuple-combinator
Convenience methods for dealing with Option tuples
-
prefixopt
See Read Me. Automatically derive options from structs and enums to use with clap.
-
to_debug
An alternative to the ToString trait that uses the Debug trait
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
fix_me
A very simple macro that lets you write temporary code that WILL NOT build in release mode
-
closet
CLOSure-Enhancing Toolbox (CLOSET) provides some questionably-useful macro utilities for closures, including clone_army!, which reduces boilerplate for clone-capturing closures, and vindaloo…
-
float
Lightweight wrappers around primitive floating point types
-
memcmp
Optimized memory comparisons for integer slices. Temporary solution until rust issue 16913 is resolved.
-
fn-traits
function traits like the standard library ones, but can be used in stable Rust
-
maybe_box
Store arbitrary data in the size of a pointer, only boxing if necessary
-
byte-slice
Byte slice manipulation macros
-
common-testing
Common testing shortcuts and utilities reused across projects
-
stringly_conversions
helping to convert to/from various representations of strings
-
hex-display
Display impl for byte slices which provides a hexdump
-
same-types
Ensure that two types are the same
-
try_into_opt
A macro like try!, but turns a Result into an Option, mainly for use in a filter_map
-
kozo
syntax sugars for structs
-
serde_apply
Partially deserialize and update your struct
-
split_ext
Extension traits for splitting
-
rescue-blanket
Escape values while they are being formatted
-
from_map
that exposes the
FromMap
trait -
codegen2
generating Rust code
-
c99
C99 types for easier interop
-
static-atom
Fast parsing from a set of strings known at compile time
-
pipe_macro
A macro to pipe function calls like in functional programming languages
-
chstr
A macro to convert a character array into a string at compile time
-
boxchop
creating boxed slices
-
const_traits
const-ready version of core::convert / std::convert traits (+ const_ops)
-
auto-error-into
Macro to automatically convert the Err variant of a Result to the Ok variant
-
noticeable
lazy observables
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
rchunks
Iterator for slices similar to .chunks() but starting from the back of the slice and moving towards the front. Differs from .chunks().rev() in handling cases where the slice is not a multiple of chunk size.
-
iterext
Padding and separation extensions to iterators
-
take_ref
TakeRef, TakeSlice, and TakeString traits enable treating references/slices and values interchangeably. They can be treated as references/slices. And you can take ownership of the value…
-
arraylib
Tools for working with arrays
-
bounce-iter
Bouncing iterator for concisely mutably revisiting an array of pointers
-
chunks-exacter
Extension traits on slices to allow for const-generics chunks_exact
-
berusty
Me practicing Rust
-
authorized
struct's fields
-
codegen-rs
generating Rust code
-
wrapgen
automatically generate safe wrappers around FFI functions
-
bstringify
stringify! that yields byte string literals instead
-
match_self
Rust macro for the common "x = match x {" pattern
-
refview
Get a reference view of some fields into a struct
-
default-ext
extension methods for the
Default
trait -
once_self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
thisisplural
#[derive(Plural)] for creating frictionless new types with a Vec, HashMap, etc
-
sorted
compile time guarantees for sorted sequences
-
reuse
Traits and derive macros for efficiently reusing your stucts or enums with any lifetime requirement
-
disp_array
This adds a wrapper for arrays to give the 'Display' trait
-
asteroids
set of macros
-
derive_builder_macro
Rust macro to automatically implement the builder pattern for arbitrary structs
-
no_error
an error library for no_std
-
ranged_type
providing ranged numeric types
-
ownage
Perform a massive ownage of your variables! Clone into closure without macros
-
borrow-owned
helper for temporary object moving
-
syntastica-core
Shared types and traits used by other syntastica crates
-
generate-random
Generate random data
-
tuple-transpose
Transpose tuple of results and options to result and option of tuple
-
tuple_zip
Convert a tuple of iterators into an iterator of tuples
-
tupiter
iterating over tuples
-
doublysure
Using types to make sure that you're sure, sure, and doubly sure
-
write-only
References/slices that provide write-access, but no read-access
-
exclusive_cell
A thread-safe, non-blocking, no-std cell that can only be accessed once
-
dygpi
support for 'Dynamic Generic PlugIns', library based plugins for Rust
-
array-fu
Construct arrays using simple syntax
-
const_stringify_ints
Converts (generic) constant integers to &'static str
-
http-request-derive
Use derive to create HTTP requests
-
random-number-macro-impl
Generate random numbers quickly
-
parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
annotation-rs
Compile-time annotation parser for rust
-
derive-merge-struct
A derive macro to partially update a named struct
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
field
Statically-verified struct field names as strings
-
sfio-promise
Helper types and functions for making oo-bindgen future interfaces drop-safe
-
typed-builder-macro
Compile-time type-checked builder derive
-
constptr
NonNull without mutability
-
rawslice
Reimplementation of the slice iterators, with extra features. For example creation from raw pointers and start, end pointer accessors.
-
cbox
C pointer boxing, for when working with ffi
-
rust-bitfield
macros to generate bitfield-like struct
-
fool
Traits for interoperation of Boolean and sum types
-
const-unwrap-9dfd7e7b6ae4d549987171c9f89a823d
experiment
-
enumeraties
Static properties on enum variants
-
convertnumber
illustrate number conversion from float to integer, I was trying out
impl
andtraits
and thought it was cool to build something from it -
miette_helper
providing helper macros for miette
-
slice_n
Slices containing at least some number of elements
-
macro-map
Closure-less
Result::map_err
andOption::ok_or_else
-
out-reference
out references
-
struct-path
A helper macros to build a string that represents struct fields path at compile time (such as <field-name>.<field-name>)
-
rjdebounce
Debouncing function utility
-
dyngo
Type-safe dynamic (type-erased) generic outparams
-
scoped-callback
Register scoped functions with local references to 'static lifetime callbacks in a safe manner
-
blk_count_macro
macro for counting a number of comma-separated tokens at compile time
-
with_locals-proc_macros
TODO!
-
tuple_split
An extension for the tupleops crate which adds a trait for splitting tuples by an index
-
ternary-rs
emulating the ternary operator from C/C++ (among other languages)
-
lazy_fn
lazy_static for functions!
-
consume-iterator
Consume any iterator fully
-
const_map
Macro to define compile-time associated constant maps
-
global-ref
share references between functions through statics
-
compile-time-crc32
taking the crc32 of a string or byte literal at compile time
-
atomic
Generic Atomic<T> wrapper type
-
tuple_length
determining the length of a tuple
-
eraserhead
erase the lifetimes from types