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