-
bitflags
A macro to generate structures which behave like bitflags
-
thiserror
derive(Error)
-
derive_more
Adds #[derive(x)] macros for more traits
-
anyhow
Flexible concrete Error type built on std::error::Error
-
ordered-float
Wrappers for total ordering on floats
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
predicates
boolean-valued predicate functions
-
darling
A proc-macro library for reading attributes into structs when implementing custom derives
-
once_cell
Single assignment cells and lazy values
-
async-stream
Asynchronous streams using async & await notation
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive -
pin-project
safe and ergonomic pin-projection
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
bytes
Types and traits for working with bytes
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
ctor
__attribute__((constructor)) for Rust
-
snafu
An ergonomic error handling library
-
bon
Next-gen compile-time-checked builder generator, named function's arguments, and more!
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
human-panic
Panic messages for humans
-
smol_str
small-string optimized string type with O(1) clone
-
enumflags2
Enum-based bit flags
-
frunk
developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
approx
Approximate floating point equality comparisons and assertions
-
similar-asserts
assert_eq! like macros with colorized diff output
-
typed-builder
Compile-time type-checked builder derive
-
memoffset
offset_of functionality for Rust structs
-
dyn-clone
Clone trait that is dyn-compatible
-
tap
Generic extensions for tapping values in Rust
-
macro_rules_attribute
Use declarative macros in attribute or derive position
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
ouroboros
Easy, safe self-referential struct generation
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
static_assertions
Compile-time assertions to ensure that invariants are met
-
scopeguard
RAII scope guard that will run a given closure when it goes out of scope, even if the code between panics (assuming unwinding panic). Defines the macros
defer!, `defer_on_unwind… -
arrayref
Macros to take array references of slices
-
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…
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
bitfield
macros to generate bitfield-like struct
-
rustlings
Small exercises to get you used to reading and writing Rust code!
-
az
Casts and checked casts
-
nonempty
Correct by construction non-empty vector
-
beef
More compact Cow
-
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
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
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 -
backon
Make retry like a built-in feature provided by Rust
-
nutype
The newtype with guarantees
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]checks -
constcat
concat! with support for const variables and expressions
-
rustdoc-types
Types for rustdoc's json output
-
safer-ffi
Write safer FFI code in Rust without polluting it with unsafe code
-
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.
-
volatile
wrapper types for raw pointers
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
dlib
Helper macros for handling manually loading optional system libraries
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
opaque-debug
Macro for opaque Debug trait implementation
-
float-cmp
Floating point approximate comparison traits
-
extendr-api
Safe and user friendly bindings to the R programming language
-
if_chain
Macro for writing nested
if letexpressions -
assertables
assert macros for better testing, debugging, quality assurance, and runtime reliability
-
polonius-the-crab
Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust
-
educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits
-
inventory
Typed distributed plugin registration
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
orchestra
Generate an orchestra of subsystems from a single struct
-
derive-where
Deriving with custom trait bounds
-
index_vec
Newtype-style helpers for
Vecandusize -
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
async-once-cell
Async single assignment cells and lazy values
-
inlinable_string
inlinable_stringcrate provides theInlinableStringtype – an owned, grow-able UTF-8 string that stores small strings inline and avoids heap-allocation – and theStringExttrait… -
version-sync
ensuring that version numbers in README files and other files are kept in sync with the crate version
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
float-ord
A total ordering for floating-point numbers
-
lazy_format
lazily formatting values for later
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
extism-pdk
Extism Plug-in Development Kit (PDK) for Rust
-
bounded-integer
Bounded integers
-
unwinding
in Rust and for Rust
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
async-trait
Type erasure for async trait methods
-
enum-ordinalize
enables enums to not only obtain the ordinal values of their variants but also allows for the construction of enums from an ordinal value
-
aws-smithy-types-convert
Conversion of types from aws-smithy-types to other libraries
-
fallible_collections
adds fallible allocation api to std collections
-
stdext
Extensions for the Rust standard library structures
-
iter-read
A Read implementation for iterators over u8 and related types
-
writeable
A more efficient alternative to fmt::Display
-
field-offset
Safe pointer-to-member implementation
-
fragile
wrapper types for sending non-send values to other threads
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
pact_consumer
Pact-Rust module that provides support for writing consumer pact tests
-
by_address
Wrapper for comparing and hashing pointers by address
-
testresult
type for concise and precise test failures
-
konst
Const equivalents of std functions, compile-time comparison, and parsing
-
erasable
Type-erased thin pointers
-
iri-string
IRI as string types
-
buffered-reader
A super-powered Reader
-
bit_field
bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
tuples
many useful tools related to tuples
-
pyo3-polars
Expression plugins and PyO3 types for polars
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
rustler
Safe Rust wrappers for creating Erlang NIF functions
-
bounded-collections
Bounded types and their supporting traits
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
inout
Custom reference types for code generic over in-place and buffer-to-buffer modes of operation
-
terrors
ergonomic and precise error handling built atop type-level set arithmetic
-
arr_macro
Initialize arrays with ease!
-
fatality
extension to
thiserror::Error -
tynm
Returns type names in shorter form
-
virtue
A sinless derive macro helper
-
recursion
cache-aware stack safe recursion
-
easy-cast
Type conversions which are expected to succeed
-
error-code
Error code
-
retour
A cross-platform detour library written in Rust
-
myutil
Rust Util Collections
-
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… -
rustrict
profanity filter for Rust
-
const-gen
generating (relatively) complex compile-time constants in rust
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
rustversion
Conditional compilation according to rustc compiler version
-
fallible-iterator
Fallible iterator traits
-
pinned-init
facilitate safe pinned initialization
-
sptr
Strict Provenance Polyfill
-
cascade
Dart-like cascade macro for Rust
-
psm
Portable Stack Manipulation: stack manipulation and introspection routines
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
st-map
Runtime for a stack-alocated map
-
culpa
error-handling syntax in Rust
-
chalk-ir
Chalk's internal representation of types, goals, and clauses
-
dyn-clonable
Attribute wrapper for dyn-clone
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
safe-transmute
A safeguarded transmute() for Rust
-
indoc
Indented document literals
-
loupe
Profiling tool for Rust
-
try_match
Fallible pattern matching with a function-like syntax
-
shaku
Compile Time Dependency Injection for Rust
-
anymap3
A safe and convenient store for one value of each type
-
strck
Checked owned and borrowed strings
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
argp
Derive-based argument parser optimized for code size
-
nshare
Conversion between n-dimensional types in different Rust crates
-
lender
A lending-iterator trait based on higher-rank trait bounds, with full std::iter::Iterator functionality
-
lending-iterator
Fully general lending iterators in stable rust: windows_mut!
-
ra_ap_mbe
Handling of
macro_rulesmacros for rust-analyzer -
core_extensions
Extensions for core/std library types, and other miscelaneous features
-
calendrical_calculations
Calendrical calculations in Rust
-
overload
macro to simplify operator overloading
-
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…
-
shopify_function
write Shopify Functions in Rust
-
libc-print
println! and eprintln! macros on libc without stdlib
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator -
autosurgeon
working with data in automerge documents
-
formatx
A macro for formatting non literal strings at runtime
-
any_of
A general optional sum of product type which can be Neither, Left, Right or Both
-
o2o
Object to Object mapper for Rust. Derive '(Try)From' and '(Try)Into' traits.
-
inline-python
Inline Python code directly in your Rust code
-
deno_error
Error representation to JavaScript for deno
-
outref
Out reference
-
conjure-object
Runtime support for generated Conjure objects
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
oxc_index
Newtype-style helpers for
Vecandusize -
rdftk_names
set of modules that contain the
IRIs andQNamestrings for commonly used vocabularies. It also provides macro support for defining new namespaces in the same style as this library. -
log-once
Collection of helper macros for logging some events only once
-
socketpair
Cross-platform socketpair functionality
-
parsel
Zero-code parser generation by using AST node types as the grammar
-
error_set
An error set macro that simplifies error management by providing a streamlined method for defining errors and easily converting between them. Inspired by Zig's error set type.
-
maybe-owned
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
k8-client
Core Kubernetes metadata traits
-
joinery
A small crate for generically joining iterators with a separator
-
concat-with
Extend the function of the
concat!macro instd -
doc-comment
Macro to generate doc comments
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
vtable
Helper crate to generate ffi-friendly virtual tables
-
thiserror-no-std
derive(Error)
-
tor-async-utils
Async/futures helpers for use with Tor
-
capacity_builder
Builders where the code to calculate the capacity is the same as the code to write what's being built
-
fluent-comparisons
Boost readability by writing multicomparison expressions like
if any_of!({a,b,c}>=5) {...}while keeping the benefits of hand-written code -
sealed
Macro for sealing traits and structures
-
aoc-parse
A little library for parsing your Advent of Code puzzle input
-
rc-box
Known unique versions of Rc and Arc
-
elain
Set a type's minimum alignment with const generics
-
dync
An efficient alternative to
dyn Traitfor containerized types -
moveit
safe, in-place construction of Rust (and C++!) objects
-
cast_trait_object
Cast between trait objects using only safe Rust
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
lazycell
providing a lazily filled Cell struct
-
lazy_errors
Effortlessly create, group, and nest arbitrary errors, and defer error handling ergonomically
-
unleash-yggdrasil
Unleash SDK domain logic extracted into a library to facilitate building your own Unleash SDKs in anything, anywhere
-
reborrow
Emulate reborrowing for user types
-
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
macon
builder macro-based generator with its own idioms
-
hax-frontend-exporter-options
The options the
hax-frontend-exportercrate is sensible to -
ltpp-output
An atomic output library based on Rust that supports output functionalities through functions, builders, and other methods. It allows customization of text and background colors.
-
mirror-mirror
Reflection library for Rust
-
cap-std-ext
Extension APIs for cap-std
-
better_scoped_tls
scoped-tls, but with good error message
-
with_locals
Function attribute to return references to locals by using CPS
-
flex-error
Flexible error definitions using macros and traits
-
zoet
Adds
#[zoet]macro to reduce boilerplate when implementing common traits -
tryhard
Easily retry futures
-
slice_ops
A selection of useful slice operations
-
egui-probe
Trait and derive macro for exposing value editing in egui
-
miden-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
delegation
Macro-based delegation for enums and structs
-
data-rw
io buffer write reader
-
as-any
provide the AsAny trait
-
retry
retrying operations that can fail
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_partsandVec::into_raw_parts -
documented
Derive and attribute macros for accessing your type's documentation at runtime
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
vector2d
The spoon of 2D vector libraries, intended for simple game development
-
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
autofolder
Single-element folding wrapper
-
i_float
This fixed float math library provides an efficient and deterministic solution for arithmetic and geometric operations
-
statum
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
lowdash
A Lodash inspired utility library to manipulate array and object for Rust
-
xx
A collection of useful Rust macros and small functions
-
assert_approx_eq
assert approximately equal
-
peeking_take_while
Like
Iterator::take_while, but calls the predicate on a peeked value. This allows you to useIterator::by_refandIterator::take_whiletogether, and still get the first value… -
devise
devising derives and other procedural macros
-
random-number
Generate random numbers quickly
-
open-enum
An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
advent-of-code
Solutions to Advent of Code
-
buildstructor
Macro to derive a builder from a constructor function
-
fn_vm
A lightweight frame based virtual machine, meant as the base for rigz_vm
-
munge
Macro for custom destructuring
-
copyless
Ways to eliminate memcpy calls when using the standard library
-
tuplex
Rust tuple extension
-
validify
struct validation and modification functionality through the use of derive macros
-
exhaust
Trait and derive macro for working with all possible values of a type (exhaustive enumeration)
-
thiserror-core
derive(Error)
-
soa-rs
A Vec-like structure-of-arrays container
-
sqlx-paginated
A flexible, type-safe SQLx query builder for dynamic web APIs, offering seamless pagination, searching, filtering, and sorting
-
funty
Trait generalization over the primitive types
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
condtype
Choose types at compile-time via boolean constants
-
void
The uninhabited void type for use in statically impossible cases
-
crevice_notan
Create GLSL-compatible versions of structs with explicitly-initialized padding
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
rust_info
Extracts the current rust compiler information
-
andex
Safe, strongly typed array indexes and wrappers for rust with zero dependencies
-
dispose
wrapper for values that must be consumed on drop
-
resiter
Helper crate for handling iterators over result
-
qualifier_attr
Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items
-
beekeeper
A full-featured worker pool library for parallelizing tasks
-
entrait
Loosely coupled Rust application design made easy
-
fixed-hash
Macros to define custom fixed-size hash types
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
bool_ext
defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
scale-typegen
Type Generation for SCALE encoded Rust Types
-
TSPL
The Simplest Parser Library
-
sugars
An useful collection of macros to make tasks easier
-
wiwi
Stuff™
-
fallible-streaming-iterator
Fallible streaming iteration
-
aerosol
dependency injection for Rust
-
const-field-offset
Wrapper around field-offset crate and const-field-offset-macro
-
jnix
High-level extensions to help with the usage of JNI in Rust code
-
moddef
Macro for convenient module declaration. Each module can be put in a group, and visibility can be applied to the whole group with ease.
-
yffi
Bindings for the Yrs native C foreign function interface
-
octseq
Abstractions for types representing octet sequences
-
psl-types
Common types for the public suffix implementation crates
-
metastruct
Abstractions for iterating and mapping over struct fields
-
proc-bitfield
expressively declare bitfield-like structs
-
conflate
Merge multiple values into one
-
const-default
A const Default trait
-
macro-asm-builder
macro-assemblers
-
smarterr
Smart error handling library
-
semval
Semantic validation
-
leptos-mview
A concise view macro for Leptos
-
iterate-trait
Experiment with methods on IntoIterator
-
dupe
Marker for types which are cheap to clone
-
hermit-sync
Synchronization primitives for kernels
-
sosecrets-rs
Secretwrapper type that reveals the secret at mostMEC: typenum::Unsignedtimes with compile time guarantees -
shape
A decidable static shape system for JSON-like data
-
refined_type
imbuing rules into types and elevating them to more robust types
-
doku
A framework for documenting Rust data structures
-
cumulus-primitives-aura
Core primitives for Aura in Cumulus
-
blanket
macro to derive blanket implementations for your traits
-
radiation
Convert Rust type into raw bytes and vice versa
-
devela
A cohesive development layer
-
display-error-chain
Formats a standard error and its sources
-
ungrammar
A DSL for describing concrete syntax trees
-
dynamic-provider
Dynamically request arbitrarily-typed values from providers with borrowed data
-
vitasdk-sys
Raw bindings to vitasdk
-
wartcl
A minimal embeddable Tcl-like language
-
tinyvec_macros
Some macros for tiny containers
-
cbor-data
using CBOR as in-memory representation for working with dynamically shaped data
-
event-driven-library
Event Driven Message Handling
-
direction
Representations of directions
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
fauxgen
write your own generators in stable rust
-
byondapi
Idiomatic Rust bindings for BYONDAPI
-
awint_macro_internals
Internal macro utilities for the
awintsystem of crates -
windows-targets
Import libs for Windows
-
cl-format
Use Common Lisp format in Rust
-
uniplate
boilerplate-free operations on tree-shaped data types
-
pilgrimage
A Kafka-like message broker in Rust
-
auto_enums
allow multiple return types by automatically generated enum
-
cexpr
A C expression parser and evaluator
-
suika_templates
template engine for the suika web stack
-
nunny
the definitive non-empty slice/array/vec library for Rust
-
enum-assoc
Procedural macro to associate constants with enum variants
-
capnp_conv
capnp write/read traits to convert from structs to readers/builders
-
rudi
out-of-the-box dependency injection framework for Rust
-
globals
Painless global variables in Rust
-
retry-error
An error type for an operation that can fail more than once
-
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
model-mapper
Derive macro to map between different types
-
pandora-interpreter
A command-line tool to run pandora language
-
dylint_linting
writing Dylint libraries
-
tstr
Type-level strings
-
human-errors
An error library focused on providing your users with relevant advice for any problem
-
tracerr
Custom compile-time captured error tracing
-
downcast
Trait for downcasting trait objects back to their original types
-
fmt-cmp
Traits and utilities for lexicographically comparing values in their
Displayrepresentations -
text-block-macros
Create a multiline string literal
-
next_tuple
A trait to build and extend tuples
-
anybytes
A small library abstracting over bytes owning types in an extensible way
-
checked-rs
encoding validation semantics into the type system
-
enum-display
A macro to derive Display for enums
-
static-keys
Reimplement Linux kernel static keys for Rust userland applications
-
rust-witness
Build a circom witness in Rust
-
allow
Alias/label lints (to disable) with your intentions. Reexported from allow_prefixed, grouped under rustc::, clippy:: and rustdoc:: modules.
-
swipl
A high-level library for building SWI-Prolog extensions and embedding SWI-Prolog in rust applications
-
more-di
support for dependency injection (DI)
-
collate
Traits and a data structure to support collation and bisection
-
heart
Hypermedia-based web development of the 1990 future!
-
sod-actix-web
Service Oriented Design - Actix Web
-
components-arena
creating complex domain-specific self-referential data structures
-
wmlua
-
strong-type
Procedural macros for naming and strong-typing pritimives and strings
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
expect-exit
Result.expected(): display an error message and exit without a panic
-
nar_dev_utils
用于NARS相关项目开发的实用工具包
-
oxrdf
providing basic data structures related to RDF
-
unsafe-fields
unsafe to access or modify fields with safety invariants
-
scaffolding-core
A software development kit that provides the scaffolding for building applications and services using OOP
-
heterob
conversion between bytes/bits and heterogeneous lists (tuples)
-
lazy-static-include
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
enum-ptr
Ergonomic tagged pointer
-
auto_ops
Macros for easy operator overloading
-
htmf
hypertext markup functions: functions for generating HTML
-
functor_derive
A derive macro to derive a functor for a type
-
one_err
OneErr to rule them all
-
nenyr
initial version of the Nenyr parser delivers robust foundational capabilities for interpreting Nenyr syntax. It intelligently processes central, layout, and module contexts, handling complex variable…
-
unzip_iter
Unzip an iterator to iterators
-
script-format
DSL to format data via rhai scripting
-
quoth
scannerless (no-lexing), developer-friendly parsing library for implementing DSLs and syntax parsers in Rust
-
bilge
Use bitsized types as if they were a feature of rust
-
defer
excecution of code, inspired by go's defer statement
-
btypes
Better types (BTypes) for when you dislike normal types, I guess
-
fomat-macros
Alternative syntax for print/write/format-like macros with a small templating language
-
orx-closure
An explicit closure with absolute seperation of the captured data from the function
-
io-streams
Unbuffered and unlocked I/O streams
-
clsx
A flexible class name composition utility for Rust, inspired by clsx and tailwind-merge
-
crustal
generating C/C++ code
-
is_empty
Easily check if the struct is empty
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
derive_destructure2
Destructure structs that implement Drop
-
aad
Automatic adjoint differentiation library
-
partial_function
A clean way to define function as a set of subfunctions where each has defined start and end bounds
-
redb_model
Redb model derive macro and DTO type conversion
-
zngur
A Rust/C++ interoperability tool
-
databend_educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits, temporarily used in databend
-
untrusted_value
aim to provide a type-safe way to handle and sanitize potentially untrusted values like user input
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
ext-trait
Annotation to easily define ad-hoc / one-shot extension traits
-
proc-easy
Macros to make writing proc-macro crates easy
-
rxml_validation
Plumbing crate for rxml and rxml_proc crates
-
logkit
Super fast, structured, scalable logging library for Rust
-
fixnum
Fixed-point numbers with explicit rounding
-
numtest
Unit testing for numerical methods
-
fp_rust
Implement fp features for Rust
-
ref_wrapper
Wrapper of dynamically borrowed data
-
show-option
displaying Options
-
autofloat
Pure Rust library for efficient automatic differentiation
-
self-rust-tokenize
Turns instances of Rust structures into a token stream that creates the instance
-
mownstr
Maybe Owned String
-
context_manager
Python's like context_managers in Rust
-
copy_from_str
An extension trait to copy a string into another string
-
oxc-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
strprintf
Provide a way to interpolate printf-style format strings using native Rust types. Part of libnewsboat lib dependencies
-
nameof
macro to determine the string name of a binding, type, const, or function
-
yerevan
Small Rust crate that brings computation expressions idea from F# for help you to work easier with functors and monads
-
tokenlock
cell types that decouple permissions from data
-
kinded
Generate enums with same variants, but without data
-
cove
Casts Of Varying Elegance (COVE): extension traits for casting numerical types
-
endian-writer
[no_std] Methods for efficient reading and writing of structures to raw pointers in a stream-like fashion
-
familiar
reserve
-
service-builder
A lightweight, type-safe service construction library for Rust that provides compile-time dependency injection through builder pattern
-
tighterror
A minimalistic error representation framework
-
rancor
Scalable and efficient error handling without type composition
-
a1
A package for converting to and from A1 spreadsheet notation
-
dogma
Dogma.rs
-
structz
Anonymous struct implementation in rust
-
dprint-swc-ext
Functionality to make swc easier to work with
-
alternating-iter
Provide an iterator adaptor which alternate between two iterators
-
borrowme
The missing compound borrowing for Rust
-
elicit
SmartPointer-like structure for polymorphism
-
funcmap
Derivable functorial mappings for Rust
-
small_len
A small library for storing the length in the smallest internal type
-
indices
macros and methods for safely retrieving multiple mutable elements from a mutable slice, addressing scenarios where slice elements would typically require
RefCellorCell(interior mutability approach) -
linear_type
Linear types for rust
-
dyn-context
mechanism for lifetimes erasing
-
teleparse
-
wintypes
that exports windows functions as types
-
ownable
Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more
-
trybuild-internals-api
A fork of trybuild with the internals exposed as a public API
-
ctrlgen
Generate enums for message-passing services
-
tardar
Extensions for diagnostic error handling with
miette -
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
nu-std
The standard library of Nushell
-
trait-cast
Get your own Any with support for casting to trait objects
-
merge
multiple values into one
-
pusherator
Push-based version of Rust iterators
-
cortex-ai
An asynchronous flow-based processing framework for building flexible data pipelines with conditional branching and error handling
-
ghost
Define your own PhantomData
-
cooked-waker
A safe interface for creating async Wakers
-
panicmsg
simplyifying common panic messages
-
drcp-format
Parse and write DRCP and literal definition files
-
deptypes
Dependent types
-
one_two_eight
typed 128-bit identifiers
-
columnation
Unsafe columnar containers for native Rust types
-
option_trait
Helper traits for more generalized options
-
yield-return
Implement a coroutine like C#‘s
yield returnusing Rust’sasync,await -
fmt-interspersed
write an iterator's items, interspersed with a separator, to a destination
-
dynamodel
derive macro to implement conversions between your object and
HashMap<String, AttributeValue> -
drop_bomb
A runtime guard for implementing linear types
-
hex_lit
Hex macro literals without use of hex macros
-
stupid_utils
that provides some simple and maybe stupid or useful tools
-
binf
that adds utilities for dealing with binary flags
-
ffi_helpers
help make working with FFI easier
-
hax-bounded-integers
Newtypes for working with bounded integers with hax
-
backtrace-error
wrap errors with automatic backtrace capture and print-on-result-unwrap
-
dialogue-macro
An extension to dialoguer that simplifies command-line interaction interfaces
-
ice_code
A macro to mark code paths as cold, allowing the common case to be inlined
-
essential-vm
The Essential VM
-
result-like
Option/Result-like monad interface for your own enum
-
ergokv
Easily store and retrieve data from TiKV with a derive
-
safe_math
Math without overflow, creates an enum and a macro to help mitigate any overflow while multiplying and adding
-
implementation
The implementation crate
-
tisel
Effective type-based pseudodynamic dispatch to impls, enums and typeid
-
mapper
Mapping macro to help to reduce mapping boilerplate
-
wrap-match
A procedural macro to wrap a function in match statement to make error logging super easy
-
any-fn
Dynamically-typed functions to represent any functions in Rust
-
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)
-
bool_vec
A crates that exposes a vector called BoolVec which allows you to store a boolean in a single bit
-
derive-ctor
Adds
#[derive(ctor)]which allows for the auto-generation of struct, enum, and union constructors -
enum_cycling
Small macro for working with enums
-
ra_ap_hir_expand
Macro expansion for rust-analyzer
-
sitrep
Frontend-agnostic progress reporting
-
xdi
Rust di containers system
-
inline-c
Write and execute C code inside Rust
-
hlist2
Compile-time heterogeneous list implementation
-
pretty-error-debug
If the process ends with an
Error, write out theErrormessage and chain -
nonany
Integer types with customizable niche values
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
evcxr_repl
A REPL for Rust
-
conv2
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
mago-typing
basic type inference for PHP code, deducing variable and return types to assist in static analysis and automated tooling
-
derive_generic_visitor
Boilerplate for building rust visitors
-
aquamarine-demo-crate
A demo crate for aquamarine -- the mermaid.js integration for rustdoc
-
intern-arc
An interner that deallocates unused values
-
opentalk-kustos-prefix
Derive macro for defining kustos prefix
-
ask_nicely
A rest client helper library
-
traitsequence
Traits to abstract over sequences
-
swift-bridge-build
Parse Rust files for swift-bridge modules and generate the corresponding Swift and C code for them
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
cast
Ergonomic, checked cast functions for primitive types
-
case_insensitive_string
A case insensitive string struct
-
dyn-hash
Hash trait that is dyn-compatible
-
slice-diff-patch
providing utility functions for diff and patch of slices
-
iterstats
Statistics for rust iterators
-
salsa-macro-rules
Declarative macros for the salsa crate
-
kind
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
hzrd
Shared mutability containers based on hazard pointers
-
bellframe
Fast and idiomatic primitives for Change Ringing
-
subplotlib
functions and types for
subplot codegengenerated Rust based test suites. Relies onsubplotlib-derivefor associated macros. -
hax-lib
Hax-specific helpers for Rust programs
-
enum-update
representing state changes as enums
-
structx
Simulating anonymous struct and named arguments in Rust
-
default-constructor
Macros for creating pseudo-dsls that constructs structs through default construction and field conversion
-
simple-error
error type backed by a string
-
egui_struct
EguiStruct is a rust derive macro that creates egui UI's from arbitrary structs and enums
-
pipe-trait
possible to chain regular functions
-
fn_macro
函数宏
-
binread
helping read structs from binary data using ✨macro magic✨
-
linked_list_r4l
Linked lists that supports arbitrary removal in constant time
-
stellar-axelar-std
Standard libraries for Axelar contracts
-
string_more
Extension traits for
Stringand&strtypes -
procmeta
integration procmeta-core and procmeta-proc
-
gen_ops
Macros for operator overloading for generic types
-
impls
Determine if a type implements a logical trait expression
-
pike
A macro collection to pipe |> your functions calls, like in functional languages such as F#, Elixir and OCamel
-
static_file_util
generating and managing static files in Rust applications
-
prange2
Parse numeric ranges for indexing
-
commonware-consensus
Order opaque messages in a Byzantine environment
-
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
fn-traits
function traits like the standard library ones, but can be used in stable Rust
-
rc-borrow
Borrowed forms of Rc and Arc
-
vector-traits
Rust traits for 2D and 3D vector types
-
rs_envflag
An easy way to define flags by environment variables
-
try-specialize
Zero-cost specialization in generic context on stable Rust
-
selfie
Experimental, macro-free and allocation-free self-referential structs
-
padder
Highly efficient data and string formatting library for Rust
-
transitionable
A no_std compatible type to transition
T -> Twhere you have an&mut T -
macro-attr-2018
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
fastn-type
fastn: Full-stack Web Development Made Easy
-
vsprintf
Rust bindings to the libc vsprintf function
-
glam-traits
Traits for the vectors in glam
-
ruut-functions
parse math functions from string (1D,2D,3D,ND) and perform symbolic derivation, gradient, hessian
-
light_ranged_integers
Ranged integers for stable Rust compiler, zero-dependencies and no unsafe code
-
focusable
A trait for types that can be focused
-
reweb3-num
Arbitrary precision, fixed-size signed and unsigned integer types for ethereum, this a fork of bnum crate
-
tupletools
functions for tuples
-
sapp-jsutils
Helper functions for working with js objects in miniquad based apps
-
aargvark
Self-similar argument parsing
-
char-device
Character Device I/O
-
conv
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
penumbra-sdk-tct
The tiered commitment tree for Penumbra
-
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. -
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
merg
Merge multiple values into one
-
cgp-component
Context-generic programming core component traits
-
rp-postgrest-error
strongly typed errors for PostgREST
-
type_cell
Attach values statically to a type using static get/set methods
-
termite-dmg
Termite Data Model Generator is a crate meant to generate boiler plate code for data models
-
code-path
A code path macro
-
safecast
Traits to define safe casting between types
-
re_tuid
128-bit Time-based Unique Identifier
-
async_labjack
A pure rust, async interface to the LabJack T-series via Modbus TCP
-
iter-comprehensions
iterator comprehensions
-
thiserror-ext
Useful extension utilities for
thiserror -
native_api_1c
Main library for Native API 1C
-
rempl
creating html components directly in your source
-
error_mapper
standardized Results and Errors handling accross all your projects
-
anyrust
any rust
-
twinsies
Smart pointer providing 2-way joint ownership of an object
-
custom_derive
(Note: superseded by
macro-attr) This crate provides a macro that enables the use of custom derive attributes -
fmodel-rust
Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust
-
soapy
Structure-of-arrays derive macro
-
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
heap-array
variable length array, with its main benefit over
Vecis taking up less space -
surrealdb-extras
additional functionality for working with SurrealDB
-
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
-
dynarg
mechanism for dynamic robust argument handling
-
width_counters
Atomic counters with variable bit widths and customizable atomic ordering
-
indexed_valued_enums
Create enums resolving into values, and get their variants back through their values or their discriminant, inspired by Java
-
mod_use
pub mod xxx; use xxx::*;
-
jni-toolbox
tools to make writing JNI native functions less tiresome
-
value-box
Allows developers to pass Rust-allocated structures over ffi
-
visibility
Attribute to override the visibility of items (useful in conjunction with cfg_attr)
-
with_drop
Nostd wrapper for using a closure as a custom drop function
-
derive-alias
Alias multiple derives as one
-
probe
Static instrumentation probes
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
err_mac
no dependency macro for creating error enums with automatic
Fromimplementations -
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
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
ecksport-core
Defs for frame types, traits, topics, error codes, etc
-
ux2
Non-standard integer types like
u7,u9,u10,u63,i7,i9etc -
arrcomp
Python-style list comprehension syntax for contiguous memory Rust arrays
-
scout-parser
A web crawling programming language
-
enum_ext
procedural macro that enhances enums with additional methods and conversions
-
nade
Adding named and default arguments to Rust functions
-
abstract-impl
Create abstract implementations for traits
-
game_inventory
An inventory system independant of item data
-
take-until
A take_until extension for iterators
-
lexi-matic
A Lexer Library
-
iter-index
More flexible alternative to Iterator's enumerate() method
-
oxidd-rules-bdd
Binary decision diagrams (BDDs) for OxiDD
-
deltoid
calculate and apply deltas to structs and enums
-
oxiderr
Streamlining Error Handling in Rust
-
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
serde_table
Write structs in an easy table format
-
enumerable
helping you to enumerate all possible values of a type
-
assume
Macro for stating unsafe assumptions in Rust
-
sigmut
a state management framework designed to be used as a foundation for UI frameworks
-
surreal_devl
Contains core logic of surreal derive
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
soa_derive
Automatic Struct of Array generation
-
pgde
A macro library for consuming PostgreSQL row data into structs
-
symbol-ty
generating symbols as type-level strings
-
prescript
parsing and executing Prescript scripts
-
partially
Partial trait, and an optional macro to mirror a struct, wrapping each field in an Option
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
pyo3-error
Unified error causality chains across Rust and Python
-
cowstr
Copy-on-Write shared strings
-
compare_version
comparing semantic versioning strings and checking version compatibility
-
axum-openapi3
Facilitate the generation of OpenAPI 3.0 documentation for axum applications
-
composable
Easy composition of functional traits, functions or closures
-
exhaustive
The trait for generating all values of a type, and a property-based test macro
-
panic-analyzer
an audit tool to scan your crate or workspace searching for potential panic points in your codebase
-
cplex-rs
Binding of IBM Cplex library
-
panic-message
Get a panic message from a panic payload
-
datafusion-functions-table
Traits and types for logical plans and expressions for DataFusion query engine
-
rawpointer
Extra methods for raw pointers and
NonNull<T>. For example.post_inc()and.pre_dec()(c.f.ptr++and--ptr),offsetandaddforNonNull<T>, and the functionptrdistance. -
simple_parse
A declarative converter for Rust type to and from binary
-
humanbyte
A procedural macro for deriving human readable byte functions
-
mago-interner
A string interning library that stores and reuses identical strings efficiently, improving memory use in large codebases or tools
-
animatron
Animation state management
-
cubob
Structured output helpers for display mode
-
indicator
Abstractions for stream aggregation, we call them
Indicators -
bon-sandbox
Not a real crate! It’s just a showcase of examples used by
bon’s documentation to demonstrate the rustdoc output for code generated by builder macros. Don’t use this crate, it… -
defer-heavy
A versatile and easy to use defer statement for Rust. Similar to Go's or Zig's defer.
-
mode
A behavioral state machine library written in Rust
-
wallee
Flexible concrete Error type built on std::error::Error with caller location tracking
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
deriving_via
DerivingVia
-
jomy-ap-rustc_lexer
Automatically published version of the package
rustc_lexerin the rust-lang/rust repository from version 1.83.0 The publishing script for this crate lives at: https://github.com/rust-analyzer/rustc-auto-publish -
tf2-sku
SKU parser for Team Fortress 2 items
-
snowflaked
creating and working with snowflake ids
-
bevy_auto_plugin
Procedural macros to simplify and streamline the creation of Bevy plugins by automating the registration of types, initialization of resources, and addition of events
-
bitbag
A useful struct for dealing with bit flags
-
processmanager
manage process lifecycles, graceful shutdown and process faults
-
portaldi
An ergonomic lightweight compile-time depencency injection library
-
parameterx
flexible and type-safe parameter management system for Rust applications. This library provides multiple ways to store and retrieve typed values using a key-value structure, with support…
-
mvutils
made from commonly used functions in my projects
-
sumtype
Generate zerocost sumtype of iterators or closures
-
as-is
An abstraction over ownership
-
swamp-script-derive-tests
tests for swamp macro
-
convert_traits
Define your own conversion traits to solve the problem of converting two external types without using new types
-
borrow-or-share
Traits for either borrowing or sharing data
-
maybe-single
A singleton. Maybe.
-
forgy
Derive macro for building dependency graphs
-
transitive
derive macros for Rust
-
dyn_std
Dynamic (object-safe) version of std traits
-
openapi_type
OpenAPI type information for Rust structs and enums
-
nanokit
A collection of tiny, reusable utility methods that reduce code size and improve performance
-
unarray
working with uninitialized arrays
-
airbag
handling errors and panics using 3rd party services
-
libabort
A abort function that doesn't require the standard library
-
transient
Reimplementation of
std::any::Anywith support for non-'statictypes -
simple-logging
logger for the log facade
-
generativity
Generation of unique invariant lifetimes
-
jomy-ap-rustc_type_ir
Automatically published version of the package
rustc_type_irin the rust-lang/rust repository from version 1.83.0 The publishing script for this crate lives at: https://github.com/rust-analyzer/rustc-auto-publish -
eira
Ansi-colored error reporting output
-
nohashmap
Use HashMap syntax in Rust for non-hashable types
-
smart_task_openapi_axum
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
-
verity-memory
Personal memory library with some cool features
-
orx-self-or
Defines SoR (self-or-ref) and SoM (self-or-mut) traits that are useful in reducing code duplication and pushing forward the ownership transfer decision from the type designer to the consumer
-
shared-type
Shared type alias and several traits to simplify working with Arc<Mutex<T>>
-
not-found-error
Convert Option to Result using convenient functions
-
advancedresearch-path_iter
A cocategory enumeration library based on path semantics
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
commonware-utils
Leverage common functionality across multiple primitives
-
duplicate_macrotest
Fork of the macrotest crate specifically to test the duplicate crate
-
is-odd
Returns true if the given number is odd
-
shallowclone
Traits for working with copy-on-write types more efficiently
-
prima_bridge
implement the bridge pattern
-
coi
Dependency Injection library
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
hexchat-plugin
Lets you write HexChat plugins in Rust
-
separator
Formats numbers into strings with thousands separators for readability
-
copstr
COpy STRing module
-
rngstr
A cli tool for generating random strings of characters with customization options and a small domain specific language
-
ty_map_gen
A type projecting map generator
-
safelog
Conditionally suppress confidential information from logs
-
swift-rs-hatter-fork
Call Swift from Rust with ease!
-
corlib
A various ideas library
-
simplerror
A zero-dep macro to declaratively define error enum types and their common trait implementations
-
oco_ref
A smart pointer for storing immutable values with relatively-cheap cloning. (Like a
Cowmeets anRc!) -
iterator-sorted
Stable functions for checking iterator sorting
-
stak-native
Optimized primitives of native functions for Stak Scheme
-
type-fn
Allows for simpler coding of type-level logic, e.g. for type-number systems.
-
suitest
quality of life test suites
-
sod
Service Oriented Design
-
digitize
Traits for accessing digits of primitive integers & floats
-
patched
Macro for patch like structure
-
ex_em_ell
Provide macros for serializing and deserializing XML
-
board_game_range
A set of iterators for target ranges in a square tile based board game
-
opaque_typedef
Supports defining opaque typedefs
-
slice_map
A generic container to store a single type of data into unevenly sized slices
-
spade-ast
Helper crate for https://spade-lang.org/
-
gh-workflow-tailcall
macros for gh-workflow
-
generics
macros for parsing generics (with optional where clause) in
macro_rules! -
sodium
FRP (Functional Reactive Programming)
-
round
your floats with precision from 1 to 10
-
zerror_full
macro for implementing helpful errors
-
iter-scan
Iterator scan methods that don't suck
-
arkui-sys
Bindings to the native ArkUI API of OpenHarmony
-
sqler
way for writing SQL queries using some of Rust syntax
-
fast-concat
Fastest macro for concatenating strings
-
plain_hasher
Hasher for 32-byte keys
-
size-of-trait
determine the size of a future or trait impl at compile time
-
dowhile_rs
Do while macro for rust with labels and nesting support
-
unwind-context
Macro to add colored panic context to your functions
-
elvish
Overengineered Advent of Code framework - not quite Santa's elves
-
syllogism
allow for some specialization using stable Rust
-
fiberplane-pdk
Fiberplane Provider Development Kit
-
opentalk-types-signaling-breakout
Signaling types for the OpenTalk breakout module
-
no-break
Typesafe extraction of continuation values from unbreakable control flows
-
tagged-id
A zero-cost wrapper adding type-safety to resource identifiers
-
procc-ll
processor of tokens for rust
-
miden-thiserror
derive(Error) with no-std support
-
bignumbe-rs
Large, medium-precision numbers
-
fx-callback
A subscription based callback to inform subscribers about relevant data events within structs
-
bash-builtins
implement loadable builtins for bash
-
primitive-from-enum
macros for get primitive enum from complex
-
should
Postfix assertion library for Rust
-
more-itertools
python more-itertools
-
sbpf-asm-macros
Ergonomic macros for low-level sBPF ASM functionality
-
capture-it
Modern c++-ish capture syntax for rust
-
ubits
Bit fields and masks
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
portrait
Fills an
implwith the associated items required by the trait -
derive-insert
GetOrInserttrait for enums and its derive macro -
sparkles
Capture execution flow of your Rust application with CPU cycle precision!
-
merge2
Merge structs into single by values
-
pathbufd
PathBuf with Display + formatting macro
-
ffi-enum
Simply write and use
enums like rust native enums, freely passing through ffi -
benri
Convenient macros wrapping the standard library
-
traitreg
Create a registry of implementations of a trait
-
easy-error
error utilities
-
install-dirs
handling gnu install directories in rust
-
scratchstack-aws-principal
Principal types for AWS/AWS-like services
-
univec
A vector that can hold elements of any single type
-
nolife
open a scope and then freeze it in time for future access
-
reductor
Generic abstractions for combining and nesting reduction patterns for iterables
-
abcgen
A procedural macro to generate boilerplate code for objects implementing the 'Actor' pattern
-
sddl
parse and analyse SDDL Strings
-
htmlm
html macro with no dependencies
-
anyerror
A type of any error for transport
-
bogdan_hello_macro
adds the method hello_macro that generates a greeting based on the name of the struct
-
home-prelude
Prelude library to support home applications
-
nnn
Generate your newtypes from a single macro
-
enum_downcast
Safe downcasting for enums
-
envsubst
Variables substitution
-
nanotweaks
moved to https://crates.io/crates/spread_macros
-
declarative_enum_dispatch
Declarative macro generating boilerplate for enum dispatch
-
nz
Collection of 100% safe macros for creating non-zero integers more easily
-
precomputed-hash
intending to be a base dependency to expose a precomputed hash
-
crony
cron runner that spawns another thread to run your cron jobs
-
shadow_counted
An iterator that counts every iteration in a hidden counter, nested iterators may commit the count to parents
-
map
map!macro andmap_insert!macro, to create a HashMap collection and insert key-value pairs. Inspired by thevec!macro. -
enumcapsulate
Safe casting for newtype enums and their variants
-
cloudformatious
Extension traits for rusoto_cloudformation
-
apply
A tiny library for chaining free functions into method call chains
-
jkcenum
Rust enum library
-
parsey
parser-generator framework
-
test_help-rs
Test helpers for Rust
-
c8str
String types that are both utf-8 and null terminated
-
uints
Unsigned Integer Properties
-
numeric_cast
Safely cast between numbers
-
maelstrom-worker-child
Helper library for maelstrom-worker
-
string_capacity
Moved to capacity_builder
-
clamp_to
Clamp integer and float values to the values that fit within both the original number type and the receiving type
-
type-toppings
Opinionated extensions to standard types
-
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
-
smol_buf
small-string optimized string / buffer type with O(1) clone
-
git-ref-format
Everything you never knew you wanted for handling git ref names
-
genrc
refcounted pointer type that allows subobject pointers
-
degeneric-macros
Hides struct generics into trait associated types
-
assert-eq-float
assert_eq_float!macros that support floats -
hierr
RUST Error
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
cve-rs
Blazingly fast memory vulnerabilities, written in 100% safe Rust
-
iter-identify_first_last
A helper iterator, flagging first and last elements
-
convi
Convenient (but safe) conversion (
From-like) traits -
newstr
macros for declaring String-base new types
-
ref_iter
Dynamic borrowing iterator
-
quick-error
A macro which makes error types pleasant to write
-
pad-adapter
that provides pad adapter
-
sign-bound
Layout-optimized positive and negative integers
-
relax
Derive Partial<T>
-
tevec
provide quantitative analysis functions for vec | ndarray | polars backend
-
gravitron_macro_utils
Gravitron's Macro Utils
-
calibrator
methods for calibration of scalar and vector measurement systems
-
add_macro
more additional macros to help you write code faster!
-
ty-tag
TypeId for lifetime containing types via type tags
-
test_eq
assert_eq!-like macros that return a Result instead
-
rustdoc-prettier
Format //! and /// comments with prettier
-
restructed
Quickly derive subsets of your structs
-
variadiz
Variadic function support for rust
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
non-empty-string
type for non empty Strings, similar to NonZeroUsize and friends
-
hello-world-in-rust
Hello World!
-
niloecl
axum handler pattern for twilight interactions
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
nil
Noxmore's Ixperimental Lutilities
-
scoped_thread_local
Highly flexible Scoped thread local with HKT builtin
-
deep_safe_drop
Safe dropping of deep trees that otherwise could cause stack overflow
-
dims_macro
Macros for Generating Systems of Units
-
rt-format
Fully-runtime equivalent of the format! macro
-
async-iterator
An async version of iterator
-
clap-doc
Create markdown descriptions for
clap::Commands -
shorter-bounds
Write shorter bounds with a trait alias macro
-
tc-error
TinyChain's generic error struct
-
genmesh
A package for generating 3D meshes
-
accountable-refcell
A RefCell wrapper that provides actionable information for dynamic borrow failures
-
tacit
macro to make newtypes easier to create
-
dilib
A dependency injection library for Rust
-
flexi_func_declarative
exposes the fb! macro to create a function with a flexible signature
-
tracked
A stringly-typed Error that includes
#[track_caller]information -
ref-ops
An escape hatch for implementing
opstraits for references to newtypes -
timed
Macros to time function execution
-
nutype-enum
Helper macro to create a nutype that behaves like an enum
-
cast_checks
A procedural macro to check for invalid casts
-
nanvm-lib
NaNVM library
-
superstruct
Versioned data types with minimal boilerplate
-
impl-opaque
Macro for declaring complex struct and initializer
-
esync
This package contains some useful synchronization primitives
-
noco
no code, no problem
-
chasa
A parser combinator with
manytaking iterator, conditional branching, and method chain -
easy_node
Smart pointer for graph nodes
-
lichen
Scripting DSL (for Dialogue Graphs, et al)
-
hs-bindgen
Handy macro to generate C-FFI bindings to Rust for Haskell
-
labview-interop
Types and wrappers for interperating with LabVIEW when called as a library
-
enumeration
An extension to rust enum
-
suika_mime
handling MIME types in the suika web stack
-
vtid
generating volatile type IDs
-
wutil
A lightweight library that contains useful functions, wrappers, and macros
-
kutil-std
std utilities from Kutil
-
str_crypter
A macro library for XOR encryption and decryption of strings at compile time, meaning no cleartext strings will be in your release binary (when using the macro). The encrypted strings will be decoded at runtime.
-
cifg
A macro for defining #[cfg] if/else blocks; alternate to cfg-if
-
plectrum
An easy way to represent lookup tables in a db as rust enums
-
chainerror
Make chaining errors easy
-
ssi-di-sd-primitives
Selective Disclosure primitive for Data-Integrity suites
-
sudo_plugin
Macros to easily write custom sudo plugins
-
typestate
A proc macro DSL for typestates
-
std-next
Opinionated utilities and polyfills
-
saturating_add_assign
Convenience macro for AddAssign with saturating arithmetic
-
binmarshal
Pack and unpack structs and enums into and out of binary data streams
-
bit_roles
Granular role management based on bit flags
-
token-ref-cell
Interior mutability cell using an external token to synchronize accesses
-
trowel
Tools for writing HTML in Rust
-
terra-items
enum contatining terraria items and prefixes
-
range_checker
derive-macro crate aimed to provide declarative bounds checking and filtering for structure
-
devgen-splitter
Devgen Splitter is a Rust library that breaks down source code into contextual chunks
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
pyo3_special_method_derive
Automatically derive Python dunder methods for your Rust code
-
tentacli-traits
Traits and types for tentacli and related projects
-
quickbits
Fast bit manipulation routines for Rust's native integer types
-
rco_utils
Shared functions for "Remote Code Execution"'s (RCO's) binaries
-
namewise
Derived trivial name-wise conversions for Rust types
-
struct-metadata
Macros for attaching metadata to structs
-
oberst
A type-safe command parser and dispatcher inspired by Brigadier and written in Rust
-
nougat
(lifetime) GATs on stable Rust
-
unwrap_or
Four easy unwrap Result and Option macros that allow for any inline-scoped code for things like return, continue, and break
-
iter-progress
Calculate progress of your iterators
-
annasul_macro
annasul: macro library
-
culprit
error crate with the goal of identifying precisely where and in which context an error occurs
-
macro-bits
performing macro-based bit manipulation
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
named-tup
Create named tuples using the tup!() macro
-
vcell
Cellwith volatile read / write operations -
gazebo
A collection of well-tested utilities
-
mudra
Currencies as distinct structs
-
err-rs
Error level management
-
asm_block
Translate tokens to string for Rust inline assembly
-
enum_handler
A macro to generate a handler trait for enums variants
-
stack_box
store unsize struct on stack with static check
-
nzliteral
Macro simplifying use of NonZero literals
-
codespan_preprocessed
Beautiful diagnostic reporting for M4 (or cpp) preprocessed text files
-
accursed-unutterable-type-id
A worse version of std::any::TypeId
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
fcitx5-dbus
fcitx5 dbus interface for rust
-
ureeves-userfaultfd
Rust bindings for the Linux userfaultfd functionality
-
kernelx
𐲕
-
parenv
Environment variable parser with a clap style derive macro and elm style error reporting
-
prepeek
Peekable iterators without mutation
-
fixedstr-ext
A fork of fixedstr, which add more const functions to it
-
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.
-
shelter
ROP-based sleep obfuscation to evade memory scanners
-
io-arrays
Random-access I/O
-
fuck-backslash
replace the backslash with slash in-place in your PathBuf
-
windows-helpers
Helpers for the windows crate
-
mini-macro-magic
Export tokens to other modules and crates. Now with 100% less proc macros!
-
carboxyl
functional reactive programming
-
v8_derive
Derive macros and helpers for Rusty v8
-
marker_trait
Implement a blanket implementation for a marker trait
-
stackerror
A pragmatic error handling library for Rust that provides helpful strings for debugging, and structured data for runtime error handling
-
gerber-types
Types and code generation for Gerber files (RS-274X)
-
arc_macro
A macro wrapper around Arc::new() for convenience
-
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
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
tuple_split
An extension for the tupleops crate which adds a trait for splitting tuples
-
micro_errors
deal with errors without taking the derive macro approach
-
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)
-
panicking
std::thread::panickinganalog available in theno_stdcontext -
currying
anything implementing
FnOnce. Arguments can be passed one at a time, yielding a new something implementingFnOnce(and possiblyFnMutandFn) which can be called with one less argument. -
in
Python's input() for Rust
-
type_description
Machine-readable type descriptions
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
iced_af
The iced application framework project
-
yukon
trait for the ability to cheaply duplicate an object
-
ensc-build-rs
build.rs
-
typeables
type aliases. By SixArm.com.
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
pin-macros
primarly used to simplify the proccess of working with self-referencial structures
-
pyderive
Derive macro of Python special methods and a class attributes for PyO3
-
conerror
macro that automatically adds context to errors
-
never
A stable version of the unstable never type (!)
-
defmac
A macro to define lambda-like macros inline
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
px-wsdom-macros-decl
wsdom crate
-
error_status
Model common error context with HTTP 4xx and 5xx code
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
deno-bindgen2
An FFI bindings generator for Deno
-
ez_log
logging library for Rust
-
inherent
Make trait methods callable without the trait in scope
-
elor
Base generic implementation of an Either type
-
debug-fn
A function adapter that implements Display and Debug
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
defer-lite
A lightweight high-performance implementation of Go's defer statement
-
partial_application
partial function application via the partial! macro
-
tartan-bitfield
Define structures with accessors for particular bits or bit ranges
-
methods-enum
Two macros for easy implementation of 'state' design pattern and other dynamic polymorphism using enum instead of dyn Trait
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
intertrait
Allow for inter-trait casting
-
failed-result
A small crate for converting various failed value to result with corresponding error type
-
flatty-base
Flatty traits and primitives
-
overloaded_literals
Overloaded Literals to construct your datatypes without boilerplate and with compile-time validation
-
okapi-response-mac
A macro for creating response code based on responses structs rather than typing and implementing OkapiRocketResponseInner manually
-
lazy-init
Lazy initialization
-
steel-repl
REPL library for steel
-
copyvec
A contiguous growable array type, with a fixed, stack-alllocated capacity that implements Copy
-
python-packaging
Python packaging primitives implemented in Rust
-
fmt-derive
A more robust and versatile derive macro for Debug and Display
-
isolator
A lightweight library for isolating Rust functions
-
easy-ext
A lightweight attribute macro for easily writing extension trait pattern
-
enum-unit
Generates unit-variant enums from existing enums
-
singleton-manager
A programatical singleton manager
-
captur
Macro to capture whole structs from disjoint fields in a closure
-
tri_ton
A Macro for Handling Exceptions
-
lazyinit
Initialize a static value lazily
-
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
-
nest-guard
working with nested guard-type APIs
-
docsplay
A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc
-
carykh-macro-rust
macro for finding strings that contain self-referential numbers. Inspired by carykh. This description contains twenty-seven words, fifty-four vowels, and ninety-nine consonants.
-
func
that helps creating colsures from function pointers
-
rust-kzg-bn254-primitives
offers a set of structs, traits and functions for generating Blobs and Polynomials which are used to interact with rust-kzg-bn254-prover and rust-kzg-bn254-verifier crates
-
vector3d
3D vector type
-
snapup
Abstractions for handling snapshots with streams of subsequent updates
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
rusty-cmd
creating custom line-oriented command interpreters in Rust
-
relrc
Reference counted pointers, with relationships to other pointers
-
iter_peek_end
current element the last one of a peekable iterator ? (
is_last()andis_not_last()) -
cgp-async
Async-generic primitives to support both sync/async in context-generic programming
-
field33_rdftk_names_temporary_fork
set of modules that contain the
IRIs andQNamestrings for commonly used vocabularies. It also provides macro support for defining new namespaces in the same style as this library. -
mongo_indexed
derive macro to declaratively index mongo collections
-
tuple_list
macro-free variadic tuple metaprogramming
-
iterpipes
Compositional, pipes-style stream processing
-
verbex
Vebex is a Rust library that provides procedural macros for creating regular expressions in a verbose and readable way
-
tl_list_lib
Type-level kinded heterogeneous list for type-level programming in Rust
-
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…
-
egg_recursive
A recursive interface for egg: e-graphs good without S-expresion!
-
re_error
Helpers for handling errors
-
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
shared_singleton
trait provides singleton pattern state management with shared container
-
cstr-argument
A trait for converting function arguments to null terminated strings
-
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
-
cypat_scoring_engine
A CyberPatriots scoring engine library
-
coded
concrete error type with an
ErrorKindenum matching Google’s “canonical error codes” -
typed-sql
A strongly typed sql serialization/deserialization framework
-
isr-macros
Macros for ISR
-
kittycad-execution-plan-traits
Types for KittyCAD execution plans
-
random_variant
To be used with all variant, contains the derive macro
-
array_trait
A generic trait for any array, with item as type and length as const parameter
-
cmdstruct
A lightweight macro for implementing commands with a struct
-
gur
A undo-redo framework
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
ferrunix
A lightweight run-time dependency injection framework for Rust
-
effing-mad
The hottest algebraic effects library in Rust
-
pit-rust-externref
Portal Interface Types
-
typenum-consts
Procedural macros that take a literal integer (or the result of an evaluation of simple mathematical expressions or an environment variable whose value is a literal integer) and convert…
-
air-macros
Macros for the TNJ Assembly Intermediate Representation (AIR)
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
range-ext
Range intersection
-
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
-
cheap-clone
A trait which indicates that such type can be cloned cheaply
-
set_derive
Using Macros to Implement List comprehension Similar to Python Language
-
peggen
Generate recursive-descent & precedence climbing parsers
-
rvs
defining and evaluating random variables using a simple DSL
-
tao-of-rust
《Rust编程之道》随书源码
-
errore
error handling and tracing
-
jomy-ap-rustc_abi
Automatically published version of the package
rustc_abiin the rust-lang/rust repository from version 1.83.0 The publishing script for this crate lives at: https://github.com/rust-analyzer/rustc-auto-publish -
fu
Just an Error
-
supply-chain-trust-example-crate-000055
Flexible concrete Error type built on std::error::Error
-
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
qm-utils
functions and macros
-
bint
Bounded Integer in Rust
-
eventmill
Event sourcing and CQRS for Rust applications
-
maybe-borrow
Macros for conditionally returning borrowed data
-
lemurs-8080
An emulator for the Intel 8080 microprocessor
-
unsafe_cell_slice
A microlibrary for creating multiple mutable references to a slice
-
string_error_wrap
providing a macro for an error type wrapping a String
-
sendable
Rc and Option equivalents that facilitate sending data between threads
-
gobble
A Combinator based parser for strings that gets out of the way, and leaves your code looking like a grammer
-
zellij-tile
A small client-side library for writing Zellij plugins
-
option-ext
Extends
Optionwith additional operations -
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
-
static_assertions_next
Compile-time assertions to ensure that invariants are met
-
irox-types
Enums and structs to describe Rust's basic type system
-
valued-enums
Macros collection and specify trait for creating valued or python-like enums
-
custom-format
Custom formatting for Rust
-
macroex
An extractor based low level macro parsing crate that provides high level parsing support through derive macros
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
jdt_maybe_multiple
MaybeMultiple is a utility crate that establishes an enum to use in place of
Optionwhere the content may be singular, multiple, or None -
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
json-query
Run jq programs to extract data from json strings
-
market
Infrastructure for producers and consumers
-
numdiff
Numerical differentiation via forward-mode automatic differentiation and finite difference approximations
-
io-close
An extension trait for safely dropping I/O writers such as File and BufWriter
-
trot
Trait library
-
const-macros
Various macros for const contexts
-
cprint
Cargo-like print
-
aranya-buggy
A less panicky replacement for unreachable!() and unwrap
-
eventually
using Event Sourcing in Rust applications
-
aoko
extension library
-
docify_clone
Docify allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples
-
grouping_by
allows the user to group an iterator by various ways
-
holder
getter setter auto gen with holder trait
-
named-block
Macro implementing early-exit-from-any-block
-
proto-mapper
A Macro library for easier mapping between custom models and proto generated code
-
intfloat
Fast and simple hashable float alternative using ints
-
iter_fixed
Iterator of fixed length
-
k8s-controller
lightweight framework for writing kubernetes controllers
-
maelstrom-test
Test macros for Maelstrom
-
quick-error2
A macro which makes error types pleasant to write
-
maybe-uninit-ext
Extended maybe-uninit types
-
branch_hints
that provides likely and unlikely branch hint functions in stable Rust
-
totally-safe
that allows you to bypass Rust's safety guarantees with totally safe patterns, featuring arbitrary lifetimes, aliasing, and more!
-
rustrix
Supports macro and basic operations for matrix
-
bty
Streamlined definition and usage of branded types in Rust
-
roopert
object-oriented toolkit for Rust
-
runestr
User-perceived characters related types and data structures
-
thiserror_string_context
Adds context string to error enums generated with thiserror
-
assert_matches2
A version of the assert_matches! macro that brings variables from the pattern into scope
-
portable-io
“ A subset of Rust
std::iofunctionality supported forno-std -
combin-iterator
Some usefull facilities for combining iterators
-
the-string-macro
The missing
string!macro to constructStringvalue from string literal -
control-flow
A hack to control control-flow outside closures
-
vmprotect
Unofficial VMProtect SDK for Rust
-
entrance
A command line argument parser library which provides type assisted tools
-
thin_cstr
An experimental crate which provides a truly thin std::ffi::CStr
-
log_limit
A rate limiting logging crate
-
enum-derive-2018
macros for deriving additional functionality for enums
-
enumx
Ad-hoc enum extension
-
error-graph
Allows non-fatal errors in a tree of subfunctions to easily be collected by a caller
-
progress-streams
Progress callbacks for types which implement Read/Write
-
mac
A collection of great and ubiqutitous macros
-
lset
Data types describing linear sets
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
context-async
context handle async future timeout or cancel
-
tupl
Perform generic operations on tuples
-
ownit
Easily turn borrowed type into owned values
-
river-layout-toolkit
Write River layouts in Rust with ease
-
str-chunks
implements char-wise chunked iteration of str
-
readonly
Struct fields that are made read-only accessible to other modules
-
const_fn
A lightweight attribute for easy generation of const functions with conditional compilations
-
tuple_utils
A set of utilities to enable higher level operations over tuples
-
case_iterable
A procedural macro to iterate over enum variants, ala Swift's CaseIterable
-
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
ointer
Steal the high bits of a pointer to store an extra value
-
goof
A reusable, composable, aggregate and
no_std-friendly error library -
xmacro_lib
macro engine for producing multiple expansions
-
reax
A reactivity system for Rust that infers dependencies between functions
-
wiwiwiwiwiwiwiwiwiwi
declarative macros for wiwi, a library, of, Stuff™ (implementation detail; do not depend on this crate directly)
-
some_crate
If you just need a crate that's guaranteed(*) to do practically nothing
-
piston-float
Traits for generic floats in game development
-
autoproto
Replacement derive macros for
prost::Message, and supporting traits and types to make implementing this trait easier -
declarative_type_state
A collection of declarative macros to reduce boilerplate code when implementing type-state patterns
-
poison-guard
maintaining sane state in the presence of panics and failures
-
filterable-enum
generating filterable enums (Combining bitflags and discriminated unions)
-
reportify
error handling and reporting
-
singleton-attr
singleton procedural attribute and derive macro
-
kstring
Key String: optimized for map keys
-
ieee-apsqrt
Square root functions for IEEE floats using rustc_apfloat
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
oc-hook-macros
Some convenient macros for hooking Objective-C functions
-
as_num
Checked conversions between Rust's numeric types
-
function
A set of useful traits for your functional needs
-
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
rtml
(r)ust macros for h(tml) expansion => rtml. (r)ust type safe (css) => rcss
-
element-ptr
A macro to make accessing elements through raw pointers easier
-
smooth-operator
Procedural macro that transforms regular infix arithmetic expressions into checked arithmetic expressions
-
rw-exact-ext
Extension of std::io to read and write data types with exact amounts of bytes
-
rukt
dialect for token-based compile-time scripting
-
hxdmp
A small utility to create hexdump output from byte slices
-
dioxus-shareables
Hooks for sharing structures between components
-
thread-object
Abstraction over thread-local storage allowing dynamic creation of TLS variables
-
tany
Type-erased container with inline storage for small values
-
physical-quantity
dimension and unit system for general physical physical quantities
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
sql-table-macros
Helper macros to generate SQL table definitions
-
circomspect-parser
Support crate for the Circomspect static analyzer
-
rama-error
error types and utilities for rama
-
lmml-parser
LMML parser
-
seqgen
Sequence generation library
-
softfloat-sys
Rust bindings for Berkeley SoftFloat 3
-
algar
Algebraic structures, higher-kinded types and other category theory bad ideas
-
irox-structs
Traits for Struct Types - linearly serialized big/little endian bytes
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
kommons_macros
a set of macros with utils
-
tyfling
todo
-
loop-let
An immutable loop structure that can be used as an expression
-
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
-
rust-kzg-bn254-verifier
offers a set of functions for verifying KZG commitments and proofs in bn254, with the motivation of supporting fraud and validity proof logic in EigenDA rollup integrations
-
peeking-iter
An iterator adapter that allows infinitely-deep peeking
-
adhesion
A set of macros for design by contact in Rust. The design of this library was inspired by D's contract programming facilities.
-
unwrap-overflow-ops
arithmetic operations that always panic on overflow
-
macon_api
builder macro-based generator with its own idioms
-
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
squote
A clone of the quote crate that uses a String as its backing store
-
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
-
min-max
max! and min! macros
-
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
retrying
General-purpose retrying library for Rust with macros and functions
-
descriptive_toml_derive
Procedural derive macro for serializing a struct into a TOML template with field descriptions that is easily edited and deserialized
-
spade-ast-lowering
Helper crate for https://spade-lang.org/
-
fastn-resolved
fastn: Full-stack Web Development Made Easy
-
builder-pattern
A derivable macro for declaring a builder pattern
-
procedural-masquerade
macro_rules for making proc_macro_derive pretending to be proc_macro
-
anthill-di
Rust di containers system
-
mago-linter
A PHP linter that identifies common coding errors, style issues, and potential bugs, helping maintain high code quality
-
ptrplus
Additional funtionality for pointer types
-
sized-data
Sized data trait + macro implementation for use in Anchor framework
-
inline_dyn
A container type for storing dynamically-sized types inline
-
s-string
s!() macro for quick String::from()
-
matr
A metaprogramming library for Rust
-
gull
type generation
-
closure_example
A short description of my package
-
pooled-writer
using N threads to write to M compressed files/writers
-
ffi_time
FFI assistant for Rust time types
-
argcall
Enables enums and structs to be callable by associating functions with their variants or fields
-
typemap-meta
compile-time macro to create type-to-value maps
-
partial-borrow
Partially borrow a struct
-
nonasync
A set of utilities useful for building a non-blocking non-async APIs
-
hrbf
Hermite Radial Basis Functions with higher order derivatives
-
wrappr
A libary for some useful wrapping traits
-
gilder
Golden testing library
-
redhook
Dynamic function call interposition / hooking (LD_PRELOAD) for Rust
-
std_nightly_to_stable_3db085279c83
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
valid8
no-nonsense validation library
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
arc-interner
An interner that deallocates unused values
-
rust_kafka_like
A Kafka-like message broker in Rust
-
materially
A macro for material implication
-
messages
Runtime-agnostic actor library
-
display_full_error
Minimal display formatter for error chains
-
thiserror-context
A wrapper around thiserror, giving you the ability to add context
-
multer-derive
derive for constructign type from multer Multipart
-
hs-bindgen-traits
traits behind hs-bindgen ergonomics
-
rustc-ap-rustc_expand
Automatically published version of the package
rustc_expandin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
netherite
A tokio implementation of the Minecraft Protocol with derive macros
-
hurl_core
Hurl Core
-
prev-iter
Iterator which allows you to view the previous element
-
strdeser
A struct serializer for rust empowered with a macro
-
cfg-or-panic
Replace function bodies with
unimplemented!()when condition is not met -
deadlocker
Bringing builder pattern to defeat deadlocks
-
almost
comparing floating point numbers
-
aranya-trouble
A wrapper to implement the Error trait
-
partial_derive2
makes all the properties of a struct type an optional property
-
interpolate
form of string interpolation
-
buf-read-ext
Trait extending anything that implements BufRead with stream_until_token()
-
despatma
Design Pattern Macro like Loki
-
easy_errors
simplify and enhance error handling in Rust
-
flexible-io
Wraps values such that dyn-safe IO traits need not appear as static bounds
-
slice-utils
A collection of slice utils, like itertools
-
cfgenius
Conditional compilation with macro support in Rust
-
isclose
A collection of trait and macros for comparing approximate equality
-
rs_transducers
transducers for Rust
-
koute/nes
emulator written in Rust
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
wx-core
微信数据解析工具
-
ctor-lite
Run code at program startup or shutdown
-
refl
reflencoding which you can use to provide a proof witness that one type is equivalent (identical) to another type. You can use this to encode a subset of what GADTs allow you to in Haskell -
projecture
Easy arbitrary type projections without proc macros
-
bittorrent-primitives
collections of basic types for BitTorrent projects
-
hictor
declarative macro for __attribute__((constructor))/__attribute__((destructor))
-
plain_enum
Mimicing Java's enum::values() and EnumMap
-
bitmask
generator for enum scoped bit flags
-
flowcontrol
clarifying and simplifying control flow
-
lawn-constants
error and logging types, traits, and codes for Lawn
-
jmespath_community
JMESPath is a query and transformation language for JSON
-
fn_zip
zip trait for functions, allowing two functions to be combined before being called
-
opentalk-types-signaling-moderation
Signaling types for the OpenTalk moderation module
-
supply-chain-trust-example-crate-000046
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… -
tcp-struct
Share structs over tcp
-
thin_delegate
Auto implementation of trivial delegation to inner types
-
to_snake_case
that transforms strings to snake_case
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
objective-rust
Seamlessly bind Rust and Objective-C code
-
eeric-interpreter
A front-end abstraction layer over eeric
-
once_cell_serde
Single assignment cells and lazy values
-
num_bound
Add bounds fn to anything implementing
Ordthat bounds a number to a range -
smallnum
Compile-time size optimization for numeric primitives
-
destructure_traitobject
Unsafe helpers for working with raw trait objects. (Forked from traitobject)
-
redox-os/relibc
Mirror of https://gitlab.redox-os.org/redox-os/relibc
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
kube-core
Kube shared types, traits and client-less behavior
-
quote-data
A tokenization Library for Rust
-
stub-macro
stub!() is a better version of todo!() that can be assigned to a variable
-
timed-locks
Smart pointers to
tokio::synclocks that either panic or error after a timeout -
scientisto
A light-weight Rust implementation of the github/scientist library used for careful refactoring of critical code paths
-
pi_null
define trait is named Null. u8,u32,u64,Option...is implements Null
-
lazy_bastard
A helpfull macro because writeing a seperate Default function is too much effort
-
stackstack
A singly linked list intended to be chained along stack frames
-
dyn_partial_eq
PartialEq macros for trait objects
-
box-dyn
Macro to derive the implementation of Trait for Box<T: Trait>
-
jsona-openapi
A openapi dsl in jsona
-
thisctx
Easily create error with contexts
-
stringreader
wrapper for strings so that they can be consumed via the std::io::Read trait
-
permeable
A permission-demand trait. Decouples the permission-demander from the permission / auth provider.
-
fluent-string
Fluent versions of String mutation methods
-
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
handle_errors
just a macro to get the thiserror with colors and the error place
-
string_from
A three-letter macro for String::from
-
nipdf-cff-parser
that parses CFF files, part of nipdf library
-
str-macro
The str!() macro, similar to vec![] but for strings
-
dbus-strings
Rust native implementation of different D-Bus string types
-
dare
daring flexible data representation
-
jget
Rust tools
-
concat-string
macros for concatenating string slices into owned strings
-
chassis
Compile-time dependency injection framework
-
consclr
console text colorful
-
lerpable
a derive macro for combining ADTs
-
shvar
POSIX-compliant shell variable substitution routine
-
sdl3-main
Tools for using SDL's main and callback APIs
-
consumable
Consume the value by replacing it with the default value and returning the previous value
-
yugen
Writing rust like python
-
symbol
globally interned strings
-
cond
Rust macro to use a match-like syntax as an elegant alternative to nesting if-else statements
-
maybe-uninit
MaybeUninit for friends of backwards compatibility
-
apparat
A lightweight event-driven behavioral state machine
-
thread-scoped-ref
that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
beetle-nonzero
Combines the std
NonZerostructs into one struct -
typederror
A wrapper around anyhow that allows for a primary error type
-
standback
New standard library, old compiler
-
problem
Error handling for command line applications or prototypes
-
derive-merge-struct
A derive macro to partially update a named struct
-
rustils
Utilities for rust
-
uwuizer
Rust Macro to UwUize your text. UwU.
-
objid
Generate a random object identifier
-
const_unit_poc
Proof of Concept: Physical units through const generics
-
trig
Complete set of trigonometric and hyperbolic functions in Rust
-
pathogen
Typed references and deep mutation into Rust types
-
derive_variants
derives an additional enum from a nested enum that contains only variants and no nested fields
-
ffd
Fast Function Dispatch: Improving the performance of Rust's dynamic function calls
-
mapcomp
Python-like list comprehensions for standard containers
-
enum_index
Trait and macros for extracting Enum variant index
-
racros
Collection of rust macros
-
io-adapters
Adapters to convert between different writable APIs
-
loft
-
rusty-typesh
A flexible type pattern matching system for Rust
-
fixed-macro-types
Macro aliases used in the
fixed-macrocrate -
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
-
version
A very simple library who's job is to return the version of your crate if you're building with Cargo
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
imgref-iter
A small crate for iterating over the rows or columns of
imgrefbuffers -
supply
Provider API for arbitrary number of lifetimes
-
perhaps
Maybe monad implementation with a more intuitive name. Using Certain and Dubious instead of Just and Nothing
-
hado
Monadic do notation using a macro
-
dyn-dyn
Flexible trait object downcasting using ptr_metadata
-
posix-errors
Posix error codes and handy functions for using them
-
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!,include!, orconcat_idents!) -
coi-rocket
integration support between coi and rocket
-
docpos
Compact-document items after defining them (fn, struct, enum) + document fn parameters with rustdoc (⑂roxygen)
-
cadeau-sys
FFI bindings to Cadeau library, performance primitives and media foundation functions
-
codama-syn-helpers
Extension of syn for Codama
-
jnt
full of just neat things
-
stecs
Experimental static compiler-checked ECS library
-
oneline-eyre
A fork of
simple-eyrewhich outputs errors on a single line -
tlns-google-oauth2-traits
A bunch of traits for
tlns-google-oauth2-traits -
orfail
Error handling library for portable unrecoverable errors
-
aspect
Toolkit for Rust
-
rsor
Reusable slice of references
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
rbtag
A procedural macro to add build DateTime and git commit information at compile time
-
assert_unordered
A direct replacement for
assert_eqfor unordered collections -
cantor
A general toolkit for working with types that have a small number of values
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
hcstatic-str
compact storage for short static strings
-
tiny-ordered-float
Tiny version of OrderedFloat
-
bytelike
Common types and functions for byte size handling
-
osu-file-parser
parse an osu! beatmap file
-
imstr
Cheaply clonable and slicable immutable strings
-
supply-chain-trust-example-crate-000008
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.
-
extended-primitives
providing primitive-like types for use
-
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
dyn_struct
Construct dynamically sized types safely
-
bon-cli
Dev tool for working with the
boncrate -
error-iter
Error::sources on stable Rust
-
edsm-dumps-model
Data models for EDSM dump data
-
zonbi
Type-Erase tools for non-
'statictypes -
termal_core
contains implementation for the termal library
-
aws-lib
Helper functions and types for AWS operations
-
syn-test-suite
Test suite of the syn crate
-
squeak
providing types allowing execution of callbacks in response to values being broadcast or mutated
-
enum-rotate
Rotate and iterate your enums
-
ghost-lite
custom PhantomData types
-
error2
error handle library for Rust
-
curerr
easy error handling
-
brain_flak_macro
Brain-Flak macro
-
lurk-ipld-macro
lurk-ipld macro
-
sized-dst
Owned container for dynamically-sized types backed by inline memory
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
frayed
Unfused and unashamed iterators
-
non_structural_derive
nonstructural derives for auto traits
-
lup
A custom indexed loop macro library for Rust
-
interning
Thread-Lcoal and Global Interning Library
-
brug
enum command generation for implementation blocks
-
defer-rs
Deferred execution Rust utilities
-
tryiter
functions for Iterators of Results
-
enum_macro
Useful macro for enum
-
merge-hashmap
Merge multiple values into one
-
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
macro-utils
Some macros to make code writing more elegant and funny
-
has-some
The opposite of is_empty (and is_empty for filters)
-
kmacros_shim
Useful macros
-
fixed-type-id
Make your types have a fixed type id&stable type name with version support between different builds
-
asset-derive
asset handling derive macro for enums, and a proc-macro learning resource!
-
easy-err
An easy Error wrapper
-
num-sign
enum Sign { Positive = 1, Negative = -1 }
-
wasmer-wit-bindgen-gen-core
wit-bindgen-gen-c
-
whiskers-widgets
Dynamic UI sub-system for whiskers
-
wrapping-macro
wrapping macro
-
advance-iter
A small crate to help with "stepping through" iterators
-
fieldx_plus
Design patterns built on top of fieldx crate
-
option_into_controlflow
Option into ControlFlow conversion
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
tailsome
Blanket traits providing
.into_ok(),.into_err(), and.into_some()for happier method chaining -
dev_bestia_url_utf8
url utf8 encode/decode
-
overloadf
unlock function overloading for rust
-
flatty-portable
Flatty portable trait and primitives
-
async_fn_traits
Trait synonyms for “Fn[…]”-trait bounds returning futures
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
derive-prom-metrics
Build Prometheus metrics declaratively as structs
-
peekable-fwd-bwd
Iterator Peekable with multi-forward-peek and multi-backward-peek
-
kust
Kotlin-like APIs for Rust
-
divide_slice
methods to divide a slice into portions of same size
-
encdec-base
encdec simple encoder/decoder base types and traits
-
twitter/rustcommon-atomics
Atomic primitives unified by traits
-
cudd-sys
Bindings for CU Decision Diagram library (CUDD)
-
mogrify
macro for autogenerating a “Parse, Don’t Validate”
TryFromimplementation for structs -
cgp-error
Context-generic programming error components
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
destruct-drop
Macro for dropping the fields of a struct or enum without dropping the container
-
sod-crossbeam
Service Oriented Design - Crossbeam
-
stur
functions for working with strings
-
stream_assert
Macros to simplify testing of
Streambased APIs -
bigerror
handle big errors ¯\_(ツ)_/¯
-
tl_str_list
Type-level string (tl list of chars)
-
throwing
Create explicit errors easily with a handy macro
-
ad-hoc-iter
Ad-hoc exact size owning iterator macro and other optional utils
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
unroll_range
Repeats a block of code for each number in a specified range
-
bronzeflow
Bronze: A workflow scheduler in rust
-
cloned_trait
Cloned Trait
-
string-join
A python-like way to join items in an iterator with a separator
-
hb_error
Useful macros and traits for creating and handling errors
-
const-type-layout
Derivable const trait to view and compare the layout of a struct, union, or enum
-
yansongda-utils
rust 中一些关于我自己的常用工具
-
simplicio
Gets rid of the boilerplate in rust
-
symbolism
Unique symbols made from human readable tags
-
crdts_macro
CRDTs proc_macro
-
bidir_iter
Bidirectional iterators
-
type_reflect
Extensible runtime reflection through a Derive macro
-
structural-convert
Derive conversion traits (From, Into, TryFrom, TryInto) when fields are structurally similar in enums or structs
-
tch-tensor-like
Derive convenient methods for struct or enum of tch tensors
-
flexcell
A dynamic borrow container allowing temporary replacement of internal references
-
enum_pipeline
way to use enums to describe and execute ordered data pipelines
-
murrelet_livecode_macros
livecode macros for murrelet, a livecode framework
-
oxydized-money-macros
Companion library to oxydized-gains providing convenience macros
-
knife
An iterator that divides things evenly
-
postgres-mapper
Struct mapping for postgres
-
ebacktrace
error wrapper which captures a backtrace and can carry an optional textual description
-
fold-license
Folding licenses from multiple dirs with
cargo/Cargo.toml andyarn/package.json -
runtime-contracts
Structured, understandable runtime contracts
-
xconstants
Adds preliminary support for enum const generics
-
function_overloading
that adds function overloading
-
multi_try
Safely combine results
-
ambient-authority
Ambient Authority
-
specler
way to write specifications on values
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
diesel_derives_traits
Traits for diesel_derives_extra
-
dirk_framework
Dependency Injection for Rust
-
safe-discriminant
A minimalistic,
no_stdcompatible trait and procedural macro for extracting discriminants from enums at zero cost -
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
rustpython-literal
Common literal handling utilities mostly useful for unparse and repr
-
cisness
Runtime 'live witness' of two types being the same
-
hereditary
Procedural macros for emulating OOP Inheritance in Rust
-
lazy_link
proc macro for dynamic runtime lookup of external functions, supporting custom resolvers, caching and no_std environments
-
try_utils
The try! macro descends into an enum variant. It's more flexible than ? and unwrap(), and it works with your enum, too!
-
smartcow
a cow for smartstrings
-
qbdi-sys
QBDI library rust binding (use rust bindgen)
-
checked-float
making invariant-enforcing floating point wrappers
-
rtoolbox
functions for other crates, no backwards compatibility guarantees
-
chalk-macros
Macros for Chalk
-
diffuser-edit
Edit diffuser models without GPU and Python
-
wtflip
A language in a Rust macro... or something.
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
standalone-proc-macro2
Fork of proc-macro2 that uses rustc-ap-proc_macro so as to remove the rustc dylib dependency
-
regex-macro
A macro to generate a lazy regex expression
-
failsafe
A circuit breaker implementation
-
const_struct
macro that allows const structures to be passed as const generics
-
peak-result
trait that extends the standard Result enum to allow you to run some code in case of error or success
-
supply-chain-trust-example-crate-000053
A lightweight version of pin-project written with declarative macros
-
ip-family
IP family enum with functions to get special ips of the right family
-
illicit
An implicit thread-local environment which is indexed by type
-
word_iter
Iterator over all words in a string
-
casual
parsing user input
-
type-variance
Marker traits for subtype variance
-
filters
Build filters/predicates with the builder pattern
-
iterator_item
a generator syntax experiment
-
dbg_unreachable
Switch between unreachable! and unreachable_unchecked with a single macro
-
replace_err
Adds a
replace_errmethod toResultwhich throws away the current error and replaces it -
vm6502
A 6502 virtual machine backend
-
serde-textual
derive Display/FromStr by using serde
-
nanopre
A a zero-dependency, no-unsafe implementation of a minimal C-style text preprocessor
-
swapbytes
swapping the endianess of structures
-
tugger-snapcraft
Snapcraft packaging primitives
-
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
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
yikes-intenum
Augment integer-based enums with an unknown variant; a macro that makes you say "yikes!"
-
rust_bridge
The rust_bridge
-
oop
Object-Oriented Inheritence in Rust
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
notzero
macro for constructing
std::num::NonZero*from constants -
let_clone
Declarative macro to clone multiple values at once
-
unwrap_todo
Option::todo and Result::todo methods
-
rerast_macros
Macros for use in Rerast rules
-
delegare
delegate struct easy
-
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.
-
bounded-vector
Vec wrapper that guarantees upper and lower bounds on type level
-
err-convert-macro
Errors converting macros
-
thiserror-nostd-notrait
derive(Error)
-
printc
Print-clean macro. Like
println!but cleaner input. -
repeated
Allows you to repeat a block of code a number of times
-
rust_jsc_sys
Low-level bindings to JavaScriptCore
-
lawn-protocol
protocol types, traits, and codes for Lawn
-
adjacent-pair-iterator
An iterator over adjacent pairs in another iterator
-
liftor
Functors for Rust lifetimes
-
state-shift
Macros for implementing Type-State-Pattern on your structs and methods
-
instability-example
Example crate demonstrating instablity usage
-
string-literal-const-replace
Proc macro for compile-time find/replace on string literals
-
ez_jni
Macros and functions that make using Java in rust feel natural
-
no_std_strings
no_std version of crate fixedstr: strings of constant maximum size that can be copied and stack allocated
-
gha_main
Convenience macros for writing GitHub Actions in Rust
-
haz
A thin abstraction over polymorphic environments
-
todo_using
A super small crate only exporting a single macro to "use" parameters
-
jomy-ap-rustc_span
Automatically published version of the package
rustc_spanin the rust-lang/rust repository from version 1.83.0 The publishing script for this crate lives at: https://github.com/rust-analyzer/rustc-auto-publish -
syrette
The convenient dependency injection framework
-
temporary_enum_delegate_0_3_0
trait delegation functionality for enums and structs
-
namable_closures
types and macros to create namable closure types
-
target-cpu-fetch
Exposes a method for querying the CPU name from the current target specification JSON file
-
easy-min-max
Easy to use macros for min, max and clamp. Works with no_std
-
nofmt
nofmt::pls, a macro that does its best at preventing a code block from being mangled -
temp-stack
A data structure for contexts or similar stack structures that are allocated on the call stack, using the temp-inst crate for lifetime erasure
-
retryiter
A wrapper lib on top of rust Iterator with added retry support
-
navigator
A Macro-heavy Domain-Specific Language for console apps with menu systems
-
seasick
FFI-safe nul-terminated strings with ownership semantics
-
rnet
Easily call into Rust from C# or other .net langauges
-
drop-bin
Defer running expensive destructors until later
-
taskchampion-lib
Personal task-tracking
-
flip-flop
implements the flip-flop operator from Perl and Ruby as a Rust macro
-
iter-n
functions returning impl Iterator to return one of several distinct types
-
string-eyre
Convenience traits for dealing with errors that don't want to eyre
-
enum-unitary
Trait and macro for unitary enums
-
const-chunks
Extension trait to chunk iterators into const-length arrays
-
golangify
published at 01.04.2024 this crate brings familiar flavor for newcomers from golang
-
rspack_macros_test
rspack macros test
-
fmu_from_struct
A derive macro for automatically setting up FMU models in Rust
-
lithium
Lightweight exceptions
-
sha2-derive
exporting a derivable
Hashabletrait that works withsha2 -
uni_tmp_jni
It's temporary fork for https://crates.io/crates/jni. Don't use!
-
list_comprehension
A macro for Haskell-like list comprehensions in Rust
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
another-visitor
Lets you derive visitor pattern implementations
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
asenum
Small derive macro to safely convert the numerical value of an enum to the enum
-
aprox_eq
determining aproximate equality between floating point types and deriving this capability to structs comprised of floating point numbers and other implementers of
AproxEq -
eager
macro expansion
-
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…
-
log_err
Log error messages from Unwrap and Expect with log crate
-
have_len
container empty ? (
is_empty()andis_not_empty()) -
xkcd_unreachable
macro xkcd_unreachable!() inspired by https://xkcd.com/2200/
-
will_exit
work on program will exit
-
error-ext
Error utilities
-
supply-chain-trust-example-crate-000028
A macro for declaring lazily evaluated statics in Rust
-
eros
Context aware, ergonomic and precise error handling
-
high_mem_utils
bunch of mem safe abstractions,some involving transmute
-
iter_from_fn
Create iterator from repeatedly aplying a function that takes no parameters
-
iter_accumulate
An iterator adaptor that accumulates the elements and yields the current accumulated value for each iteration
-
btl
shell scripting in rust. Github Repo: https://github.com/znx3p0/btlsh
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
nype
Newtype helper macros for Rust
-
battler-wamprat-error
Procedural macro for custom WAMP errors
-
win9x-sync
Windows 9x compatible synchronisation primitives for Rust
-
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
error_mancer
Quickly define custom error enums for a function
-
extent
replacement for std::ops::{Range,RangeInclusive}
-
deferred-box
Defer the value set after the struct has been initialized
-
tca-rs
The Composable Architecture (TCA, for short) is a library for building applications in a consistent and understandable way, with composition, testing, and ergonomics in mind
-
structify
A procedural macro to transform functions into structs with state and execution dependencies
-
steel-gen
Code generation crates for use within steel
-
destruct
structs and enums for simpler combinator implementation
-
dtor
__attribute__((destructor)) for Rust
-
audiotags-dev-macro
macros used during the development of audiotags
-
retry-block
retry operations that may fail with configurable backoff behavior using macros over blocks of code
-
tuplemagic
manipulating tuples through various operations like mapping, filtering, nesting, and reducing
-
internship
Interned string and more
-
null-kane
currency crate with the option to add your own currency localization logic
-
redb_model_trait
Redb model trait
-
dynamic-cast
The fifth pillar of OOP: dynamic casting
-
helper
provided some useful proc macros for Rust
-
ddd-rs
Domain-Driven Design (DDD) building blocks, for Rust applications
-
qcontext
One-time initializable static state with statically-checked zero-cost interior mutability
-
lyneate
beautiful code underlining and error reporting
-
dependent_ghost
Matt Noonan's 'Ghosts of Departed Proofs'
-
tryvial
Small crate for ok-wrapping and try blocks
-
value_unit
every unit imaginable. Also contains a handy macro
-
regi
Regi
-
simple-dmenu
macro to call dmenu
-
greattraits
My own collection for traits extending standard library types
-
persian_str_rs
functions for working with Persian strings in Rust
-
iter-skak
Combines std::iter::Skip and std::iter::Take into one
-
stringlit
A macro to convert from str to String
-
impl_ops
Macros for easy operator overloading
-
backyard-nodes
Nodes representing PHP code AST
-
makepad-internal-iter
Internal iterators
-
mapper-api
Api of the
mappercrate -
laby_common
Shared code required by laby
-
opentalk-types-common-identifiers
Common identifier types for OpenTalk crates
-
humane_commands
Allows you to write more shell-like Commands
-
todo
Minuscule
TODO!macro that lets you type-check and test but prevent compiling in release mode -
maybe_path
Zero overhead static initializer for Path
-
tailwag_macro_inline
The logic for A collection of macros to support the tailwag crate
-
type-sets
Sets implemented in the rust type-system
-
slice-copy
Go style copying for slices
-
chainer
A cursed crate that allows for global call chaining with access to chained function results
-
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…
-
simple_detailed_error
Stack and specify errors explainations saying what happened, why, how, where, how to solve it and its causes
-
sod-mpsc
Service Oriented Design - Multi Producer Single Consumer
-
kmacros
Useful macros
-
zkp-macros-decl
Procedural macros
-
char_combinator
An iterator to create all combination of a given char range
-
sod-bus
Service Oriented Design - Single Producer Multi Consumer
-
livre
type-safe PDF parser
-
fallback-if
Fall back to an alternative given some predicate
-
iterator-endiate
Extension method for (exact size) iterators which yields tuple containing whether item is last in iterator
-
rustc-ap-rustc_span
Automatically published version of the package
rustc_spanin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
vebex
that provides procedural macros for creating regular expressions in a verbose and readable way
-
guest_cell
Storage space for externally-owned private data
-
veccell
variant of Vec with interior mutability
-
csharp_binder
generate C# bindings for a Rust foreign function interface (FFI)
-
fast_delegate
delegate struct easy
-
controlflow_inspect
inspect_* methods for ControlFlow
-
string-config-parser
configuration file parser for Rust
-
these
A three-way enum capturing This, That, or Both. Inspired by the Haskell package https://hackage.haskell.org/package/these
-
nanoval
A nan-tagged value for representing f64, i32, u32, booleans, null and arbitrary pointers
-
disuse
The way to notify the implementation which return value is disuse
-
better_any
Type id and Any for non static types
-
throw
Efficiently add statically-calculated stack traces to errors
-
objectionable
storage of unsized types inline inside allocated objects
-
borrow
Zero-overhead, safe implementation of partial borrows. This crate allows you to borrow selected fields from a struct and split structs into non-overlapping sets of borrowed fields.
-
ffizz-string
FFI string implementation
-
darkly
scanf-style scanner
-
loop_chain
Macro for writing nested Loop expressions
-
tupperware
Storage traits for your types
-
multi_stack_queue
Abstraction layer for a stack-allocated multi-queue with bounded length. WIP
-
cargo-manifest
Helper crate to parse and manipulate manifests -
Cargo.tomlfiles -
lucene_query_builder
A procmacro derive crate to generate lucene query builder for Rust structs :
-
tagged-pointer-as-enum
A set of structs, traits and macros to implement tagged pointers
-
any_cmp
Support dynamic type comparisons
-
spade-hir
Helper crate for https://spade-lang.org/
-
sod-tungstenite
Service Oriented Design - Tungstenite
-
srb-std
test description 02 description
-
either_n
An Either enum with N variants
-
fix-rat
A rational number type with fixed denominator
-
funkjon
One of the worst macros this world has ever been (dis)graced with
-
hazmat
A collection of helpers for working with hazardous materials in Rust crates
-
scope-functions
Kotlin-inspired scope functions for use in almost any situation
-
match_any
declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
classes
Dependency-free macro that simplifies the process of building class strings for DOM elements
-
sid_vec
Tiny library providing id types and an id-based vector
-
iter-diff
Differences between iterators
-
zoomer
Making Rust a true modern language™️ with revolutionary macros
-
value-bag-sval2
detail for value-bag
-
io-read-line-prototype
Prototype for io::read_line
-
std_io_iterators
An iterator for
STDINand a wrapper forSTDOUT. Allows easy piping, and graceful closing of application if pipe breaks -
bitty_write_macro
A drop-in
write!replacement that optimizes non-formatting writes for code size -
handlevec
Small abstraction over index-style iteration over a vector, with deletion, insertion, and other operations on the vector while iterating
-
splop
Helper functions to determine the first/last repetition of something
-
pin-init
Safe pinned-initialization in Rust
-
vnum
Create enums with a constant value associated to every variant
-
sly_static
Seamless Rust Static Initialization: Effortless and Efficient
-
prometheus-metric-storage
Derive macro to instantiate and register prometheus metrics without having to write tons of boilerplate code
-
ffizz-passby
FFI helpers for implementing pass-by-value and pass-by-pointer
-
amethyst-inspector
unity-like inspector for amethyst
-
for-loop-iterator
Iterators like traditional for loops
-
const-exhaustive
Enumerate all values of a type at compile time
-
cron_macro
cron macro
-
ratelimit_rs
The ratelimit package provides an efficient token bucket implementation
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
tcs-dhbw
Modules for a model traffic control system project at DHBW Stuttgart
-
quack
Duck typing traits
-
ever
Print the build information of your program with minimal boilerplate
-
tl_interface
Type-level interface for type-level programming in Rust
-
rombok
boilerplate generation macros like lombok
-
p2panda-stream
Stream-based methods to conveniently handle p2panda operations
-
custom-string
This macro generates string types with custom validation
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
pyadvreader
Split text file into text sequences, strings and (line) comments
-
write-to-file
Write to a file, simple helper fn and traits lib crate
-
dyncast
Downcasting made easy
-
en
The easiest numeric traits!
-
kurtbuilds_regex
Wraps the regex library to also provide macros
-
easy-envar
Enables easy retrieval and export of environment variables in
build.rs -
abi_stable_shared
detail of abi_stable
-
strpatmatch
string pattern matching
-
burrtype
A framework for exporting types to other languages
-
teo-teon
Object notation for Teo
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
fancy-default
A better
derive(Default)implementation -
shoulda
derive macro for test assertions
-
doc-search-dsl
procedural macro for creating complex regex patterns using a Domain-Specific Language (DSL)
-
onlyerror
Obsessively tiny error derive macro
-
fast-rustc-ap-rustc_lexer
Automatically published version of the package
rustc_lexerin the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
maflow
Flow macros: basically unwrap for return, continue and break
-
never-say-never
The never type (the true one!) in stable Rust
-
wrapping_macros
A macro for wrapping arithmetic
-
cryo
Extend the lifetime of a reference. Safely.
-
libipld-macro
ipld macro
-
zerror
error interface for context-aware error-reporting
-
rsyntax
-
jealousy
A wrapper arount the envy crate, providing an easily implementable trait
-
tor-basic-utils
General helpers used by Tor
-
oofs
Error handling library that generates and injects context for you
-
repr-trait
Traits to represent Rust reprs
-
dreg-core
Core functionality for Dreg
-
kusprint
A set of macros for printing objects to stdout without having to specify a template literal
-
components-arena-traits
Does not intend for direct use
-
sqlx_query
Expands to either sqlx function
queryor macroquery!call depending onsqlx_compiletime_checkshas been enabled during the build -
totally-ordered
No dependency, no-std totally ordered f32/f64
-
dyn-any
An Any trait that works for arbitrary lifetimes
-
delfi
Conveniently writing data to csv-files
-
name-it
Give a name to async fn return types
-
escher
Self-referencial structs using the async/await transformation
-
dev_bestia_string_utils
string manipulation
-
fastpeek
A different way to peek iterators
-
ld_preload_helpers
Macros to run code at load time and override C functions
-
traverse
Proof-of-concept trait for internal iterators called traversals
-
namedarg_rustc_macro
namedarg main package
-
guard-clause
Syntactic sugar for writing simple guard clauses
-
flaky_test
atttribute macro for running a flaky test multiple times
-
morphism
A structure for suspended closure composition in Rust
-
ddi
Dynamic dependency injection library for rust
-
macro_lisp
Lisp-like DSL for Rust language
-
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
node-grove-common-api
A common API for Node Grove
-
new_type
Experimental implementation of newtypes by type level logic
-
std_prelude
prelude that the rust stdlib should have always had
-
breakable-block
A shim library for a stable implementation of what is proposed in RFC 2046
-
partial-default
PartialDefault, a trait similar to Default but with fewer guarantees
-
type-handle
Regular and reference-counted type handles
-
variant_count
Derive macro for enum which adds to it the count of variants
-
steloc
compile-time DI framework for Rust
-
common_macros
common macros like
hash_map!orhash_set!(WIP) -
pluck
Extract values conveniently
-
singleton-trait
Singleton trait for types with unique values and Erased type for zero-sized ownership proofs
-
displaythis
derive(Display)
-
common_regex_rs
Set of common regex for Rust
-
quasi_iter
that contains supplementary iterator objects and methods
-
pyspark-arrow-rs
Derive macros to be used to add some helper functions to Rust structs to make them useable in Pyspark's mapInArrow
-
applying
Apply functions in method-position
-
re_types_core
The core traits and types that power Rerun's data model
-
mstr
2-word, immutable Cow<str>
-
derive_default_builder
derives a builder implementation relying on all fields implementing Default
-
first-err
Find the first Err in Iterator<Item = Result<T, E>> and allow iterating continuously
-
ftkit
A small set of utilities for newcomers learning Rust
-
as-result
Traits for converting types which may be interpreted as or into a result
-
iota-rs
macro for other Go refuges who miss const blocks and iota
-
stringedits
Edit trait and associated iterators for small edits to strings
-
vec-utils
vector utilities
-
trait-gen
Trait implementation generator macro
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
const-units
that lets you check the dimensions of your quantities at compile time and run time
-
versioned-file
adding versions and upgrade schemes to files
-
os-thread-local
OS-backed thread-local storage. This crate provides a
ThreadLocaltype as an alternative tostd::thread_local!that allows per-object thread-local storage, while providing a similar API… -
itermap
Iterator tools for maps (
HashMap,BTreeMap, etc.) -
ownedbytes
Expose data as static slice
-
fullypeek
Peek forward in an iterator as far as you'd like, memory allowing!
-
rs-std-ext
An extension for the standard library
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
except
The only one
Error -
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
gdal-bind
A binding utility for gdal-win crate
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
repository
all kinds of entities
-
asyncsync
Runtime-agnostic synchronization primitives for asynchronous Rust
-
for_each_repeat
Iterator::for_eachthat can repeat current iteration -
namedarg_hack
namedarg main package
-
tenacious
[RETIRED: Will not work with MIR] A plugin to prevent certain types from being moved
-
derive_constructors
Deriving From, TryFrom and create new_with_*args* functions
-
qwutils
some utilities
-
syn-ext
Human friendly or editable extension for syn
-
slippery-iter
Easy to use abstinential (slippery), N-peekable and rewindable wrapper over an iterator. (Nightly Rust)
-
type_enum
Create tagged unions consisting of different types
-
rust-enum-derive
(and program) for generating rust enums and associated traits from text files
-
internal
fields in Rust
-
lua-macros
Useful macros to join Lua with Rust
-
validus
A string validation library
-
data_models
used to lookup the sizes of various C-types of historical data models
-
injectables
procedural macro library that enables field injection between Rust structs through #[injectable] and #[inject_fields] attributes. The library handles visibility rules, generic type resolution…
-
simple-counter
Macro for generating thread-local static counters. Useful for basic ID generation.
-
checked_sum
safely summing up iterators
-
size
expressing, formatting, and interacting with file sizes
-
ferrite-session
Session Types DSL for Rust
-
rust_c
Write C code inline in your rust code (hacky fork of rust-cpp / cpp crate)
-
tiny-input
Tiny input macros
-
sycamore-state-core
sycamore-state core types and trait definitions
-
unsafe-any
Traits and implementations for unchecked downcasting
-
multindex
Index slices with multiple const indices/ranges
-
doxed
making Rust doc strings available at runtime
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the *relative* difference
-
shell-tools
shell tools for Rust
-
early_returns
Macros to make early returns easier to work with in Rust
-
flow-control
Declarative macros for common flow-control use cases such as break, continue, and return
-
rexpr
Rust Json Object access Runtime
-
com-scrape-types
Support code for bindings generated with com-scrape
-
leucite
A wrapper crate around rust-landlock that provides useful abstractions and utilities
-
warrant
A Swift-guard-like macro for Rust
-
derive-attribute
A set of macros to automatically deserialize standard attributes
-
raw-cstr
Keep raw-cstrings in thread local storage for reuse
-
macroquest
Write MacroQuest plugins in Rust
-
concat_strs
Macro for quickly building a String from components
-
tea-map
Map functions for tevec
-
bioneer
An Open-Source Rust Implementation of Bionic Reading
-
ordered_iter
Ordered iterators
-
fuzzypath
Quick & dirty fuzzy path comparison
-
negative
impls in stable Rust
-
tuple-traits
Additional tuple traits to enable ergonomic types
-
grid-iter
Ideomatic Grid operations via Iterators
-
iprint
debugging utility that prints indented text based on function call depth
-
libmw
constructing a pipeline of middleware functions
-
i-codegen-code
Common tools supporting the
derive-codegencrate -
switch_statement
switch statement macro
-
macaroni
The missing macro std library for Rust
-
racer-interner
thread-local string interner for racer-rust
-
linq
Language Integrated Query in Rust
-
quick_io
facilitate input and output within programs, with a set of macros
-
kvtree
Heterogenous in memory key value tree storage
-
ident-util
macro to determine the string name of a binding, type, const, or function
-
pisserror
A golden rip-off of thiserror
-
whaterror
Customizable handling for fallible main
-
herbie-lint
A rustc plugin to check for numerical instability
-
dyn-error
Error-related utilites for Rust
-
malvolio
programmatically generating HTML
-
big_mac
A metamacro toolkit for writing complex macros
-
type_utilities
Implementing more methods to rust type primitives
-
pingora-error
Error types and error handling APIs for Pingora
-
cex
Checked exception simulation
-
greedy_enum
derive macro of FromStr for enum
-
general_tools
offers many functions for many different types of operations, such as operations with strings, numbers, files, and more!
-
zip_clone
Zip an iterator to a repeately cloned object
-
bystr
macro to create compile-time, fixed length, byte array from a string
-
conventus
Traits for assembling and disassembling items
-
stuff
Stuffing things into pointers
-
frust
Functional Programming in Rust
-
thin-boxed-slice
ThinBoxedSlicestores the size of the slice before the content of the slice, so thatsize_of::<ThinBoxedSlice>is only the size of a pointer -
perthread
ThreadMap structure for accessing PerThread thread local variables form a static context
-
lateinit
Unsafe late-initialization for statics
-
wherr
Enhance Rust errors with file and line details using the
#[wherr]macro for clearer debugging -
raw_struct
procedural macro for easily declaring C-style structs that reference local or external memory, based on your memory implementation. It generates appropiate getter methods for easy access.
-
unwind_safe
Readable unwind-safe code thanks to a try-finally-looking builder pattern
-
traced_result
Proof-of-concept error tracing using the
Trytrait -
input-handle
handle input of any type
-
emplacable
Return unsized values from functions
-
pollock
An ergonomic and performant processing-like library for generative art and simple games in Rust
-
easy_switch
A macro for traditional C-style switch statements
-
aoc-util
function for aoc
-
rassert-rs
macro for expressing Result-returning assertions
-
err-per-field
A more fine-grained control over field-level error handling
-
zerocopy
makes zero-cost memory manipulation effortless. We write "unsafe" so you don't have to.
-
simple_scan
Iterator extensions for simple scan operation
-
trait_enum
Easy enum wrapper that implements all traits that the wrapped objects implement
-
prctl
This package provides safe abstraction to the linux prctl() interface. Some functions may be architecture-specific.
-
advise
User-friendly status reporting
-
ident-mash
Mash idents together inside macro_rules!
-
string-utility
substring implementation (with the RangeBound trait), keep string before or after a specified string, etc
-
fallthrough
Pattern match with fallthrough, in the style of C switch
-
to-syn-value
Defines a derive macro to implement a trait converting values to instances of syn::ToDeriveInput
-
number-bytes
trait for converting generic numeric types to and from bytes
-
hex-slice
Extends the std::fmt::*Hex traits to slices
-
find_all
A (nearly) identical alternative for
Iterator::findwhich returns anOption<Vec<usize>>containing all elements which meet a given predicate (instead of just the first) -
parameterized_test
A macro to support providing arguments to test functions
-
string-builder
string builder type
-
fat_type
A type which permits thin references to arrays and dynamic types
-
avocado-schema
A schema DSL which can be interpreted to implement multiple purposes
-
coercible_errors
Zero-cost error handling for generic traits
-
wgpu_bind_dsl
An experimental macro dsl for describing Bind layouts in wgpu-rs
-
slots-slice
manipulating slices of optional values
-
garando_pos
Backport of libsyntax_pos
-
functo_rs
Control/Data/Unrestricted monad hierarchies for Rust to be used with qualified_do
-
phantomdrop
Go-like deferring of function calls
-
try-drop
Batteries included error handling mechanisms for drops which can fail
-
crashreport
Automatic GitHub crash reporting system for any Rust crate
-
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
noders
NodeJS-like event loop environment for Rust
-
taker
Option-like taking for everyting with a default value
-
phantom_newtype
Lightweight newtypes without macros
-
input-macro
No-nonsense input!(...) macro for Rust
-
strunemix
allows to build a struct with a form of its fields, by deriving enums of them
-
tupley
Extension for primitive tuple (Hlist based on recursive structure)
-
instancebuilder
Convenient way of managing dependency injection
-
context-rs
Pass values down the async call stack, with no_std and no_alloc support
-
int-to-c-enum
TryFromInt - A convenient derive macro for converting an integer to an enum
-
fluid-macro
Write long method chains as a series of steps instead, and more!
-
detach
helper type for being able to detach/reatach a member item
-
query_interface
Dynamically query a type-erased object for any trait implementation
-
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
-
unsafe-any-ors
Traits and implementations for unchecked downcasting
-
trait-union
Stack-allocated trait objects
-
anony
Anonymous struct
-
retry-policy
Retry Policy
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
detour2
A cross-platform detour library written in Rust
-
iter-tee
Make several clones of an iterator
-
shoogah
Add some syntactic 'shoogah' to Rust
-
pack1
Byte array newtypes for different primitive types
-
constrained_type
On the fly value objects in Rust
-
function-compose
lib to allow composition of sync and async rust functions
-
ataraxy
Discord slash commands framework for Serenity
-
selfref
Semi-pain-free self-referential pinned types
-
shoggoth
Generic and type-level programming for Rust
-
arch-into
safe type conversions between pointer-sized types (usize/isize) and types with fixed size
-
type-uuid
Safe, stable IDs for Rust types
-
easyerr
easier creation and transformation of error types
-
eliza_error
“Times are bad. Children no longer obey their parents, and everyone is writing an error handling library.” — Cicero
-
ps-util
aims to provide generally helpful utility functions and traits
-
nameth
macro to generate a static &str representing the name of a function, a struct or an enum
-
transmute_guard
Transmute between types that have been marked as safe by the marker type
-
kinds
Higher-Kinded Types simulated by GATs
-
atruct
macros for anonymous structs in Rust
-
with_capacity_safe
A safer alternative to Vec::with_capacity with into_raw_parts which can be used from stable
-
error_handling
Macro used to clean and centralize error handling within async processes
-
gtk_widget_macro
A derive macro helps you handle Gtk widgets
-
rich-result
Rich result type differentiating between recoverable & fatal errors
-
sensitive_trait
A marker trait for sensitive information
-
seventy
Newtype sanitization and validation
-
nvptx-std
stdlib for nvptx64-nvidia-cuda
-
cew
Personal Rust utility library
-
yadir
Dependency Injection Registry for Rust
-
htmxpress
Procedural macros for generating htmx strings
-
printrn
A macro to replace
println!(), that will replace all\nwith\r\n, e.g. for crossterm or other raw terminal work. -
pre
Compile-time assistance for working with unsafe code
-
appro-eq
Approximately equal traits and assertion
-
retoken
Build &str tokenizers using regex
-
byteflags
A macro to generate bitflag-like structures with u8 flag values
-
cflp
A context-free-language parser generated by procedural macros
-
iter_ref
Traits for iterating over referenced data without consuming the iterator
-
oi-unwrap
unwrap without unwrap
-
impl-converter-helper
declarative macro library to help you implement the
FromorTryFromtrait for your type -
axpy
Macro for auto-vectorizing n-ary linear combinations
-
deno-bindgen2-common
Common library used by the deno-bindgen2 project. Contains mainly implmenentations for parsing and transforming Rust source code.
-
hatch_result
A result-like struct that returns on Ok, instead of on Err when ? operator is used
-
forkable
Fork-able iterators and asynchronous streams
-
nonicle
Tools for type-safe, canonical data representations
-
fallible_map
fallible mapping over
Optionand iterators using functions that can returnResults -
near-safe-cell
A more ergonomic 'UnsafeCell' wrapper/replacement
-
hlist
Heterogeneous list with type-directed search
-
standalone-quote
Fork of quote that allows disabling the proc-macro feature in proc-macro2 so as to remove the rustc dylib dependency
-
validator_types
Basic type for validator and validator_derive
-
rstgen
Even simpler code generation for Rust
-
beaver
setting up Rust objects inspired by factory_bot
-
lifted
Higher-kinded types in Rust
-
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
-
fix_me
A very simple macro that lets you write temporary code that WILL NOT build in release mode
-
cismute
Safely transmute type to itself in generic contexts
-
vector_calculus
A single easy-to-use library for all vector calculus computations
-
thiserror_core2
derive(Error) (no_std-enabled using core2)
-
slid
labeled IDs
-
mathelogos
as a functional programming language
-
yolo-block
Like a
tryblock, but automatically unwraps the result -
incomplete
incomplete!(), a compile-time checked version of unimplemented!()
-
collar
easy array collection
-
chunk_iter
Chunked iterator generic over any iterator
-
strflags
A string-enum and string-flags with fixed variants that can also accept arbitrary data
-
fuzzy_match_flex
Fuzzy matching library based on the popular
FuzzyWuzzylibrary for python -
safe_unwrap
allows unwrapping and annotating that the unwrap will never fail. Does not require
std. -
ohos-sys-opaque-types
Internal helper cratefor opaque type bindings that are used in multiple ohos-sys crates
-
statum-core
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
gitoxide-core
implementing all capabilities of the gitoxide CLI
-
byteorder_slice
Byteorder like crate for &[u8]
-
derivative
A set of alternative
deriveattributes for Rust -
cxx-symbols
detail of the
cxxcrate -
macro-attr
macro_attr!macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derivecrate. -
rhizo-types
A collection of common Structs and Enums used in the software components that comprise the Rhizo network
-
typed_macros
Adds typing to your macro's arguments, making it a lot less of a pain to deal with them
-
enum-lexer
A proc_macro lexer generator. using
enum-like syntax. -
reinterpret
Low level utility functions to reinterpret arrays of data
-
lens-rs
lens implemented in rust
-
max_values
Struct and iterator extension trait for getting max values out of given
-
similar-structs-macros
Quality-of-life macros for more concise struct/enum definitions
-
remit
Rust generators implemented through async/await syntax
-
transactional_iterator
Iterator that allows to commit or abort progress
-
trait_exerci
how to understand the trait for rust
-
tightness
Define types bound by arbitrary invariants and conditions
-
nan-tag
NaN-tagged pointers in Rust, storing an f64 in the same space as a pointer
-
hexify
Format hex
-
nullable-result
A replacement for Option<Result<T, E>> or Result<Option<T>, E>
-
ironplc-dsl
Domain-specific language objects for IEC 61131 language elements
-
fs_util
A package providing a few useful functions that std::fs does not
-
bloc
A state management library
-
svgmacro
Write any SVG easily from Rust!
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
nstd_env
NSTD env crate
-
plmap
Parallel pipelined map over iterators
-
always_equal
A wrapper for types that can't implement Eq
-
kaguya_rs
Functional Programming tools and ADTs
-
typestate-builder
Derive-macro-based generator that combines
TypestateandBuilderpatterns -
switcheroo
Lightweight userland context switches
-
fortify
convenient way to bundle owned data with a borrowing type
-
extended_matrix_float
Float trait for extended_matrix lib
-
splitbits
Concise bit field extraction
-
py-comp
A macro implementing a Python-like generator expression
-
termcolor_output
Interface crate for styled output to termcolor through macro
-
maybe_null
A pointer type for handling potentially null values without accidental dereference
-
stack-tokens
stack token implementation for convenient TLS borrowing
-
ts_quote
Procedural macros for quasi-quoting TypeScript from Rust
-
std-io-peek
Peek trait
-
dynstack
A stack for trait objects that minimizes allocations
-
callable
closures implementing PartialEq and argument operations
-
structural
Field accessor traits,and emulation of structural types
-
accompany
with-like macro for Rust -
chandeliers-err
Internal error message generators for the Chandeliers project
-
dec-number
Decimal Floating Point Arithmetic for Rust
-
intuple
Convert structs and enums into tuples (of refs) and back - recursive, ignore fields
-
custom_float
Custom floating-point types
-
zero_v
implementing iterators over function outputs for collections of types implementing a common trait, without using vtables/ dynamic polymorphism
-
try_all
Extends iterators with
try_allto convert iterator of results into result of iterator of okays -
intern-all
A safe and predictable interner for data of mixed and arbitrary type
-
ngram_iter
An iterator of arbitrary N-grams of rust Copy types
-
pipeop
Adding the pipe operator to Rust with a declarative macro
-
anonymous-trait
Anonymous trait implementation with capturing the environment
-
kv-derive
Derive struct conversions from and to key-value vectors
-
named_constants
Procedural macro makes enums behave like named constants in languages like C/C++ or C#
-
macro-stateful
help record state in a global scope
-
bevy_cell
Attach Bevy's Handles/Entities statically to Types
-
mod
project that provides two simple and useful utility functions for converting between Option and Result types
-
anxious
panic-free dialect of Rust
-
unused
Allows for unused generic parameters that do not act like they are owned
-
birds
Combinators using Rust macros
-
magic_static
Global singletons initialized at program start, an alternative to lazy initialization
-
codespan-derive
derive(IntoDiagnostic) for easy codespan integration
-
mat-rs
no_std implementation of mathematical matrix types
-
ryu_floating_decimal
Fast floating point to floating decimal conversion. See the crate 'ryu' for more details
-
ejni
working with JNI more pleasant
-
rust-fp-categories
A Functional Programming Library in Rust, Category
-
exonum_leveldb
An interface for leveldb
-
swiss-army-knife
Common utility code to support linux-support and other projects
-
enum_to_enum
Derives possibly effectful conversions between enums
-
qcomms
small library that offers a simple, zero-cost message passing trait. no async-trait
-
therror
derive(Error) with a twist (based on thiserror)
-
err-context
Lightweight context layers for stdandard library errors
-
byte-mutator
define staged mutations for a series of bytes
-
strategy-pattern-rs
A procedural macro library for implementing the Strategy Pattern in Rust
-
leptos_datatable
A leptos component for creating tables with data validation
-
flagged
Bitflag-based warning type
-
read_buffer
ReadBuffer, a wrapper to safely read into a buffer from a Read
-
enum_derive
macros for deriving additional functionality for enums
-
teloc
compile-time DI framework for Rust
-
fb_cloned
Cloned macro
-
ruroonga_command
A tiny Groonga query builder and generator
-
type-record
A type-level record (see documentation for details)
-
buffer
Safe, write-only, generics-free buffer abstraction
-
light_enum
provide a derive keyword to generate a light enum
-
chia-secp
Secp256k1 and secp256r1 types for Chia
-
defile
Proc-macro helper to ungroup macro metavariables
-
min-specialization
Experimental implementation of specialization
-
typeful
A collection of helper derive macros for type patterns
-
expandable-impl
What if we could check declarative macros before using them?
-
thin-slice
An owned slice that packs the slice storage into a single word when possible
-
comparator
A Java-like Comparator type
-
strser
A struct serializer for rust empowered with a macro
-
try_or_wrap_s
?ortry!macro, with an additional wrapping of the error in something else -
toml_config_trait
Rust trait to turn a Rust struct into a TOML config
-
opentalk-types-signaling-recording-service
Signaling types for the OpenTalk recording_service module
-
kinder
small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
cronjob
scheduling your methods
-
result-ext
Extends
Resultwith additional operations -
anyhow_ext
Extension of anynow
-
error
A fancy error type for highly generic cases
-
r-ex
Zero-bloat Rust core library extensions
-
const-assert
Assert struct for const generics
-
newtype-derive-2018
macros for deriving common traits for newtype structures
-
arr_ty
Macros for smart array initialization (best for trait object element types)
-
okk
approach to replacing the
Ok(()) -
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
-
spans
Split an iterator into contiguous spans
-
scopefn
Scope functions for Rust
-
zhi_enum
derive macros to easily use enum
-
vesta
Extensible pattern matching
-
assure
macros for Rust runtime checks and error handling
-
u-plus
Pretty Unicode code point literals: U+12345 instead of '\u{12345}'
-
laxcow
Clone-on-write smart pointer with relaxed trait constraints
-
kg-symbol
Atomic strings in Rust
-
displaydoc-lite
Implement the Display trait using your standard doc comments
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
not-so-fast
data validation with derive macro
-
lox_utils
General helpers used by Lox
-
ground-env
Parse env variables by defining a struct
-
closure
A macro for capturing variables on a per variable basis
-
mods
Simpler module declaration
-
mauzi
Experimental i18n library using proc-macros
-
rsb_derive
An opinionated macro implementation for Rust struct builder pattern with compile-time validation
-
null-terminated
slices and UTF-8-encoded strings with thin references
-
tuplify
Generic hlist/tuple library
-
rustcomp
Adds vector, map, set, and iterator comprehensions to Rust
-
utility-macros
emulate Utility Types and Unions from TypeScript
-
okey
Everything is Result::Ok
-
enum_index_repr
EnumIndexRepr provides a small macro which allows getting the index on an enum
-
regex_with
providing procedural macros for regex-based parsing and validation of custom data types
-
lubeck
Functional programming framework written in cutting edge rust
-
duplex
trait: interactive streams
-
if_empty
Replace if/else checks for emptyness with a simple method call
-
user-panic
Error messages
-
tectonic_errors
A boxed error type for Tectonic, with supporting utilities
-
microtype
simplify the creation of microtypes
-
unreachable_checked
unreachable!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won't panic.
-
orderless
Orderless/named functions in Rust.
add!(b = 2); // 4. -
mago-reflector
Allows introspection of PHP code structures, enabling tools to examine classes, interfaces, methods, and other elements for advanced analysis
-
exprtk_rs
Rust bindings to the ExprTk C++ library (http://www.partow.net/programming/exprtk)
-
type-registry
Static type registration
-
memprint
A way to print memory layout of a struct
-
project-uninit
Macros for safe references to and initialization of fields in MaybeUninit structs
-
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.
-
flag-mast
Ergonomic Rust bit flags
-
rusty-peg
A macro for defining PEG parsers
-
rangetree
Range-tree for storing non-overlapping scalar ranges
-
bset
Fast and compact sets of bytes or ASCII characters
-
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
-
collection_literals
macros for initializing std::collections
-
check
Convenience assert!-like macros which return instead of panicking
-
dyn-fn-once
Dynamically-typed self-consuming closures in Rust
-
fungus
reduce code verbosity
-
on_drop
on drop
-
mdo
Monadic do notation for rust using macro and duck typing
-
crossdylib
Cross-platform shared state across shared libraries/modules
-
macro-circom
Circom DSL providing macros used in Light Protocol
-
type-factory
unique opaque types
-
restate
state machine library
-
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
finite-fields
Traits and types for computations on finite fields
-
vlq-bij
Bijective Variable-Length Quantity encodings
-
fastperm
A dead-simple, extreme fast permission flag system for Rust with no dependencies
-
cassandra_macro
Create Cassandra tables and CRUD CQL prepared statements from Rust structs. (custom derive: cassandra_macro_derive)
-
signrel
Trait expressing relationship between integers of different signedness
-
cgp-sync
Async-generic primitives to support both sync/async in context-generic programming
-
zerror_core
A complete implementation of the zerror:Z trait
-
mightrix
treat continous memory as a matrix
-
nvim-types
Rust bindings to the Neovim C types
-
iterator-ext
An extension to Rust's Iterator
-
kwarg_macros
Keyword argument plugin
-
errify
Function error context provider
-
static_interner
Similar to
internmentcrate, but with interface and performance tweaks -
jam-pvm-builder
building PVM code blobs, particularly services and authorizers
-
generator_extensions
Basic extensions to Generator types to bring parity with Iterators
-
dyn_ord
Equality and ordering for trait objects
-
inner
The inner! macro descends into an enum variant. It's more flexible than try!() and unwrap(), and it works with your enum, too!
-
enum_variant_macros
Macros to generate From & TryFrom for enums
-
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…
-
fmterr
Sane error reporting that just works
-
default_is_triple_underscore
Shorter syntax for Default::default() : ___()
-
with-id
trait providing method for getting string id from struct
-
quark
Types for manipulating numeric primitives at the bit level
-
assert-impl
Macro for static assert types implement a trait or not
-
irox-enums
Traits for better Enumerated Types
-
formy
derive macro to turn structs into html forms
-
apply_attr
A syntax extension providing higher-order attributes to Rust
-
funlib
Rust functional library
-
zipped
recursively unzipping tuples, Options of tuples and Results of tuples
-
xstd
eXtended STandarD library
-
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…
-
statenum
enabling enums in state-pattern logic
-
sqlx-executor-alias-macro
SQLx Executor alias macro
-
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
-
strong
Strongly typed String
-
xselfref
Fork of the selfref library, with some additions
-
typefun
Emulating various values at compile-time using types
-
do-not-use-testing-rosidl_runtime_rs
Message generation code shared by Rust projects in ROS 2
-
hemtt-preprocessor
A preprocessor library for hemtt
-
consume_on_drop
A zero-cost abstraction that allows Drop::drop to consume self by value
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
lazy_thread_local
Lazily initialised per-object thread-local storage
-
cpp_to_rust_generator
Automatic generator of C++ library wrappers
-
tyco
Macro for generating scoped TYped COntexts
-
check-ends-macro
A couple of macros to simulate match with starts and ends of a string
-
has_fields
Some macros helpful for processing forms with optional fields
-
variant_counter
Rust's Enum variant counter
-
pgx-utils
functions for 'pgx'
-
io-window
Seekable I/O adapter that limits operations to a byte range
-
extrude
A macro for unwrapping an enum value into an Option
-
call-once
A type that can only be called sucessfully once
-
unnest
Macros for an unnested control flow
-
error_def
syntax extension for generating error-handling boilerplate code
-
batch_oper
some batch operation macro for some operations
-
aether_primitives
Helpers for common SDR and signal generation operations
-
tuppipe
pipe operator-like implementation using tuples in Rust
-
macro_error
A macro to display error message
-
not_empty
Slices and vectors that are statically guaranteed to be not empty
-
nias
closure generator library
-
ambience
Lightweight library for passing ambient parameters
-
niceowner
A stupid library that allows you to own a value, even if it comes from a reference. No cloning.
-
borrow-framework
More flexible borrowing
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
rooting-forms
Generates HTML (rooting) forms from structures
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
intercom
writing COM visible Rust components
-
range_check
bounds-checking and range helpers
-
catch-unwind
Wrappers for catch_unwind that handle the edge case of the caught panic payload panicing
-
copypasteck
A plugin lint for detecting
ifandmatchbranches with duplicated conditions or contents -
big_s
Rust’s missing
Stringliteral -
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
dyn_traits
Magically derive non-object-safe traits
-
match-commutative
Match on patterns commutatively, reducing the use of duplicated patterns. ↔️
-
nested-ref
References to data contained in one or more nested RefCells
-
hexhex
hexadecimal conversion 🪄
-
builder_option
A macro to generate builder class for a struct
-
prefixes
Attribute-like macros imitating literal prefixes, e.g. #[f]"Hello, {world}"
-
join_to_string
Join a list of items to string/buffer
-
closure_attr
An attribute macro to simplify closure captures
-
typesafe-builders
Infallible compile-time checked builders for your structs
-
fang_oost
implementing Fang and Oosterlee's algorithm for inverting characteristic functions
-
ffi-toolkit
A collection of functions useful for working with the Rust FFI
-
simple-life
async lifecycle trait and convenient macros
-
io-ensure
Prototype of the
std::io::ensurefamily of macros -
dyn-ptr
A box that stores types like pointers, forgetting everything besides
Self: Unsize<dyn Trait> -
fallacy-clone
fallible clone
-
identifiers
working with rust identifiers and keywords
-
fused_error
working with composable errors
-
default_macro
My default!() macro
-
amass
Automatically generate
Fromimpls for nested enums, even across crates -
hacspec-lib
The hacspec library
-
sod-log
Service Oriented Design - Log Integrations
-
to_tokenstream
An interface for creating a compiler within a Rust macro
-
hold-macro
extended todo!() macro that can suppress unused value warnings
-
current
setting current values for stack scope, such as application structure
-
stable-step
Step for stable rust
-
seesaw
generate traits from C header files
-
interleave_n
A generic iterator interleaving extension for iterators of iterators, based on itertools
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
the-newtype
The Newtype trait
-
floating-ui-utils
Rust port of Floating UI. Utilities for Floating UI.
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
interior_mutability_pointer
A wrapper around
Rc<RefCell<T>>allowing immediate access to inner methods -
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
-
stivale_rs
Rust bindings for the stivale boot protocol
-
select_indices
Iterators for taking multiple shared/exclusive references from a slice
-
tap-trait
Inspect and mutate values without leaving the method chain
-
gpp
A generic C-like preprocessor for Rust
-
encoding-next_index_tests
Helper macros used to test index tables for character encodings
-
c99
C99 types for easier interop
-
then
bool::then functions but named properly
-
once
assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
entwine
Generic slice-like interface for operating on multiple slices at the same time
-
boolinator
trait, which lets you use Option and Result-style combinators with bools
-
err_tools
Helper traits and functions for building errors in rust
-
contains
A Container trait
-
source-chain
Formats StdError with it's source chain
-
qed
Compile-time assertions
-
oneshot-fused-workaround
Fused wrapper for futures::channel::oneshot
-
bitutils
Bitfield macro and utilities
-
x-bow
Precise State Management Library
-
c-emit
Polished builder API to write C Code
-
tt-call
Token tree calling convention
-
units
Measure for Rust. Easy to use, type-safe and customizable.
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
khtml
macros for simple html generation
-
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… -
vec_vec
When dealing with
Vec<Vec<T>>is unavoidable -
try-traits
Alternatives to std lib traits that can fail
-
borrow_channel
A channel for borrows
-
modifier
Fluid chaining APIs for both mutable ownership types
-
slice_trait
A generic trait for any slice, with item as a type parameter
-
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
-
config-docs
A trait and derive macro to generate documentation for your structs
-
fn_block
defining macros for calling blocks or expressions in a closure
-
litenum
minimal convertion utilities between literal and enum
-
extension-eyre
Re-export of color-eyre that introduces Extensions (type-map) to eyre::Report
-
rvs-c-api
C-API for Rvs - A library for defining and evaluating random variables using a simple DSL
-
rusty-matrix
A generic matrix implementation
-
serde-struct-tuple-enum
Procedural macro for deserializing an enum of structs from tuples
-
tearor
Easily turn data races into data corruption!
-
desaturate
This package aims to makes it easier to maintain a single code base for both regular and async functions
-
set_slice
A macro for assigning values to slices
-
easy_retry
easy to use retry library for Rust
-
static_assert_macro
so-called
static_assert -
error-context
Methods and types that help with adding additional context information to error types
-
hexf-parse-libm
Parses hexadecimal floats (see also hexf)
-
enum_primitive
Macro to generate num::FromPrimitive instances for enum that works in Rust 1.0
-
adrop
fast dedicated thread drop
-
lexington
A very simple library for lexing / parsing
-
esvc-traits
Traits for ESVC
-
runtime_injector
Runtime dependency injection container
-
get-field-by-type
Get a value of field, based on the type of a field
-
tapir
Adding tapping functionality to rust
-
wurm
Non-fatal, strongly typed errors
-
spawn_interval
Call a subroutine at a constant time interval
-
result
Helpers for dealing with nested Result and Option types
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
cpp_to_rust
Automatic generator of C++ library wrappers
-
clonesure
A helper macro to create closures which will clone its environment
-
inline-const
Inline consts implemented as a macro
-
speedy_refs
A collection of simple and fast and useful smart pointers
-
future-union
Use future::Either with
impl Future -
endian_trait
A trait for Endianness conversions that can be implemented on most types
-
catch_panic
A helper macro for safe Java-Rust interop that "catches" Rust panics and rethrows them as Java exceptions
-
cute
A macro for Python-esque comprehensions
-
diva
Opinionated convenience wrappers for
std::process::Commandand friends -
set_env
Sets environment variables permanently across all major platforms
-
rustring_builder
string builder
-
podstru
Bureaucratic structs to speed up rust development
-
const_power_of_two
working with constant generics that are powers of two
-
display_with
Return opaque impl Display and/or impl Debug types via display_with and debug_with
-
johalun/module
FreeBSD kernel module in Rust
-
uninitialized
Opt-in unsafe uninitialized memory
-
scout-audit-clippy-utils-soroban
For internal usage by cargo-scout-audit
-
quartet
Nibble (quartet, u4) slices
-
error-doc
proc macro to generate #[doc] comments from #[error] messages
-
slip
A hassle-free utility to encrypt error handling strings in your public binaries to protect your business logic
-
alrulab-core
Alrulab Core Library
-
staticinit
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
orion-async
Eliminate this constraint for performance - the local variables of asynchronous functions must implement Send Trait
-
byteorder_core_io
reading/writing numbers in big-endian and little-endian
-
const_num_bigint
const bigint
-
emboss
A small macro to embed metadata as an ELF/Mach-O section in your final binary
-
axmac
Readable indexing macros for 1-4 dimensional data structures
-
endian-num
Byte-order-aware numeric types
-
parser-c
Macros for parser-c
-
butcher
An easy way to interact with structs and enums wrapped in Cows
-
stable_borrow
A marker trait indicating that borrows are address-stable
-
eternal_iterator
Trait implementation to promise that the iterator iterates forever
-
inline_default
Macro for inline Default implementation
-
surrealize
A procedural macro for generating helper struct variants for use with SurrealDB
-
enum_properties
A macro for declaring static properties on enum variants
-
strongly
A proc macro to create strongly-typed primitives
-
loopcell
cell for multiple routes of access that are only used one-at-a-time in sequence
-
iter-python
Python generator expressions and 'list' comprehensions
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
xreflect
Basic macros for dynamic reflection of structs/enums
-
scanfmt
easy to use macro for parsing a string
-
thisisplural
#[derive(Plural)] for creating frictionless new types with any collection type like Vec or HashMap
-
is-same
A trait for comparing object equality
-
const_typed_builder
Compile-time type-checked builder derive using const generics
-
collected
Summation, product, maximum and more special collectors for Rust iterators
-
init_with
Helper trait to initilize an array with a function
-
stable-pattern
Stable port of std::str::Pattern and friends
-
fmap
Functors in Rust
-
unwrap_let
macro for quickly unwrapping a refutable pattern
-
nstd_str
NSTD strings crate
-
forward_ref_generic
Generically forward references for operations on Copy types
-
mapstruct
Create refactor safe derivatives of Structs with proc-macros
-
lit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
even_bigger_s
Better String Literal
-
rudeboy
Rlua User Data Extension Boy - Derive/attr macros and traits for easily exporting user data to RLua
-
option_macro
a convenience macro
-
extensor
the main extensor crate for building arbitrary valent tensors and more
-
romap
A trait for read-only-maps
-
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.
-
read-restrict
Restrict the number of bytes read from a reader
-
shorten
A collection of convenience functions, macros and traits to shorten repetitive code
-
match_opt
A macro for turning a partial match into a full match returning an option
-
fix_fn
Macro to create recursive closures (similar to the Y combinator)
-
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
-
deref_owned
Generalization of std::borrow::Cow
-
cor_iter
Correlate of two iterators
-
ffizz-header
FFI helpers to generate a C header for your library
-
context-iterators
Iterators adaptors with associated read-only data
-
nvim-oxi-types
Rust bindings to types used by Neovim's C API
-
instruct-macros-types
Instructor Macro Types are a collection of simple types that we export to work with the instruct-macros crate
-
vec3
-
utils-results
The easiest and most intuitive error handling solution
-
split-optional
It split from a source
strtoOption<&'a str>per an element -
tartan-c-enum
Define FFI-safe enums that support unknown values
-
purescript_waterslide
Generate Purescript types from your Rust types
-
define_into_enum
Defines Into<T> on an enum where all variants wrap T
-
hello_egui_utils
used by crates from https://github.com/lucasmerlin/hello_egui
-
rustpy
Bindings of Rust programming language primitives
-
fallible-option
Fallible is an Option with inverted Try-semantics
-
take_mut
Take a T from a &mut T temporarily
-
rustollens
A small and experimental library with a type-level representation of booleans with companion connectives for compile-time sort-of fun with logic
-
audiotags-macro
macros used during the development of audiotags
-
pass_by_catastrophe
Please do not use this
-
ixc_core
Interchain SDK Core
-
composing
Tools to compose functions
-
forsyde-io-libforsyde
The LibForSyDe trait hierarchy and their functions, built on top of the Rust ForSyDe IO supporting library
-
extract-variant
Destructure expressions into, and return assignments from, a single pattern
-
improved_slice_patterns
A tiny crate that provides macros to help matching on Vecs and iterators using the syntax of slice_patterns
-
newtype-enum
Traits to convert between enums and their variant types
-
similarity
calculating similarity between numerical slices
-
fstrings
Python3 fstring interpolation in Rust
-
pyo3_special_method_derive_lib
Automatically derive Python dunder methods for your Rust code
-
partial-functional
A small collection of Semigroups and Monoids for rust
-
rust_io
Macro implementation for [rust_io] defining several operators to be used emulating Haskel [do notation]
-
eater_rangeset
work with set's of ranges
-
spargeo
GeoSPARQL functions
-
take-if
A tiny utility for conditionally taking the contents of an option
-
sexpr-out
Tools for writing S-Expressions from Rust data
-
thinnable
Thin references to unsized types
-
ghosts
Type-check non-existing
Phantomcode for Fun And Profit™ -
dbg_mac
Handy debug only macros
-
rmin
A minimal Rust lib for writting R extensions
-
refute
Add a refute! macro(Elixir inspired). Essentially assert!(false).
-
constructor-lite
Generate minimal constructors for structs
-
derive-name
Derive macro to get the name of a struct, enum or enum variant
-
smart
dynamically-dispatched smart pointers
-
labelled-enum
Converting an enum to/from String
-
arraybox
A box with fixed capacity, backed by a byte array (it can be stored on the stack too). Implements fixed capacity
ArrayBox. -
rstring-builder
String builder type
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
arbintrary
Proof of concept for arbitrary integer sizes using generic const
-
slyce
Python-like slices
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
genz
Uniqueness of types via invariant lifetimes
-
kalgan_string
A collection of functions for string manipulation used by Kalgan Framework
-
omniswap
swap values between possibly-overlapping references
-
engineer
master builder!
-
split_exact
splitting strings into arrays of slices
-
truthy
Check if a value is "truthy"
-
opentalk-types-signaling-polls
Signaling types for the OpenTalk polls module
-
uuid25
25-digit case-insensitive UUID encoding
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
stripmargin
but elegant multiline string in Rust à la Scala
-
bongonet-error
Error types and error handling APIs for Bongonet
-
pretty_panics
pretty panic messages
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
timely-container-master
Container abstractions for Timely
-
test-results
A series of utility macros for outputting testing results
-
compost
Adds a macro to decompose tuples into tuples containing a subset of their values
-
str_assert
Thin wrapper around stdlib assert_eq macros using dissimilar as the comparison. (Only for strings)
-
total_float_wrap
Floating point wrapper implementing Hash and Ord according to IEEE 754 totalOrd
-
getfn
generating function pairs to refer to functions via custom expressions
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
tosserror
derive(Toss)
-
friendly_safety_buddy
A fun macro to write safe code with
-
beard
Handy macro to generate formatted text in rust
-
log-instrument
Offers an attribute procedural macro that adds
log::trace!events at the start and end of attributed functions -
menv
Pulling in arguments from environment variables
-
u16cstr
A macro for creating c-style u16 wide strings at compile time
-
my-desire
poc generic and injection-proof interpolation API for Rust
-
col_proc_macros
A bunch of procedural macros for declare collections of various kinds from their contents as fast as possible
-
audi
Generic listener abstraction
-
meticulous
Result extension to add more meaning to unwrapping
-
diff-ba-rs
macros to get the difference of variables caused by a procedure
-
effect_cell
Container that runs effects when updated
-
lazy_transducer
Lazy, parallel, indexable, generic data iterators
-
smurf
SMall Useful Rust Functions
-
visita
Elegant implementation of the Visitor Pattern
-
atomic_non_null
An atomic wrapper around NonNull
-
mixed_array
Construct arrays of mixed types
-
rustspec
BDD style test library
-
error-macro
error macro
-
unique_ptr
smart pointer implementation in Rust
-
conditional-assignment
very simple, small crate to help make conditional assignments more ergonomic
-
open-ambient
Open files and directories with constant paths
-
type-vec
A type-safe vector with type-level length
-
bpack
Fast, simple and easy to use data compression library meant to work with byte slices of String and str types
-
convertable-errors
defines an ergonomic macro for deriving From<Foreign> conversions for variants of Rust enums
-
chisel-common
Chisel common macros, types and functions
-
map_tuple
Map individual elements of a tuple
-
bos
Flexible Borrowed, Owned or Shared (B.O.S.) smart pointers. Like std's Cow but with Rc/Arc and without the ToOwned requirement
-
iter_mod
A macro for enumerating all the constants in a module
-
optargs
Easily create macros for functions with optional arguments
-
tupleops
work with tuples
-
wrapped-list
Macro for wrapping elements of a list with an object, function, or another macro at compile time
-
kind-derive
Derive generator the kind compiler
-
picostring
A stack allocated string that requires no extra space to store length
-
mixed-num
A trait for generic implementations of numerical methods
-
scalar_types
A module that wraps scalar types in an endian safe type
-
ranged_type
providing ranged numeric types
-
fn_name
Macros that produce the name of the function they're invoked within
-
foreign-types-shared
An internal crate used by foreign-types
-
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
html5ever_macros
High-performance browser-grade HTML5 parser − compiler plugins
-
cell-project
Safe interface for cell projection
-
with-api
macro for shrinking scope
-
fmt_adapter
newtype adaptors to and from any formatting trait
-
structmap
Procedural macro library for converting between Rust structs and associative containers
-
vec2
-
untrusted_value_derive_internals
aim to provide a type-safe way to handle and sanitize potentially untrusted values like user input
-
html_tag
An Enigmatic Way to use HTML in Rust
-
fluent_builder
builder API
-
upget
Super simple trait that patterns the value "updae" and "get"
-
enum_const
enum const trait
-
nes
New Error System for rust
-
close
Trait + smart pointer for manual object destruction
-
predicate
Use enum to predicate something, support & and | operator
-
zoozle
Some I/O macros like C++ cin/cout
-
anyhow-loc
anyhow with location
-
generic_singleton
allowing for generic singleton patterns
-
unwrap-enum
generate methods to access enum variants
-
retry_macro
A set of declarative macros which retries executing a function upon failure
-
cause
A generic [std::error::Error] implementation
-
unwrap_helpers
Helper macros for unwrapping
-
zc_io
zero-copy I/O
-
tlist
Type-level linked lists (of types) and type-level 'functions' to manipulate them. Because TList is implemented using GATs, usage is very ergonomic.
-
eieio
Error Implementing
Eq + Clonereplacingstd::io::Error -
rs-utilities
Some utilities
-
vertigo-html
Html2Vertigo conversion macro usable re-exports
-
scsys-utils
scsys is a collection of primitives and utilities for use throughout the ecosystem
-
io-arc
Proof of concept Arc with IO trait delegation
-
zkp-macros-lib
procedural macros implemented using
proc_macro2 -
powerfmt
powerfmtis a library that provides utilities for formatting values. This crate makes it significantly easier to support filling to a minimum width with alignment, avoid heap… -
common-strings
Macro for storing common strings as enum variants
-
close-err
Add .close() to file-like types, for error handling
-
collect_array
Allows for collecting an Iterator into an exactly sized array
-
function_string_builder
A string builder that takes a user-provided function
-
stackvec
stack-allocated Vectors (performance and/or no-std)
-
nommy
Type based parser
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
error_hook
error hook
-
polimorphism
Function overloading via a procedural macro
-
try-iterator
Adds a few fallible methods to iterators
-
traitobject
Unsafe helpers for working with raw trait objects
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
predicates-core
An API for boolean-valued predicate functions
-
cronus_parser
The DSL parser for cronus API spec
-
better-as
Explicit type casting
-
rustyinject
Zero-cost, compile-time DI framework for Rust
-
vec_remove_if
Extract elements from a vector based on supplied criteria
-
env-var
Macros providing easier access to environment variables in rust
-
typle
Generic tuple bounds and transformations
-
cpp_utils
interoperability with C++
-
inline_newtype
newtype macro inspired by kotlin's inline class
-
cgp-field
Context-generic programming field traits
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
defunctionalize
Defunctionalization as a proc-macro over modules
-
fsize
fsizeis aliased to the floating-point type of pointer size -
soapy-shared
Custom types used by soapy macros
-
supply-chain-trust-example-crate-000023
Single assignment cells and lazy values
-
handle-error
An error handling helper macro to avoid the constant if let Err(e) pattern
-
result-inspect
Adds the missing Result::inspect() function
-
derive_environment
modifying structs via environment variables
-
rbuwu
rust macros but in uwu
-
assert_into
For when writing .try_into().unwrap() feels too long
-
effective
An effects library, an alternative to keyword generics
-
md_match
A macro to support md-match syntax
-
spawn_timeout
Call a subroutine after a constant time interval
-
edisp
Dispatch-on-collect for Rust enums
-
seestr
pointer-wide nul-terminated strings with ownership semantics
-
inew
Macroses for constructor generation
-
simple-di
dependency injection for Rust
-
supply-chain-trust-example-crate-000032
Extra iterator adaptors, iterator methods, free functions, and macros
-
sanitizeable
derive structs without certain fields
-
multiple_errors
Propagate multiple errors instead of just the first one
-
auto-currying
Automatically implement Curry for callable types such that they are curried functions
-
maybe-unwind
A wrapper of catch_unwind that also captures the panic information
-
static-cond
Macro for performing comparisons during macro expansion
-
external_mixin_umbrella
Backing library for
rust_mixinandexternal_mixinto keep them DRY -
monomo
Explicit trait monomorphization
-
nagios-range
types to parse and operate on Nagios ranges
-
mopa-maintained
My Own Personal Any: get your own Any with additional functionality
-
derive-for
Macro for defining structs using the same derive procedural macros
-
flow_impl
Definition of an Implementation trait for flow functions, and a derive macro
-
shpat
sasha's solution to common patterns
-
oneoff
one-off types
-
anyflux
Generic flux-like state management
-
struple
Convert structures from and to tuples
-
no-std-thiserror
thiserror but no_std compatible
-
colmac
Macros to work with
std::collections -
array-lit
Macros for array and
Vecliterals with superpowers -
lazy-attribute
convenient attribute macro for lazy function execution
-
pigeon-impl
Generate recursive-descent & precedence climbing parsers. (extra implementations)
-
and_then_some
extension trait for
boolwith methods that returnOption<T> -
head-tail-iter
An iterator that repeatedly splits head & tail
-
ez_jni_general_utils
General utility functions and data that are common for the ez_jni crate, its macros, and its tests
-
tokio-stream-extra
stream extensions
-
generic_error
A package containing a generic error type that can be dropped in to simplify error handling
-
description
like Display, but 'static
-
value-enum
Macro for generating enums associated with values
-
derive
providing a minimal example of a derivable trait (via companion crate derive-derive) for testing and illustration
-
anymap
A safe and convenient store for one value of each type
-
n-functor
Faux-derive a
mapfunction for types with one or more type parameters -
borrowck_sacrifices
Necessary sacrifices to keep the Borrow Checker happy and developers sane
-
nearly_eq
Nearly(Approximately) equal traits and assertion
-
bagel
Compile-time evaluation and other tools
-
tinytest
Write more compact unit tests with a small macro
-
swahili-dsl
A Swahili-based DSL made for educational purposes
-
anysafe
any safe
-
regex-bnf
A deterministic parser for a BNF inspired syntax with regular expressions
-
number-types
A typenum clone I made for fun with some positive changes but much fewer features
-
failchain
Ergonomic companion library for failure
-
higher-kinded-types
"Generic generics" / higher-kinded APIs in stable Rust
-
scope-exit
The util to call procedure when exit current scope. scope exit. like defer in go.
-
newtype_derive
macros for deriving common traits for newtype structures
-
tuple_tricks
A couple of traits on tuples that allow inductively building new traits
-
macroland
macro shorthands of various types in Rust
-
cri-ref
Embedded-friendly equivalents of URIs
-
option-cell
OptionCell: OnceCell but derivable from Option
-
clonelet
macro to capture by clone in closures
-
garando_syntax2
Backport of libsyntax
-
attr_alias
Reduce attribute repetition with aliases
-
signed_distance_fields
SDFs (signed distance fields) and some operators to play with these SDFs
-
tagname
get the name of a variant in your enum as a string
-
mint
Math interoperability standard types
-
scalar_map
mapfor scalar types -
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
html_stack
A stack based dsl for writing html. This is not an html template!
-
nstd_proc
NSTD process starting/killing crate
-
cursor
A more free Rust-Iterator
-
parametrizer
safe crate for parsing properly-formatted math strings representing parametric functions into Rust functions
-
ssi-verification-methods-core
Core traits and types for verification methods in ssi
-
mago-service
Integrates multiple PHP tooling capabilities—such as parsing, linting, and formatting—into a unified interface for easier tool orchestration
-
peano
numbers implemented in Rust's type system. Consider using typenum instead for much faster type-level numbers.
-
underscore_args
Macro for underscore named argument syntax, aka Dyon
-
aspect-weave
An Aspect Toolkit for Rust
-
as_base
Cast trait objects to some base class
-
serde_str_helpers
Helpers for using serde with strings
-
piping
Pipeline syntax in Rust.
4isize |> double(__) |> __ as usize. -
reglex
lexer generator using regex
-
vec_split
Splits arrays of vectors into arrays of items
-
lsdata
LSD (Less Syntax Data) configuration/data transfer format
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
error-utils
Some rust macros to simplify common error handling patterns
-
expand_array
Macro to convert a static array to a fixed-size array
-
assert-cmp
Convenient assertion macros that print the failed expressions and their evaluated values
-
take-static
Static items that provide mutable access only once
-
make_public
A procedural macro to make struct fields public
-
see-through
traits to provide access to internal fields of generic structs
-
shellexpand-fork
Shell-like expansions in strings
-
drop_ok
.drop_oksyntax sugar forResult. It’s instead of.map(|_|()). -
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
keypath
Derivable, type-safe Swift-style keypaths
-
deborrow
Splits mutable references safely into their fields, and helps with reference manipulation
-
inter-struct
Automatically generated traits for arbitrary structs
-
dyn_struct2
Construct dynamically sized types safely. Supports arbitrary unsized types, not just slices
-
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.
-
dyn-eq
Test equality between trait objects
-
roxygen
Seamlessly document function parameters with rustdoc
-
infix_macro
macro that generates the neccesary boilerplate to use "*operator*" infix functions
-
cpp_core
interoperability with C++
-
konst_macro_rules
detail of the konst crate
-
try-unwrap
A revolutionary new crate that allows you to unwrap() without making your stupid software panic
-
iex
Idiomatic exceptions
-
enum-derived
Generate random instances of your enums and structs
-
codama-errors
Errors and result types for Codama
-
iter-flow
Functional programming utilities for Rust
-
tci
Teaching C Interpreter
-
tuple-conv
Allows converting tuples of one element to vectors
-
phantom-enum
macro library for creating phantom enums
-
turbostate
Finite State Machine
-
astr
A const lenght stack str
-
transitive_from
Helper macros for creating hierarchies of transitive
Fromimplementations -
errormake
A macro for automatically creating Error structs
-
plugin
Lazily evaluated, order-independent plugins for extensible types
-
phtm
Re-exports for common uses of
PhantomData -
conform
Macro to transform struct string fields in place
-
ez-err
error handling library with support for ergonomic and fast error handling
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
peekable_next
An extension for Rust iterators to peek at the next element without advancing
-
derive_di
realized the dependency injection pattern
-
bidirectional_enum
Automatically generates conversions between an enum type and any other type
-
rust-hl7
HL7 Parser and object builder? query'er? - experimental only at any rate
-
lua53-ext
Extension to jcmoyer's Lua 5.3 bindings
-
ees
error-handling library
-
ferment-interfaces
Traits for FFI conversions and some helper methods
-
tylar
Type-Level Arithmetic in Rust
-
aict
Generates auto-incrementing unique IDs
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
bilk
Miscellaneous convenience functions and traits
-
unique
ptr::Unique for stable Rust
-
firedbg-lib
FireDBG Support Library
-
tracing-assert-macros
A macro for capturing trace logs
-
tool
A grab-bag of tools for functional programming
-
any_ref
To capture and move things that are NOT 'static with memory safety
-
typebitset
Type-level bitset implementation
-
refid
Newtype enabling identity comparison (e.g. through pointer equality)
-
unreachable
code optimization hint in stable rust
-
nyavascript
Lisp implementation. Called NyavaScript because I'm a monster
-
polymorph
A set of utilities to better enable polymorphic behavior in Rust
-
lambek
Type-Level Programming in Rust
-
packetrs
Macro-based struct serialization/deserialization
-
simplebyteunit
A thin encapsulate for integer primitives to facilitate a fast, simple, yet ergonomic byteunit implementation
-
spade-types
Helper crate for https://spade-lang.org/
-
io-extra
An extension trait for
std::io::Error, with shorthand constructors for variousstd::io::ErrorKinds -
rle
run-length encoded data
-
into_variant
Easily convert your types into the corresponding enum variant
-
assert-parse
The util to assert macro parsing
-
cereal
data serialisation library
-
letr
The macro for the lazy
-
manifest-dir-macros
function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
bind_match
Convenience macro similar to
matches!but binds to variables in the pattern and returns anOptionof the result -
slicefields
Allows for data structures whose members are sub byte aligned (e.g. a one bit alignment)
-
tinypointers
Pointer implementations that take 8 or 16 bits
-
chained
lazily chaining functions
-
yadi
dependency injection framework for writing applications with the Rust programming language
-
aggregate
attributes of structs for runtime
-
xbitwise
that extends the basic functionality of bitwise operations
-
rubbl_core
Core types and traits for Rubbl, a Rust package for astrophysics
-
maparr
macro to build a static
Mapbased on const array -
io_resp
A RESP parser implementation, written with edge performance in mind
-
pipe-chain
Combinators & parser library
-
once-cell-regex
just gives you the
regexmacro from theonce_celldocs! -
cart_prod
Cartesian product of iterators
-
tuple-fn
call functions and closures with tuple of arguments
-
respan
Macros to erase scope information from tokens
-
srce
Self-Ref Cell Environments
-
mutable-constant
Mutable access to a constant value
-
lifterr
A small set of adapters extending Rust's error-handling capabilities
-
supply-chain-trust-example-crate-000042
derive(Error)
-
uninit-tools
that allows working with uninitialized memory entirely in safe code
-
debug-map-sorted
Sorted Debug impl for HashMap
-
phantasm
Small lib that helps with variance
-
async_t
zero-cost async-traits
-
evaluator
interfaces and implementations for logic constructs that return values without accepting arguments, either via closure captures, global state, calculation or otherwise
-
bin-utils
A bunch of utility macros and traits for binary parsers
-
temp-inst
safe lifetime-erased representations for objects with lifetime parameters. Can be used to pass an object across an API where lifetime parameters would prevent it.
-
generic_static
Generic static variables in generic functions
-
struct-builder
Derive a builder for your structs
-
selective_assertions
Macros for asserting equality of structs with the flexibility to exclude or focus on specific fields
-
event-observer
observer pattern by rust
-
derive-ex
Improved version of the macro to implement the traits defined in the standard library
-
apply_conditionally
Chain and apply methods on objects conditionally
-
structinator_traits
traits allowing transfer of data from iterators to structs
-
thistermination
add the Termination trait to error enums inspired by thiserror
-
mononym
Type-level named values with partial dependent type support in Rust
-
power-assert
Power Assert in Rust. Provides better assertion message.
-
into-a-byte
Build a byte from tuple of Into<u8>
-
tugger-debian
Debian packaging primitives
-
dynamic
A dyanmically typed value with fast downcasting
-
precisej-printable-errno
Printable system call errors for nix
-
clap-action-command
A command-map pattern layered on Clap subcommands
-
opentalk-types-signaling-shared-folder
Signaling types the OpenTalk shared_folder module
-
sim_connect_rs
An easy to use, opinionated API for SimConnect
-
random_stuff
A pile of random helpers, macros, extension traits… that I didn’t care to write a separate crate for. Probably nothing to do with
randcrate. -
model_macro
traits collection
-
if-none
Early break/continue/return if an optional expression evaluates to
None -
dynerr
Macros for dynamic error handling
-
serde_extra
Various de/serialization methods
-
with-thread-local
A micro crate that simplifies a bit the use of the std macro
thread_local! -
validated-slice
Helper macros to implement std traits for custom validated slice types
-
try_convert
Auto-generate TryFrom and an error type, with minimal boilerplate
-
default-test
A default trait that can be used in tests
-
ndless-static-vars
storing static, program-wide parameters for Ndless
-
unwind-unsafe
Zero-sized marker types which do not implement UnwindSafe or RefUnwindSafe
-
transition-table
transition table utilities for keyword parser
-
unibox
Universal Box that can store any type using static or dynamic memory
-
alias-ptr
(Mostly) safe manually-freed shared pointers in Rust
-
rvs-parser
Parser for Rvs - A library for defining and evaluating random variables using a simple DSL
-
rcrefcell
Wrapper type for Rc<RefCell<A>>
-
assert_ok
A macro that asserts a Result is Ok
-
nclosure
composable, nameable closure types with separated states and functionality for use in APIs where anonymous types are unavailable
-
studs
collection of extenstions to the Rust standard library
-
passable_guard
A Guard to help you catch leakage of pointers that you pass over a FFI boundary
-
negative-impl
Negative trait implementations on stable Rust
-
rxs
Reactive extensions library for Rust with Object-safe traits
-
envoy
Conveniences for manipulating environment variables
-
lifelink
Erase covariant lifetime parameters from anything, with generic associated types
-
erroneous
Minimalistic helper for using errors
-
aliri_braid_examples
Examples demonstrating usage of the
aliri_braidcrate -
localization
t! macro, the easiest way
-
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
-
ssi-core
Core types and traits for the ssi library
-
prim_int_kind
Enumeration whose variants represent kinds of primitive integers
-
array_manipulation
Methods for manipuling arrays in a Vec-like fashion. It will (probably) get into core once const expressions get less experimental.
-
kathy
Const-evaluated swift-style keypaths
-
lifetime
Traits and derive macros to change the lifetime of a type, allowing efficient reuse of your stucts or enums with any lifetime requirement
-
code-docs-rs
reading field names, types and comments
-
kvfmt
A helper macro for stringifying variables into a key=value style string
-
type_hash
Generate a hash for a Rust type. The primary use-case for this crate is for detecting differences in message types between versions of a crate. The
TypeHashtrait is implemented… -
self-reference
Helper
-
collections_macros
a collection of macros to make making collections easier
-
rusty_state
state machine for rust
-
static-cow
Cowat the type level: a framework of traits for writing types that are generic over ownership of their contents -
maplit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
cosmian_std
Cosmian std lib to write Rust MPC programs with easier abstractions and helpers
-
into-result
convenience trait for converting something into a
ResultorOption -
bin-pool
A small crate for interning binary slices
-
matrix_match
Macro to match on two values at the same time
-
proc_assertions
Compile-time assertions via procedural macros
-
scones
Generates simple constructors for structs
-
test-macro
macro for writing Rust test code in an easy way
-
arrutil
Functions for manipulating arrays from slices
-
derive_destructure2_examples
Examples for crate derive_destructure2
-
debug-tag
Debug-only tagging for tracking values
-
num-conv
num_convis a crate to convert between integer types without usingascasts. This provides better certainty when refactoring, makes the exact behavior of code more explicit, and allows using turbofish syntax. -
boundnum
Bounded number type
-
trait-set
Support for trait alias feature on stable Rust
-
using
A macro for simpler builders with method cascading
-
frunk_utils
working with frunk
-
chain_linq
.NET's LINQ in rust as a declarative macro
-
eso
Type machinery to build Cow-like containers
-
pure_cell
Alternative to GhostCell that provides safe interior mutability via const expressions
-
encoding_index_tests
Helper macros used to test index tables for character encodings
-
cartesian_array_product
Arrays of the cartesian product of a set of items
-
bointer
Assorted pointer-related utilities
-
a1_notation
A package for converting to and from A1 spreadsheet notation
-
glasses
Macros for writing lots of tests (or specs!)
-
raw_pointer
Safely handling raw mutable pointers to a generic type
-
rustility
A collection of utilities I often find myself using in Rust
-
into_index
Helper traits allowing indexing into vectors and similar types by other types than
usize -
davenport
Ergonomic thread-local workspaces for intermediate data
-
thiserror_lite
Almost drop-in replacement for thiserror, implemented using 100% declarative macros
-
correct
A number wrapper that has correct bitwise shift behaviors rather than the primitives in rust language
-
ogma-libs
Ogma DSL builder libs
-
variadic_monoids
Construct variadic functions using monoids
-
arcmut
Introduce ArcMut, utility for FFI
-
pin-projections
Declarative macro for creating projection functions for pinned objects
-
scsys-core
scsys is a collection of primitives and utilities for use throughout the ecosystem
-
wgsl-types
WGSL Types
-
breadx-image
Image type to be used in breadx
-
enum-to-types
Macro for generating pseudo-enums for type-level programming
-
pointer-identity
Wrapper type to treat the pointer address of types as identity rather than the value
-
into_string
Helper crate to convert values into strings avoiding extra allocations
-
bounded_types
type representing bounded integers, implemented using const generics
-
delay_init
Macro to declare lazily initialized types
-
canpack
Canpack Rust utilities
-
integer_or_float
A data type holding an ‘integer or float’ (a data type in the Unified Font Object specification, among others)
-
lit-vek
iter! and vek! macros for nicer literal syntax
-
exun
Handle unexpected errors
-
tested-trait
Associate tests with traits
-
whiteout
macros that erase the type of any value into an impl Trait for a given trait
-
random-number-macro-impl
Generate random numbers quickly
-
struct_baker
enable ergonomic creation of compile time parsers
-
isnt
Inverted versions of boolean-valued stdlib functions
-
try_as
Macros and traits to ease using enums whose sole purpose is to enumerate a set of types
-
ctti
Compile-time type information
-
anon_enum
Enum types with fully-generic variants
-
memory-size-type
A data type for dealing with memory sizes
-
spidermeme
Traits to test for type equality and type inequality
-
stated-scope-guard
A more flexible RAII pattern for stated resouce management
-
debug_unwrap
Adds the method debug_unwrap for when you just want to make it compile
-
curry-macro
Have fun currying using Rust's native closure syntax
-
user_stable_vtable
A partial implementation of [RFC 2955], written in stable rust
-
atomik
Generic Atomic type
-
bit_fiddler
Macros for common bit operations with multiple convenient patterns
-
newtype
Custom Derive to give tuple structs newtype semantics
-
fstrings-rust
Python3 fstring interpolation in Rust
-
closure_capture
Capture variables are moved into closure or async block
-
byte-array-struct
Macro to create a byte-array backed struct
-
drop_some
.drop_somesyntax sugar forOption. It’s instead of.map(|_|()). -
ref-map
Helper trait for Option and Result to map references
-
type-layout
Derivable trait to view the layout of a struct, useful for debugging
-
tagged_cell
Fast, initializable, and thread safe static variables
-
checked_array
A checked API for array types
-
generic_once_cell
A bring-your-own-mutex version of once_cell
-
shrinkwraprs
Auto-derive for Rust conversion traits -- make working with newtypes a breeze
-
generic-lexer
A generic lexer using a simple match function
-
free_function_pipes
a bunch of traits that makes composing functions together easier
-
stack-trait
Stack trait with entry API for the LIFO element
-
koption_macros
Some macros that are useful for working with
Options -
extern-c
Convert a zero-sized closure into an
extern "C" fn(…)pointer -
borked
convienient error handling library for rust
-
bifurcate
A general, extensible and performant implementation of bisect
-
arrays
Construct an array from an iterator
-
asserts-rs
Asserts utilliy macros for Rust
-
jomy-ap-rustc_ast_pretty
Automatically published version of the package
rustc_ast_prettyin the rust-lang/rust repository from version 1.83.0 The publishing script for this crate lives at: https://github.com/rust-analyzer/rustc-auto-publish -
init-token
one-time safe initialization of static, without overhead
-
match_all
match_all! macro for matching multiple patterns
-
constany_blank
Convert any function to constant
-
keepops
Extension traits for keeping the input of mapping functions
-
const-anonymous-functions
macro to create const anonymous functions
-
generics2
macros for parsing generics (with optional where clause) in
macro_rules!- enhanced fork of generics -
ts_static
Wrapper macro for lazy static and a struct to aid in accessing a static in a thread safe way
-
cherrybomb-oas
Cherrybomb OpenAPI Specification (OAS) struct and functions
-
build-deftly
Derive custom builders, using the derive-deftly macro system
-
moveslice
A one-function crate to move chunks in a slice around
-
zisvalidator
A validator for struct and enum
-
fast-map
Map-like structs
-
polymorphic-constant
A macro to define a numerical constant in multiple types at once
-
asserter
New assertion library for rust
-
rusty-value
Create a generic inspectable value from any rust type
-
serde_type_name
lookup name of type for any struct or enum that derives serde Serialize
-
supply-chain-trust-example-crate-000043
derive(Error)
-
array_init_macro
initialization macro for arrays
-
array-fu
Construct arrays using simple syntax
-
nutype_macros
The newtype with guarantees
-
ptr_iter
Iterators to simplify working with pointers
-
cow_arc
CowArc can be useful for decreasing memory allocations by sharing immutable memory
-
zkp-logging-allocator
Wrapper around the system allocator that logs large allocations
-
sort-by-borrowed-key
Adds two convenience methods for sorting by a borrowed key
-
opentalk-types-signaling-recording
Signaling types the OpenTalk recording module
-
anyinput-core
An internal helper library of anyinput
-
slice-ext
Useful extensions to slices and iterable types
-
mistake
An error handling crate for functions that produce multiple errors
-
opentalk-types-signaling-timer
Signaling types the OpenTalk timer module
-
cobalt-async
collection of helpful functions for working with async Rust
-
unflatter
unflatteris a Rust library providing extension traits for flattening and unwrapping nested structures, including nestedOptionandResulttypes. It simplifies working with deeply… -
input-stream
IO streams similar to C++'s streams
-
async_pipeline_for_lucas
Easy way to pipeline sync and async functions
-
if-let-return
macro for
if let ... pattern -
thin_str
A string type that’s smaller than
Box<str>or String -
valibuk
set of macros implementing the correct-by-construction pattern
-
batbox-tuple-macros
Macro for calling your macro for all tuple sizes
-
struct-variant
Minimal helper macro to generate an enum out of a list of structs
-
hex-display
Display impl for byte slices which provides a hexdump
-
archway
Rust traits for Rc and Arc interoperation
-
graphfind-rs
finding patterns in graphs
-
dot-generator
the set of macros to generate dot files
-
kizuna
service locator
-
raise
yeet!all the things -
cartesian
QOL macro that creates the cartesian product of multiple iterators
-
variadic_closure
Support for dynamically created and called closures with variable number of arguments
-
boulder
Like a builder, but heavier
-
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
-
own-ref
&own references with ergonomic macro construction
-
funfun
Macros for working with closures
-
maybe-owned-trait
Either an owned or borrowed value, with type known at compile time
-
mut_family
A GAT-based library for writing code that is generic over exterior/interior mutability and mutability of references
-
prec
A generic operator-precedence parser library
-
bounded
numeric types
-
abi_stable_derive_lib
detail of abi_stable
-
refcon
A reference-behaving type indifferently wrapping reference or immediate values
-
set_field
Set fields on structs by string
-
dispatchtable
Small library used to specify function dispatch tables HashMap<K, Box<Fn(..)>>
-
resize_slice2
Resize a slice given a larger slice in safe Rust
-
my_rust_utils
My personal set of helpers
-
float-lerp
Lerp and InverseLerp functions for floats
-
to_unit
ToUnit; Any type to () syntax sugar
-
lgio
Lightweight, generic, no_std IO
-
rs_envflag_macros
An easy way to define flags by environment variables
-
iter2
Iterator
chaining,cmping and more as free functions taking twoIntoIterators -
new_york
Home of the dollar slice
-
fatal-error
Differentiate errors and fatal errors
-
into_ext
Extension trait for the “Into” trait, offering a method “.into_::<T>()” to specify the target type of conversion
-
stringy
A tiny Rust crate for generating byte-sized enums that represent a fixed, ordered set of &str data
-
type-layout-syn2
Derivable trait to view the layout of a struct, useful for debugging. Patched for syn 2.
-
multiref
Multireferences: a safe way to do [&T] -> &[T]
-
schemars-zod
A few functions to aid Zod schema generation from rust types annotated with schemars
-
bg
builder + generics
-
iter_columns
Iterate over columns easily
-
injectify
impl Trait in structs
-
slicemath
element-wise operations on arrays of numeric values
-
soft_assert
Non-panicking assertions
-
nuhound
Improve error handling capability
-
size-trait
Traits for restricting the size of type parameters
-
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…
-
static_leak
Leak references with static lifetimes from static Mutexes and RwLocks
-
constduck
Compile-time ducktyping and reflection using const generics
-
ortho_vec_derive
Derive orthogonal vector structure for better CPU cache usage
-
zconvertenumn
Convert number to enum
-
ref-portals
Safely use (stack) references outside their original scope
-
bstringify
stringify! that yields byte string literals instead
-
refmove
An experimental implementation of library-level by-move references
-
defvar
A macro that makes defining environment variables easy
-
zkp-error-utils
Assertion like macros for returning
Result::Err -
unstringify
Procedural macro implemention of the reverse operation of
stringify! -
pythonic-helper
that provides Python-like functions (and some surprises)
-
hash-that-set
Implements hashing for sets and maps themselves. Enables a map of maps to values, or a map of sets to values.
-
error-ex
designed for those who desire clear, explicit, and easy-to-use error creation and handling
-
libsugar
syntactic sugar in the form of a library
-
tyenum
Attribute macro for type enums
-
dyn_safe
Take control of the Semver hazard of the
dynsafety of your traits! -
enum-tools
Automatically derive functions and trait implementations for enums
-
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.
-
string-cases
String case conversion utilities
-
gemstone
collection of utilities
-
constant
evaluation tools for Rust
-
tensor-macros
A compile time optimised tensor library
-
opera
Marker types that are easy to understand
-
pure_pursuit
generic Pure Pursuit in no_std Rust
-
fake-enum
creating FFI safe "fake" enum types
-
rewrap
Result<Result<T, E>, F>->Result<T, F> -
rescue-blanket
Escape values while they are being formatted
-
trace-error
Extensions to Rust's error system to automatically include backtraces
-
bigfactorial
Precalculated compile-time factorial macro for numbers upto 99
-
error_log
struct-based Error-Handling
-
tuple-arity
Get the arity (number of elements) of tuple types with 0-12 elements
-
struct_scheme
structure scheme display
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
composer-primitives
primitives types for composer
-
join-lazy-fmt
Lazy
separator.join(iterable)method andlazy_format!for Rust -
ffi_reflect_csharp
C# code generator for the
ffi_reflectpackage -
stringly_conversions
helping to convert to/from various representations of strings
-
kalman-fusion
single-variable Kalman filtering for Float and Fixed types
-
turbonone
macro for calling functions with Option<T> arguments
-
kozo
syntax sugars for structs
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
generic-mutability
Allows the creation of APIs that are generic over mutability
-
zachs18-stdx
My commonly used extensions to std APIs
-
struct2map
Procedural macro library for converting between Rust structs and associative containers
-
larc
Lazy Arc/Weak pointers
-
extrust
intended as an extension of the standard library
-
bswap
byte-swapping integers, pointers, and slices
-
gamo
A Range like struct for user defined types
-
enum-extract-error
A companion crate for
enum-extractthat exports an error type