-
zerocopy
makes zero-cost memory manipulation effortless. We write "unsafe" so you don't have to.
-
anyhow
Flexible concrete Error type built on std::error::Error
-
bitflags
A macro to generate structures which behave like bitflags
-
derive_more
Adds #[derive(x)] macros for more traits
-
pretty_assertions
Overwrite
assert_eq!andassert_ne!with drop-in replacements, adding colorful diffs -
ordered-float
Wrappers for total ordering on floats
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
once_cell
Single assignment cells and lazy values
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
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…
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
shellexpand
Shell-like expansions in strings
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive -
bytes
Types and traits for working with bytes
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
smol_str
small-string optimized string type with O(1) clone
-
snafu
An ergonomic error handling library
-
thiserror
derive(Error)
-
pin-project
safe and ergonomic pin-projection
-
inventory
Typed distributed plugin registration
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
approx
Approximate floating point equality comparisons and assertions
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
enum-map
A map with C-like enum keys represented internally as an array
-
human-panic
Panic messages for humans
-
macro_rules_attribute
Use declarative macros in attribute or derive position
-
ouroboros
Easy, safe self-referential struct generation
-
generic-array
Generic types implementing functionality of arrays
-
frunk
developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
dyn-clone
Clone trait that is dyn-compatible
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
cap-std
Capability-based version of the Rust standard library
-
leptos
full-stack, isomorphic Rust web framework leveraging fine-grained reactivity to build declarative user interfaces
-
bon
Next-gen compile-time-checked builder generator, named function's arguments, and more!
-
zerovec
Zero-copy vector backed by a byte array
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
scopeguard
RAII scope guard that will run a given closure when it goes out of scope, even if the code between panics (assuming unwinding panic). Defines the macros
defer!, `defer_on_unwind… -
az
Casts and checked casts
-
memoffset
offset_of functionality for Rust structs
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
tap
Generic extensions for tapping values in Rust
-
nonempty
Correct by construction non-empty vector
-
float-cmp
Floating point approximate comparison traits
-
bitfield
macros to generate bitfield-like struct
-
lasso
A multithreaded and single threaded string interner that allows strings to be cached with a minimal memory footprint, associating them with a unique key that can be used to retrieve them at any time
-
rustlings
Small exercises to get you used to reading and writing Rust code!
-
bcs
Binary Canonical Serialization (BCS)
-
dlopen2
opening and operating on dynamic link libraries (also known as shared objects or shared libraries)
-
typed-builder
Compile-time type-checked builder derive
-
error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
json-patch
RFC 6902, JavaScript Object Notation (JSON) Patch
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]checks -
polonius-the-crab
Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust
-
writeable
A more efficient alternative to fmt::Display
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
compiler_builtins
Compiler intrinsics used by the Rust compiler
-
assertables
assert macros for better testing, debugging, quality assurance, and runtime reliability
-
nutype
The newtype with guarantees
-
counter
package to count generic iterables
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
volatile
wrapper types for raw pointers
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
constcat
concat! with support for const variables and expressions
-
cfg-if
A macro to ergonomically define an item depending on a large number of #[cfg] parameters. Structured like an if-else chain, the first matching branch is the item that gets emitted.
-
enclose
A convenient macro, for cloning values into a closure
-
beef
More compact Cow
-
rustdoc-types
Types for rustdoc's json output
-
derive-where
Deriving with custom trait bounds
-
iri-string
IRI as string types
-
educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits
-
bit_field
bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
safer-ffi
Write safer FFI code in Rust without polluting it with unsafe code
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
easy-cast
Type conversions which are expected to succeed
-
async-once-cell
Async single assignment cells and lazy values
-
float-ord
A total ordering for floating-point numbers
-
rustc_apfloat
Rust port of C++ llvm::APFloat library
-
assert_matches
Asserts that a value matches a pattern
-
if_chain
Macro for writing nested
if letexpressions -
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
bounded-integer
Bounded integers
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
konst
Const equivalents of std functions, compile-time comparison, and parsing
-
unwinding
in Rust and for Rust
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
tynm
Returns type names in shorter form
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
la-arena
index-based arena without deletion
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
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 -
testresult
type for concise and precise test failures
-
by_address
Wrapper for comparing and hashing pointers by address
-
orchestra
Generate an orchestra of subsystems from a single struct
-
stdext
Extensions for the Rust standard library structures
-
fallible_collections
adds fallible allocation api to std collections
-
aide
A code-first API documentation library
-
lazy_format
lazily formatting values for later
-
axum-valid
validation extractors for your Axum application, allowing you to validate data using validator, garde, validify or all of them
-
foreign-types
A framework for Rust wrappers over C APIs
-
pyo3-stub-gen
Stub file (*.pyi) generator for PyO3
-
protobuf-src
Build system integration for libprotobuf
-
rustrict
profanity filter for Rust
-
io-extras
File/socket handle/descriptor utilities
-
erasable
Type-erased thin pointers
-
virtue
A sinless derive macro helper
-
recursion
cache-aware stack safe recursion
-
arrow-buffer
Buffer abstractions for Apache Arrow
-
similar-asserts
assert_eq! like macros with colorized diff output
-
comparable
comparing data structures in Rust, oriented toward testing
-
lender
A lending-iterator trait based on higher-rank trait bounds, with full std::iter::Iterator functionality
-
async-trait
Type erasure for async trait methods
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
const-gen
generating (relatively) complex compile-time constants in rust
-
cool_asserts
A collection of useful testing assertions and utilities
-
tuples
many useful tools related to tuples
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
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
-
failsafe
A circuit breaker implementation
-
array-init-cursor
help keep track of arrays of MaybeUninit
-
ptr_meta
A radioactive stabilization of the ptr_meta rfc
-
bounded-collections
Bounded types and their supporting traits
-
resman
Runtime managed resource borrowing
-
field-offset
Safe pointer-to-member implementation
-
buffered-reader
A super-powered Reader
-
proof-of-sql
High performance zero knowledge (ZK) prover for SQL
-
terrors
ergonomic and precise error handling built atop type-level set arithmetic
-
bevy_reflect
Dynamically interact with rust types
-
dyn-stack
Dynamic stack wrapper for unsized allocations
-
pyo3-polars
Expression plugins and PyO3 types for polars
-
dynosaur
Dynamic dispatch for return position impl traits and async in Rust
-
tlua
Zero-cost high-level wrapper for Tarantool-LuaJIT
-
pinned-init
facilitate safe pinned initialization
-
tiny-fn
Type erased closures on stack
-
atomic_refcell
Threadsafe RefCell
-
const-random
compile time random number generation
-
arrow-array
Array abstractions for Apache Arrow
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
iter-read
A Read implementation for iterators over u8 and related types
-
deltae
Calculate Delta E between two colors in CIE Lab space
-
fallible-iterator
Fallible iterator traits
-
fatality
extension to
thiserror::Error -
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
rustpython-ast
AST definitions for RustPython
-
psm
Portable Stack Manipulation: stack manipulation and introspection routines
-
ra_ap_ide_assists
Code assists for rust-analyzer
-
try_match
Fallible pattern matching with a function-like syntax
-
soa_derive
Automatic Struct of Array generation
-
pusherator
Push-based version of Rust iterators
-
lending-iterator
Fully general lending iterators in stable rust: windows_mut!
-
aws-smithy-types-convert
Conversion of types from aws-smithy-types to other libraries
-
strck
Checked owned and borrowed strings
-
safe-transmute
A safeguarded transmute() for Rust
-
loupe
Profiling tool for Rust
-
libcnb
A framework for writing Cloud Native Buildpacks in Rust
-
facet-reflect
Allows peeking (reading from) and poking (writing to) types that implement Facet
-
version-sync
ensuring that version numbers in README files and other files are kept in sync with the crate version
-
indoc
Indented document literals
-
shaku
Compile Time Dependency Injection for Rust
-
as_variant
macro to convert enums with newtype variants to
Options -
pretty_assertions_sorted
Wrapper around the
rust-pretty-assertionscrate that allows for the ability to sort the Debug output -
tryhard
Easily retry futures
-
anymap3
A safe and convenient store for one value of each type
-
arrayref
Macros to take array references of slices
-
value-trait
Traits to deal with JSONesque values
-
oxc-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
overload
macro to simplify operator overloading
-
sptr
Strict Provenance Polyfill
-
reval
expression evaluator
-
simple-error
error type backed by a string
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
outref
Out reference
-
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.
-
deriving_via
DerivingVia
-
derive-deftly
An ergonomic way to write derive() macros
-
argp
Derive-based argument parser optimized for code size
-
cascade
Dart-like cascade macro for Rust
-
ffi-convert
A collection of utilities to ease conversion between Rust and C-compatible data structures
-
o2o
Object to Object mapper for Rust. Derive '(Try)From' and '(Try)Into' traits.
-
oqs
interface to Open-Quantum-Safe's liboqs
-
cap-std-ext
Extension APIs for cap-std
-
elain
Set a type's minimum alignment with const generics
-
rdftk_names
set of modules that contain the
IRIs andQNamestrings for commonly used vocabularies. It also provides macro support for defining new namespaces in the same style as this library. -
dync
An efficient alternative to
dyn Traitfor containerized types -
lazy_errors
Effortlessly create, group, and nest arbitrary errors, and defer error handling ergonomically
-
auto_enums
allow multiple return types by automatically generated enum
-
reborrow
Emulate reborrowing for user types
-
const_soft_float
Const Soft Float Point
-
email_address
providing an implementation of an RFC-compliant
EmailAddressnewtype -
sealed
Macro for sealing traits and structures
-
capacity_builder
Builders where the code to calculate the capacity is the same as the code to write what's being built
-
joinery
A small crate for generically joining iterators with a separator
-
dupe
Marker for types which are cheap to clone
-
socketpair
Cross-platform socketpair functionality
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
cast_trait_object
Cast between trait objects using only safe Rust
-
calendrical_calculations
Calendrical calculations in Rust
-
cargo-emit
Talk to Cargo easily at build time
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
dypdl
Libarary for Dynamic Programming Description Language (DyPDL)
-
fstr
A stack-allocated fixed-length string type
-
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…
-
pin-utils
pinning
-
retry-error
An error type for an operation that can fail more than once
-
ronky
way to export Rust definitions to Arri types
-
with_locals
Function attribute to return references to locals by using CPS
-
yazi-macro
Yazi macros
-
frida-gum
Rust bindings for Frida
-
tstr
Type-level strings
-
documented
Derive and attribute macros for accessing your type's documentation at runtime
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
inline-python
Inline Python code directly in your Rust code
-
anyerror
A type of any error for transport
-
arrow-ipc
Support for the Arrow IPC format
-
flex-error
Flexible error definitions using macros and traits
-
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
fixnum
Fixed-point numbers with explicit rounding
-
open-enum
An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
stdio-override
overriding Stdin/Stdout/Stderr with a different stream
-
macro-machines
State machine macros with logging and graphviz DOT file generation
-
vector2d
The spoon of 2D vector libraries, intended for simple game development
-
makers
a POSIX-compatible make implemented in Rust
-
rdftk_iri
IRI and URI specifications
-
autofolder
Single-element folding wrapper
-
fluent-comparisons
Boost readability by writing multicomparison expressions like
if any_of!({a,b,c}>=5) {...}while keeping the benefits of hand-written code -
manganis
Ergonomic, automatic, cross crate asset collection and optimization
-
condtype
Choose types at compile-time via boolean constants
-
rustversion
Conditional compilation according to rustc compiler version
-
data-rw
io buffer write reader
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator -
rollgrid
pseudo-infinite open worlds
-
uniplate
boilerplate-free operations on tree-shaped data types
-
slice-dst
Slice-based custom DSTs
-
statum
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
twilight-mention
working with mentions in the Twilight ecosystem
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
moveit
safe, in-place construction of Rust (and C++!) objects
-
dispose
wrapper for values that must be consumed on drop
-
awint_macro_internals
Internal macro utilities for the
awintsystem of crates -
ra_ap_hir_def
RPC Api for the
proc-macro-srvcrate of rust-analyzer -
as-any
provide the AsAny trait
-
peeking_take_while
Like
Iterator::take_while, but calls the predicate on a peeked value. This allows you to useIterator::by_refandIterator::take_whiletogether, and still get the first value… -
myutil
Rust Util Collections
-
sugars
An useful collection of macros to make tasks easier
-
orion-error
Struct Error for Large Project
-
random-number
Generate random numbers quickly
-
assert-eq-float
assert_eq_float!macros that support floats -
parsable
A trait to easily parse data structures
-
valitron
ergonomics, functional and configurable validator
-
datasize
A simplified heap memory size estimator
-
qualifier_attr
Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
fmodel-rust
Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust
-
advent-of-code
Solutions to Advent of Code
-
r3bl_redux
Redux library built using Tokio, concurrent & parallel
-
ra-ap-rustc_pattern_analysis
Automatically published version of the package
rustc_pattern_analysisin the rust-lang/rust repository from commit ac17c3486c6fdfbb0c3c18b99f3d8dfbff625d29 The publishing script for this crate lives at:… -
merge
multiple values into one
-
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
munge
Macro for custom destructuring
-
devela
A development layer
-
thiserror-no-std
derive(Error)
-
moddef
Macro for convenient module declaration. Each module can be put in a group, and visibility can be applied to the whole group with ease.
-
any_of
A general optional sum of product type which can be Neither, Left, Right or Both
-
display-error-chain
Formats a standard error and its sources
-
dtype_variant
Enables type-safe enum variants with shared type tokens across multiple enums, allowing for synchronized variant types and powerful downcasting capabilities between related enums
-
static_cell
Statically allocated, initialized at runtime cell
-
lowdash
A Lodash inspired utility library to manipulate array and object for Rust
-
metered
Fast, ergonomic metrics for Rust!
-
arr_macro
Initialize arrays with ease!
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
core_maths
Extension trait for full float functionality in
#[no_std]backed bylibm -
crustal
generating C/C++ code
-
istring
A replacement for String that allows storing short strings of length up to sizeof<String>() - 1 without a heap allocation
-
leptos_reactive
Reactive system for the Leptos web framework
-
inlinable_string
inlinable_stringcrate provides theInlinableStringtype – an owned, grow-able UTF-8 string that stores small strings inline and avoids heap-allocation – and theStringExttrait… -
nuts-rs
Sample from unnormalized densities using Hamiltonian MCMC
-
monadify
functional programming abstractions in Rust, focusing on Monads, Functors, Applicatives, and related concepts
-
entrait
Loosely coupled Rust application design made easy
-
funty
Trait generalization over the primitive types
-
psl-types
Common types for the public suffix implementation crates
-
rust_info
Extracts the current rust compiler information
-
thiserror-ext
Useful extension utilities for
thiserror -
panic-halt
Set panicking behavior to halt
-
golem-rib
Parser for Golem's Rib language
-
type-safe-id
A type-safe, K-sortable, globally unique identifier
-
thiserror-context
A wrapper around thiserror, giving you the ability to add context
-
ownedbytes
Expose data as static slice
-
async-fn-stream
Lightweight implementation of
async-streamwithout macros -
oo-bindgen
DSL-based binding geneator for C, C++, Java, and C#
-
validated
The cumulative sibling of
ResultandEither -
sbnf
A BNF-style language for writing sublime-syntax files
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_partsandVec::into_raw_parts -
andex
Safe, strongly typed array indexes and wrappers for rust with zero dependencies
-
hibachi
Asynchronous Batched Inference Platform
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
metastruct
Abstractions for iterating and mapping over struct fields
-
k8-client
Core Kubernetes metadata traits
-
void
The uninhabited void type for use in statically impossible cases
-
aerosol
dependency injection for Rust
-
stackalloc
Safely allocate and manipulate arbitrarily-sized slices on the stack at runtime
-
fixed-hash
Macros to define custom fixed-size hash types
-
iced_anim
creating animations in Iced
-
delegation
Macro-based delegation for enums and structs
-
concat-with
Extend the function of the
concat!macro instd -
base-traits
base traits (for Rust)
-
panfix
parsing: linear time parsing of multifix operators
-
resiter
Helper crate for handling iterators over result
-
k9
rust testing library
-
racer
Code completion for Rust
-
validify
struct validation and modification functionality through the use of derive macros
-
nu-engine
Nushell's evaluation engine
-
num-t
Num<T>: Associate arbitrary types with numeric types
-
rs-event-emitter
simulate promise implementation for rust
-
miden-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
loft
embedded scripting language
-
polars-lazy
Lazy query engine for the Polars DataFrame library
-
macon
builder macro-based generator with its own idioms
-
wallee
Flexible concrete Error type built on std::error::Error with caller location tracking
-
fragile
wrapper types for sending non-send values to other threads
-
relib_internal_shared
relib is a framework for reloadable dynamic libraries
-
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… -
smarterr
Smart error handling library
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
direction
Representations of directions
-
nshare
Conversion between n-dimensional types in different Rust crates
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
components-arena
creating complex domain-specific self-referential data structures
-
rustgram
A fast server framework for hyper with app builder from yml file
-
opentalk-types-signaling-livekit
Signaling types for the OpenTalk livekit module
-
hax-frontend-exporter
mirrors of the algebraic data types used in the Rust compilers, removing indirections and inlining various pieces of information
-
error-code
Error code
-
as-is
An abstraction over ownership
-
refined_type
imbuing rules into types and elevating them to more robust types
-
rudi
out-of-the-box dependency injection framework for Rust
-
optionally_const
Optional constness on stable Rust
-
core_extensions
Extensions for core/std library types, and other miscelaneous features
-
emboss
Macros to embed metadata as an ELF/Mach-O section in your final binary
-
tinyvec_macros
Some macros for tiny containers
-
pagetable
Wait-free 4-level 64-bit pagetable for roughly-contiguous keys
-
orx-pseudo-default
PseudoDefault trait allows to create a cheap default instance of a type, which does not claim to be useful
-
leptos-mview
A concise view macro for Leptos
-
renege
Tracking cache validity using fast concurrent invalidation propogation
-
rudi-dev
Rudi - an out-of-the-box dependency injection framework for Rust
-
indices
macros and methods for safely retrieving multiple mutable elements from a mutable slice, addressing scenarios where slice elements would typically require
RefCellorCell(interior mutability approach) -
tuple
Element-wise operations on tuples
-
context-weaver
(WIP) A procedural text evaluation engine
-
marauders
A work-in-progress code mutation tool
-
v8_derive
Derive macros and helpers for Rusty v8
-
beekeeper
A full-featured worker pool library for parallelizing tasks
-
pariter
Parallel iterator processing
-
fn_meta
Returns metadata about a function at runtime
-
human-errors
An error library focused on providing your users with relevant advice for any problem
-
macro-asm-builder
macro-assemblers
-
tighterror
A minimalistic error representation framework
-
doku
A framework for documenting Rust data structures
-
mydi
MyDI. Dependency Injection library
-
worktable
in-memory storage
-
endian-writer
[no_std] Methods for efficient reading and writing of structures to raw pointers in a stream-like fashion
-
freecs
A high-performance, archetype-based Entity Component System (ECS) written in Rust
-
cartesian
QOL macro that creates the cartesian product of multiple iterators
-
thiserror-core
derive(Error)
-
strong-type
Procedural macros for naming and strong-typing pritimives and strings
-
hyperlight-common
Hyperlight's components common to host and guest
-
tracerr
Custom compile-time captured error tracing
-
libreofficekit
in Rust
-
one_err
OneErr to rule them all
-
enhanced-magic-string
Rust based magic-string implementation with sourcemap chains support
-
tern
Embedded database migrations in SQL or Rust
-
flarrow-runtime
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
tasru
A method to map and understand dwarf symbol information
-
derive_tools
A collection of derive macros designed to enhance STD
-
errs
handling errors with reasons
-
pretty-error-debug
If the process ends with an
Error, write out theErrormessage and chain -
sdl3-main
Tools for using SDL's main and callback APIs
-
const-field-offset
Wrapper around field-offset crate and const-field-offset-macro
-
lazycell
providing a lazily filled Cell struct
-
model-mapper
Derive macro to map between different types
-
rust-automata
A framework and a DSL for building finite state machines in Rust
-
wiwi
Stuff™
-
fieldx
Procedural macro for constructing structs with lazily initialized fields, builder pattern, and serde support with a focus on declarative syntax
-
lazy-static-include
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
squid
A RISC-V emulator with AOT compilation for fuzzing
-
libh3
Safe Rust Bindings to Uber's Hexagonal Hierarchical Spatial Index - H3
-
rustfix
Automatically apply the suggestions made by rustc
-
types_lte_3gpp
3GPP types for Rust
-
rust-box
odd set of tools for Rust programming
-
rust_lisp
A Rust-embeddable Lisp, with support for interop with native Rust functions
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
flyway
Flyway-rs project, Database change control,similar to flyway in Java
-
cheap-clone
A trait which indicates that such type can be cloned cheaply
-
econf
Load environment variables into your struct members in one shot
-
taurpc
A type-safe IPC layer for tauri commands
-
capnp_conv
capnp write/read traits to convert from structs to readers/builders
-
stackerror
A pragmatic error handling library for Rust that provides helpful strings for debugging, and structured data for runtime error handling
-
portaldi
An ergonomic lightweight compile-time depencency injection library
-
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
impls
Determine if a type implements a logical trait expression
-
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
ffi_helpers
help make working with FFI easier
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
enum-assoc
Procedural macro to associate constants with enum variants
-
certain-map
A typed map which can make sure item exist
-
mach_object
Mach-O File Format Parser for Rust
-
reflectapi
code-first web service API declaration and corresponding clients code generation tools
-
case_insensitive_string
A case insensitive string struct
-
nar_dev_utils
用于NARS相关项目开发的实用工具包
-
string-utility
substring implementation (with the RangeBound trait), keep string before or after a specified string, etc
-
elicit
SmartPointer-like structure for polymorphism
-
show-option
displaying Options
-
traitsequence
Traits to abstract over sequences
-
peggen
Generate recursive-descent & precedence climbing parsers
-
familiar
reserve
-
cexpr
A C expression parser and evaluator
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
downcast
Trait for downcasting trait objects back to their original types
-
ext-trait
Annotation to easily define ad-hoc / one-shot extension traits
-
derive_destructure2
Destructure structs that implement Drop
-
cargo-pkg-info-struct-builder
used as a build dependency which provides structured access to Cargo Package Info
-
explicit-error
Explicit concrete Error type for binary crates
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
fixed32
Fixed Point types
-
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. -
regex-macro
A macro to generate a lazy regex expression
-
copyless
Ways to eliminate memcpy calls when using the standard library
-
oxrdf
providing basic data structures related to RDF
-
tea-core
Core data structures and traits for tevec
-
sod-actix-web
Service Oriented Design - Actix Web
-
cursive-extras
Extra views for the Cursive TUI library as well some helper functions and macros
-
spacetimedsl
Ergonomic DSL for SpacetimeDB
-
pumpkin-solver
The Pumpkin combinatorial optimisation solver library
-
elastic-query-builder
ElasticSearch Query Builder
-
buildstructor
Macro to derive a builder from a constructor function
-
bool_ext
defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
spacetimedb-primitives
Primitives such as TableId and ColumnIndexAttribute
-
enumeration
An extension to rust enum
-
quoth
scannerless (no-lexing), developer-friendly parsing library for implementing DSLs and syntax parsers in Rust
-
culprit
error crate with the goal of identifying precisely where and in which context an error occurs
-
typed-oid
Typed Object IDs
-
diagnosticism
Miscellaneous discrete and simple diagnostics facilities (for Rust)
-
culpa
error-handling syntax in Rust
-
bigerror
handle big errors ¯\_(ツ)_/¯
-
rancor
Scalable and efficient error handling without type composition
-
scaffolding-core
A software development kit that provides the scaffolding for building applications and services using OOP
-
redb_model
Redb model derive macro and DTO type conversion
-
tokenlock
cell types that decouple permissions from data
-
dioxus-class
Dioxus class
-
async-transmit
Trait for transmitting data to peers asynchronously
-
defer
excecution of code, inspired by go's defer statement
-
safe_math
Math without overflow, creates an enum and a macro to help mitigate any overflow while multiplying and adding
-
fp_rust
Implement fp features for Rust
-
drop_bomb
A runtime guard for implementing linear types
-
ref_iter
Dynamic borrowing iterator
-
ruut-functions
parse math functions from string (1D,2D,3D,ND) and perform symbolic derivation, gradient, hessian
-
crashlog
Panic handling for humans
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
px-wsdom-macros-decl
wsdom crate
-
hlist2
Compile-time heterogeneous list implementation
-
sdml-parse
Parser for Simple Domain Modeling Language (SDML)
-
normalized-line-endings
Returns an iterator over characters with all line endings converted to \n
-
rrplug
framework for R2Northstar plugins
-
collect-with
enhanced collection operations with capacity control
-
russcip
Rust interface for SCIP
-
rbx_dom_weak
Weakly-typed Roblox DOM implementation for Rust
-
rust_writer
useful for editing a Rust file from Rust code
-
steckrs
A lightweight, trait-based plugin system for Rust applications and libraries
-
gofer
Gofer.rs makes it easy to fetch data from any URL
-
iterate-trait
Experiment with methods on IntoIterator
-
spire_enum
Procedural macros to facilitate enum usage, such as when delegating implementations, extracting variant types, or creating enum tables
-
iridis
framework that lets you define and build dataflow applications with ease
-
pipe-trait
possible to chain regular functions
-
vls-common
Common code for Validating Lightning Signer
-
decmathlib-rs
Port of the Intel Decimal Floating-Point Math Library decimal128 type to Rust
-
lstring
Key String: optimized for map keys
-
dynamodel
derive macro to implement conversions between your object and
HashMap<String, AttributeValue> -
pingora-error
Error types and error handling APIs for Pingora
-
stringleton
Extremely fast string interning library
-
clone_cell
A Cell that works with a restrictive form of Clone
-
hierr
RUST Error
-
ferment
Traits for FFI conversions and some helper methods
-
ecsilarant
Sketch of an ECS for the future
-
option_trait
Helper traits for more generalized options
-
route_match
A context-agnostic http routing utility
-
auto_ops
Macros for easy operator overloading
-
rocketmq-common
Apache rocketmq common
-
unsafe_cell_slice
A microlibrary for creating multiple mutable references to a slice
-
utilz-rs
A lightweight extension trait collection for Rust primitives and types
-
compile_time_sort
Sort arrays and slices of primitives in const contexts
-
time-test
Measure how long your test cases take with one simple macro
-
rst-common
A shortcut to common Rust crates
-
state-department
state management and dependency injection in Rust
-
tuplex
Rust tuple extension
-
envish
Search for environment variables
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
cast
Ergonomic, checked cast functions for primitive types
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
blanket
macro to derive blanket implementations for your traits
-
dyn-context
mechanism for lifetimes erasing
-
type-toppings
Opinionated extensions to standard types
-
enum-derived
Generate random instances of your enums and structs
-
macro-toolset
Some useful macros
-
cfg-elif
Formatter-friendly conditional compilation at item and expression positions
-
ra-ap-rustc_next_trait_solver
Automatically published version of the package
rustc_next_trait_solverin the rust-lang/rust repository from commit ac17c3486c6fdfbb0c3c18b99f3d8dfbff625d29 The publishing script for this crate lives at:… -
opentalk-diesel-newtype
Newtype derive for diesel types used in OpenTalk crates
-
trait-cast
Get your own Any with support for casting to trait objects
-
thallium
A basic game engine
-
concat-idents
Allows concatenating multiple identifiers and using them everywhere
-
alternating-iter
Provide an iterator adaptor which alternate between two iterators
-
reflux
A microservice framework aimed at scalability, flexibility and ease of use
-
swamp-error-report
Swamp error report
-
dialogue-macro
An extension to dialoguer that simplifies command-line interaction interfaces
-
wavltree
An intrusive Weak AVL Tree
-
page-turner
A generic abstraction of APIs with pagination
-
chobitlibs
Single file libraries for my project
-
evcxr_repl
A REPL for Rust
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
luau-parser
A blazingly fast Luau parser with robust error recovery
-
windows-bindgen
Code generator for Windows metadata
-
conv
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
semval
Semantic validation
-
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
actuate
A reactive user-interface framework
-
stylish-html
stylishhelpers for writing styles as HTML elements -
rshyper
focuses on hypergraphs
-
swift-rs
Call Swift from Rust with ease!
-
wellen
Fast VCD and FST library for waveform viewers written in Rust
-
makepad-live-id
Makepad live id symbol interning
-
undo_stack
A minimal undo stack for user defined types
-
tokio-tasks
Task managment for tokio
-
salsa-macro-rules
Declarative macros for the salsa crate
-
gdnative-bindings
The Godot game engine's automatcally generated bindings to Godot classes
-
reactivate
Thread Safe Reactive Data Structure. Made with ❤️ for 🦀
-
expect-exit
Result.expected(): display an error message and exit without a panic
-
funcall
A lightweight Rust library that turns functions into JSON-callable tools
-
ra_ap_la-arena
index-based arena without deletion
-
cfg_rust_features
Set cfg options according to probing for Rust compiler, language, and library features
-
guard-clause
Syntactic sugar for writing simple guard clauses
-
zip_clone
Zip an iterator to a repeatedly cloned object
-
pike
A macro collection to pipe |> your functions calls, like in functional languages such as F#, Elixir and OCamel
-
linear_type
Linear types for rust
-
globals
Painless global variables in Rust
-
sovran-typemap
A thread-safe heterogeneous container with type-safety
-
bash-builtins
implement loadable builtins for bash
-
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)
-
hex_lit
Hex macro literals without use of hex macros
-
collate
Traits and a data structure to support collation and bisection
-
rutie
The tie between Ruby and Rust
-
sandpit
A concurrent garbage collected arena
-
flarrow-builtins
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
io-streams
Unbuffered and unlocked I/O streams
-
doc-comment
Macro to generate doc comments
-
conflate
Merge multiple values into one
-
relend
A generalized reborrowing mechanism that extends beyond simple references. It also allows for implementing traits that work with reborrowing for custom types.
-
version-ranges
Performance-optimized type for generic version ranges and operations on them
-
accessorise
Add accessors to your objects
-
borrowme
The missing compound borrowing for Rust
-
enum-ptr
Ergonomic tagged pointer
-
implementation
The implementation crate
-
text-block-macros
Create a multiline string literal
-
mayheap
An abtraction over alloc & heapless
-
focusable
A trait for types that can be focused
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
intuicio-core
Core module for Intuicio scripting platform
-
supertrait
enables default associated types and const fn trait items in stable Rust
-
concrete-type-rules
Rules and validation for concrete types
-
relax
Derive Partial<T>
-
maybe-borrow
Macros for conditionally returning borrowed data
-
schematic_types
Shapes and types for defining schemas for Rust types
-
pretty-type-name
a shorter version of std::any::type_name
-
radicle-std-ext
Monkey patches of std types
-
enum_discriminant
Procedural macro to add functions on enum types to get discrimnant value from variant or create unit variant from discriminant value
-
spade-hir
Helper crate for https://spade-lang.org/
-
kismesis
A static site generator with plugins and a custom markup language
-
cbor-data
using CBOR as in-memory representation for working with dynamically shaped data
-
orx-closure
An explicit closure with absolute seperation of the captured data from the function
-
ra_ap_hir_ty
The type system for rust-analyzer
-
result-like
Option/Result-like monad interface for your own enum
-
impl-opaque
Macro for declaring complex struct and initializer
-
univec
A vector that can hold elements of any single type
-
const_fn
A lightweight attribute for easy generation of const functions with conditional compilations
-
nnn
Generate your newtypes from a single macro
-
safecast
Traits to define safe casting between types
-
qcl
A Query Check Language written in Rust
-
clsx
A flexible class name composition utility for Rust, inspired by clsx and tailwind-merge
-
sumtype
Generate zerocost sumtype of iterators or closures
-
typeid
Const TypeId and non-'static TypeId
-
nu-std
The standard library of Nushell
-
append-only-bytes
Shareable append-only bytes
-
seasick
Tools for implementing and transcribing C APIs
-
dyn-hash
Hash trait that is dyn-compatible
-
relib
framework for reloadable dynamic libraries
-
self-rust-tokenize
Turns instances of Rust structures into a token stream that creates the instance
-
static_file_util
generating and managing static files in Rust applications
-
portable-io
“ A subset of Rust
std::iofunctionality supported forno-std -
from-string
that provides a FromString trait with a String to String noop
-
yield-return
Implement a coroutine like C#‘s
yield returnusing Rust’sasync,await -
dcc-lsystem
Lindenmayer system together with some rendering tools
-
unsafe-fields
unsafe to access or modify fields with safety invariants
-
libgraphql
building GraphQL tools, clients, and servers
-
compact_strings
A more compact but limited representation of a list of strings or bytestrings
-
mu_rust_helpers
Helper functions for UEFI Rust applications
-
maybe-owned
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
ux2
Non-standard integer types like
u7,u9,u10,u63,i7,i9etc -
garnish_lang_traits
Shared traits for garnish core libraries
-
polyhal-trap
interface for multiple platforms
-
orx-self-or
Defines SoR (self-or-ref) and SoM (self-or-mut) traits that are useful in reducing code duplication and pushing forward the ownership transfer decision from the type designer to the consumer
-
binmarshal
Pack and unpack structs and enums into and out of binary data streams
-
fnrs
some useful functions i like
-
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… -
mstr
2-word, immutable Cow<str>
-
rioc
Zero cost dependency injection macros
-
non_structural_derive
nonstructural derives for auto traits
-
base64_type
type wrapper for Vec<u8> that uses base64 for serialization
-
pilgrimage
A Kafka-like message broker in Rust
-
pair
Safe API for generic self-referential pairs of owner and dependent
-
string_capacity
Moved to capacity_builder
-
ownable
Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more
-
egui-bind
showing keybinds
-
pathbufd
PathBuf with Display + formatting macro
-
pipa
Pipe Operator Library for Rust
-
locate-error
Add location info to errors
-
steel-core
Core compiler and VM implementation for steel
-
mantra-rust-macros
macros to create requirement traces and coverage logs for the
mantraframework -
plrust-trusted-pgrx
Minimal set of
pgrxrexports for plrust, which the authors have deemed trusted -
scoped-panic-hook
Adds scoped, nestable, thread-local hooks for panics and some utilities for capturing and analyzing panics more conveniently
-
ferroid
A flexible ID generator for producing unique, monotonic, and lexicographically sortable Snowflake-style IDs
-
bignumbe-rs
Large, medium-precision numbers
-
hifa-xml-schema
Structure generator from XSD source file
-
psp22
Minimal implementation of PSP22 token standard in pure ink!
-
approxim
Approximate floating point equality comparisons and assertions
-
ff-arcium-fork
building and interfacing with finite fields (Arcium fork)
-
hermit-sync
Synchronization primitives for kernels
-
efcl
The most simple, small, and fast terminal color text library
-
assert_matches2
A version of the assert_matches! macro that brings variables from the pattern into scope
-
iterstats
Statistics for rust iterators
-
zed
A minimal, Redux-like state management library for Rust with advanced features
-
anyhow-http
Customizable HTTP errors built on anyhow
-
simple_pg
extentions and utilites for working with postgres
-
glam-traits
Traits for the vectors in glam
-
anyerr
Dynamic error library with rich error wrapping and context support
-
binread
helping read structs from binary data using ✨macro magic✨
-
poise_error
An opinionated plug-and-play library for error handling in Discord bots made with poise
-
restructed
Quickly derive subsets of your structs
-
cache_diff
Generate clean, human readable diffs between two cache structs
-
amonoid
A general-purpose monoid library
-
barexp
that automatically generates mod.rs files for your project
-
mapper
Mapping macro to help to reduce mapping boilerplate
-
jkcenum
Rust enum library
-
p3-maybe-rayon
Feature-gated wrapper around rayon
-
copyvec
A contiguous growable array type, with a fixed, stack-alllocated capacity that implements Copy
-
run-on-drop
Run code when an object is dropped
-
env_var_helpers
Macros and functions that help provide access to environment variable values
-
shadow_counted
An iterator that counts every iteration in a hidden counter, nested iterators may commit the count to parents
-
error-graph
Allows non-fatal errors in a tree of subfunctions to easily be collected by a caller
-
hash-db
Trait for hash-keyed databases
-
command-error
Detailed error messages and status checking for
std::process::Command -
graphql-starter
GraphQL starter kit
-
structz
Anonymous struct implementation in rust
-
ra2-mix
Red Alert 2 MIX file format library for reading and writing MIX archives
-
try-specialize
Zero-cost specialization in generic context on stable Rust
-
chainerror
Make chaining errors easy
-
re_string_interner
string interning library
-
grit-data-prison
providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element
-
ape
reading and writing APEv2 tags
-
hotload
Zero cost hot update dynamic library; supporting DLL, SO
-
derive-regex
Easily parse a regex into a struct or enum variant
-
cortex-ai
An asynchronous flow-based processing framework for building flexible data pipelines with conditional branching and error handling
-
rsffish
wrapper for fairystockfish based on https://github.com/mind-sports-games/Fairy-Stockfish-Lib
-
fx-callback
A subscription based callback to inform subscribers about relevant data events within structs
-
kindest
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
async-retry
Async Retry
-
derive_generic_visitor
Boilerplate for building rust visitors
-
flipperzero-test
Rust test harness for Flipper Zero
-
superstruct
Versioned data types with minimal boilerplate
-
untrusted_value
aim to provide a type-safe way to handle and sanitize potentially untrusted values like user input
-
lithium
Lightweight exceptions
-
conststr
Constant strings
-
ufotofu
Abstractions for lazily consuming and producing sequences
-
js-source-scopes
extracting and dealing with scope information in JS code
-
linked_list_r4l
Linked lists that supports arbitrary removal in constant time
-
droppy
Friendlier dropwatch
-
despatma
Design Pattern Macro like Loki
-
bypass
Thread-local dynamic variables
-
key-path
Key path for Rust
-
pisserror
A golden rip-off of thiserror
-
assume
Macro for stating unsafe assumptions in Rust
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
error2
error handle library for Rust
-
service-builder
A lightweight, type-safe service construction library for Rust that provides compile-time dependency injection through builder pattern
-
dlopen
opening and operating on dynamic link libraries (also known as shared objects or shared libraries). This is a modern and more flexible alternative to the already existing libraries like libloading or sharedlib
-
path_scan
A lightweight Rust procedural macro for parsing path patterns (URLs, routes) with variable capturing, static binding, and compile-time checks
-
copy_from_str
An extension trait to copy a string into another string
-
ora
Part of the Ora scheduler framework
-
enum_cycling
Small macro for working with enums
-
list_tools
一个自己研发的Vec<T>
-
ffxiv_types
Useful types for FFXIV-related projects
-
octseq
Abstractions for types representing octet sequences
-
with_drop
Nostd wrapper for using a closure as a custom drop function
-
makefile-lossless
Lossless Parser for Makefiles
-
axum-openapi3
Facilitate the generation of OpenAPI 3.0 documentation for axum applications
-
zense
Lightweight web stack
-
variadics_please
Implement things as if rust had variadics
-
rsta
Rust Statistical Technical Analysis (RSTA) - A library for financial technical analysis indicators
-
vine
framework inspired by Spring Boot
-
typle
Generic tuple bounds and transformations
-
nonbox
NaN boxing without boxing
-
prima_bridge
implement the bridge pattern
-
struct-field-names-as-array
generating the field names of named structs as constants
-
round
your floats with precision from 1 to 10
-
error_mancer
Quickly define custom error enums for a function
-
flexcell
A flexible cell that allows safe circumvention of double borrow issues
-
twitch_types
common types for Twitch
-
good-ormning-runtime
Runtime code for good-ormning
-
prost-unwrap
A procedural macro for prost-generated structs validation and type-casting
-
zoet
Adds
#[zoet]macro to reduce boilerplate when implementing common traits -
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
code-path
A code path macro
-
assert_approx_eq
assert approximately equal
-
sod
Service Oriented Design
-
mod_use
pub mod xxx; use xxx::*;
-
gesha-rust-types
Rust types for Gesha proejct
-
frclib-core
A collection of utilities to be used across the FRC in rust ecosystem
-
drop_code
A macro that allows you to implement code that will be automatically executed after the function code has finished, be it the end of the function or even a panic state
-
rustkey
— rust library for tillitis TKey application development
-
fallthrough
Pattern match with fallthrough, in the style of C switch
-
hyperlight-guest
build guest applications for hyperlight
-
take-until
A take_until extension for iterators
-
thiserror-nostd-notrait
derive(Error)
-
surreal_devl
Contains core logic of surreal derive
-
inline-c
Write and execute C code inside Rust
-
gen_ops
Macros for operator overloading for generic types
-
vtid
generating volatile type IDs
-
baxe
that simplifies error handling in Axum
-
cdumay_error_yaml
YAML error
-
deltoid
calculate and apply deltas to structs and enums
-
iter-index
More flexible alternative to Iterator's enumerate() method
-
columnation
Unsafe columnar containers for native Rust types
-
urlquerystring
A high-performance, zero-allocation URL query string parser
-
swamp-script-derive-tests
tests for swamp macro
-
checked-rs
encoding validation semantics into the type system
-
is-odd
Returns true if the given number is odd
-
clone-agave-transaction-view
Agave TranactionView
-
game_inventory
An inventory system independant of item data
-
rama-error
error types and utilities for rama
-
error_status
Model common error context with HTTP 4xx and 5xx code
-
pyo3-error
Unified error causality chains across Rust and Python
-
entity_data
A container for entity component data
-
tantivy-derive
Generate code to converts struct from and to tantivy documents
-
flat-drop
Wrapper that drops recursive objects iteratively to avoid stack overflows
-
concat-string
macros for concatenating string slices into owned strings
-
jacklog
Easy way to get logging the way Jack always wants anyway
-
encdec
binary object encoding / decoding helpers
-
re_error
Helpers for handling errors
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
tisel
Effective type-based pseudodynamic dispatch to impls, enums and typeid
-
scsys-traits
scsys is a collection of primitives and utilities for use throughout the ecosystem
-
random_variant
To be used with all variant, contains the derive macro
-
iter_variants
A way to iterate over all variants of a rust struct/enum
-
rustilities
offers a few utils for Rust development
-
abstract-impl
Create abstract implementations for traits
-
mode
A behavioral state machine library written in Rust
-
hax-frontend-exporter-options
The options the
hax-frontend-exportercrate is sensible to -
numeric_cast
Safely cast between numbers
-
static-keys
Reimplement Linux kernel static keys for Rust userland applications
-
optfield
A macro that generates structs with optional fields
-
irgo
macro to use go-defer-like in Rust
-
isolator
A lightweight library for isolating Rust functions
-
orfail
Error handling library for portable unrecoverable errors
-
ucpack
serialization format used in the Arduino Alvik
-
kutil-std
std utilities from Kutil
-
rukt
dialect for token-based compile-time scripting
-
never
A stable version of the unstable never type (!)
-
torcher
firewall generation tool written in Rust
-
comprehensive_tls
A harness for creating consistently-shaped servers will less boilerplate
-
catboost
inference library for Rust
-
eoe
exiting processes on errors gracefully
-
tamago
generating C code
-
yart
wrapper crate re-exporting the rig_tool macro and shared utilities for rig::tool::Tool
-
xacro
A xml preprocessor for xacro files to generate URDF files
-
prange2
Parse numeric ranges for indexing
-
selfie
Experimental, macro-free and allocation-free self-referential structs
-
jist
Welcome to Jist a lightweight and efficient programming language built in Rust, designed for simplicity, flexibility, and fast performance with a clean and readable syntax. Github: https://github.com/jon429r/JistR
-
dilib
A dependency injection library for Rust
-
autotrait
Reduces boilerplate by auto-generating trait definitions from impl blocks for dynamic dispatch
-
steepen
Create multiple iterators from a single iterator by separating elements
-
constptr
NonNull without mutability
-
lure
Shift left with Lure, a Rust crate that provides a macro for creating lazy Regex instances with compile-time validation, ensuring invalid patterns fail to compile
-
easy_node
Smart pointer for graph nodes
-
coi
Dependency Injection library
-
bherror
TBTL's library for error handling in Rust
-
seal-the-deal
Attribute to use on the
traitmethods (or associated functions) that you wish to “seal”, a.k.a., render themfinal -
termite-dmg
Termite Data Model Generator is a crate meant to generate boiler plate code for data models
-
transpose-future
Transpose Option<impl Future>
-
restd
A re-implementation of various std features
-
slugify
Macro for flexible slug generation
-
ccgen
generate manually maintained C (and C++) headers
-
c8str
String types that are both utf-8 and null terminated
-
iscp-rs
iSCPv2 Client Library
-
generativity
Generation of unique invariant lifetimes
-
ad_trait
Easy to use, efficient, and highly flexible automatic differentiation in Rust
-
indexed_valued_enums
Create enums resolving into values, and get their variants back through their values or their discriminant, inspired by Java
-
db-helpers
Various macros to help with database queries and tables
-
to_boxed
defines ToBoxed Trait and its derive
-
flag-bearer
Generic async semaphores
-
permitit
Cute little library to permit a specific error
-
geqslib
Equation solving made easy in Rust and beyond!
-
borrow-or-share
Traits for either borrowing or sharing data
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
fmt-derive
A more robust and versatile derive macro for Debug and Display
-
non-empty-str
Non-empty strings
-
get_set_macro
Procedural macro to generate customizable getters and setters in Rust
-
typederror
A wrapper around anyhow that allows for a primary error type
-
named-tup
Create named tuples using the tup!() macro
-
tls-api-stub
TLS API implementation that returns error on any operation
-
rs_envflag
An easy way to define flags by environment variables
-
problem
Error handling for command line applications or prototypes
-
composable
Easy composition of functional traits, functions or closures
-
nix-compat-derive-tests
Nix protocols and data formats
-
structx
Simulating anonymous struct and named arguments in Rust
-
xlsx_batch_reader
An Excel file(xlsx/xlsm) reader by batches, in pure Rust
-
better-refcell
A drop-in replacement for
RefCellwith safe unborrow and reborrow capabilities -
cast_checks
A procedural macro to check for invalid casts
-
option-ext
Extends
Optionwith additional operations -
deki
A base for most of my rust projects (tailored to myself)!
-
capwriter
Fast saving and loading with annotating cap for vector and slice
-
std-traits
Traits for types in the standard library
-
bint
Bounded Integer in Rust
-
naan
A fast, easy, and tasty functional programming prelude
-
branch_hints
that provides likely and unlikely branch hint functions in stable Rust
-
gan
Just do it! A small tool provides ergonomic value handling with ignore/ ok/ some semantics
-
std-next
Opinionated utilities and polyfills
-
staged-sg-filter
A staged programming implementation for Savitzky-Golay filters. Loops go brrr.
-
processmanager
manage process lifecycles, graceful shutdown and process faults
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
libsbml
Rust bindings for libSBML
-
substr-iterator
Substring extractor based on characters without allocation
-
gramatika
A minimal toolkit for writing parsers with Rust
-
circuit_breaker
Circuit Breaker pattern for building resilient and fault-tolerant systems
-
sitrep
Frontend-agnostic progress reporting
-
opaque_typedef
Supports defining opaque typedefs
-
nil
Noxmore's Ixperimental Lutilities
-
width_counters
Atomic counters with variable bit widths and customizable atomic ordering
-
odesign
optimal design of experiments library written in pure rust
-
mitex-lexer
Lexer for MiTeX
-
fast-concat
Fastest macro for concatenating strings
-
appcfg
Unix style command line parameter and configuration file parsing library
-
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
-
dowhile_rs
Do while macro for rust with labels and nesting support
-
tfhe-versionable
Add versioning informations/backward compatibility on rust types used for serialization
-
no-break
Typesafe extraction of continuation values from unbreakable control flows
-
dpc-pariter
Parallel iterator processing
-
concat_const
const
&[u8]and&strconcatenation -
iter-scan
Iterator scan methods that don't suck
-
onlyerror
Obsessively tiny error derive macro
-
tc-error
TinyChain's generic error struct
-
typestate
A proc macro DSL for typestates
-
refinement-types
Refinement types
-
supply
Provider API for arbitrary number of lifetimes
-
trycatch
Throw and catch exceptions in rust
-
asn1obj
Rust Asn1 format decode/encode
-
moore-svlog-syntax
The SystemVerilog parser implementation of the moore compiler framework
-
anthill-di
Rust di containers system
-
type_cell
Attach values statically to a type using static get/set methods
-
lunka
Pretty thin bindings to Lua 5.4
-
nonneg-float
A generic NonNegative float wrapper with compile-time checked macro
-
embed_it_utils
The utils for [
embed_it] -
gdnative-async
Runtime async support for godot-rust
-
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
-
getopts-macro
Using macros to concisely define the getopts
-
tomldoc
generate documentation for toml configs defined with serde-derive
-
primitive-from-enum
macros for get primitive enum from complex
-
thermal_hydraulics_rs
A Thermal Hydraulics Library with some useful traits,enums and functions for heat transfer and fluid mechanics
-
chillpill
A more powerful (and more restrictive)
std::panic::catch_unwind -
polyvalue
A weak-typed analog for rust
-
linux-errnos
A list of error numbers
-
threadporter
First aid kit for !Send + !Sync values ⛑️
-
rustc-ap-rustc_errors
Automatically published version of the package
rustc_errorsin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
not-found-error
Convert Option to Result using convenient functions
-
warnings
defining debug only runtime warnings with a way to opt-out
-
mdtrans
Markdown parser and transformer using
pest.rs, focused on flexibility to a project’s needs -
hinted
small crate for providing a size hint and exact size on an iterator
-
triton-isa
The instruction set architecture for Triton VM
-
kolorwheel
Color palette generator for GUI applications
-
try_hard
Malleable error handling for rust
-
more-convert
adds macros for various conversions
-
menva
Manage environment variables
-
bounded-vector
Vec wrapper that guarantees upper and lower bounds on type level
-
slugify-rs
generate slugs from strings
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
cubeb
Bindings to libcubeb for interacting with system audio from rust
-
sigmut
a state management framework designed to be used as a foundation for UI frameworks
-
mac
A collection of great and ubiqutitous macros
-
pyderive
Derive macro of Python special methods and a class attributes for PyO3
-
quickbits
Fast bit manipulation routines for Rust's native integer types
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
runestr
User-perceived characters related types and data structures
-
iterator-sorted
Stable functions for checking iterator sorting
-
cust
High level bindings to the CUDA Driver API
-
transitive
derive macros for Rust
-
stub-macro
stub!() is a better version of todo!() that can be assigned to a variable
-
copstr
COpy STRing module
-
tomli
CLI for quering and editing TOML files
-
parsql-sqlite
Parsql için sqlite entegrasyonunu sağlayan küfedir
-
easy-ext
A lightweight attribute macro for easily writing extension trait pattern
-
portal-solutions-id-arena
id-based arena
-
argcall
Enables enums and structs to be callable by associating functions with their variants or fields
-
unchecked_wrap
Convenient UncheckedSync/Send wrapper types
-
facet-spez
Auto-deref specialization helpers for the Facet reflection system
-
nohashmap
Use HashMap syntax in Rust for non-hashable types
-
pgde
A macro library for consuming PostgreSQL row data into structs
-
autofloat
Pure Rust library for efficient automatic differentiation
-
clamp_to
Clamp integer and float values to the values that fit within both the original number type and the receiving type
-
derail
An alternative to
core::error::Error -
rsciter
Unofficial Rust bindings for Sciter
-
fromage
A cheesy Rust hack for converting between non-local types
-
first-err
Find the first Err in Iterator<Item = Result<T, E>> and allow iterating continuously
-
servicepoint_binding_c
C bindings for the servicepoint crate
-
visibility
Attribute to override the visibility of items (useful in conjunction with cfg_attr)
-
overloaded_literals
Overloaded Literals to construct your datatypes without boilerplate and with compile-time validation
-
unty
Explicitly types your generics
-
kittycad-execution-plan-traits
Types for KittyCAD execution plans
-
olis_string
Small-string optimization for Rust, aims to replace std::string::String
-
precomputed-hash
intending to be a base dependency to expose a precomputed hash
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
misfortunate
Perverse implementations of safe Rust traits
-
maybe-uninit-ext
Extended maybe-uninit types
-
imstr
Cheaply clonable and slicable immutable strings
-
gravitron_macro_utils
Gravitron's Macro Utils
-
actuate-winit
Winit window bindings for Actuate
-
fastpeek
A different way to peek iterators
-
datafusion-session
-
asm_block
Translate tokens to string for Rust inline assembly
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
cell_wrappers
set of macros for ergonomically working with TCells and TLCells from the qcell crate
-
cooked-waker
A safe interface for creating async Wakers
-
defmac
A macro to define lambda-like macros inline
-
newer-type
Support defining newtype wrapper with inheriting trait implementations
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
rspack-allocative
Inspect rust object tree and output it as flamegraph
-
slice-utils
A collection of slice utils, like itertools
-
deterministic_default_hasher
A deterministic initialisation of the stdlib default hasher
-
enumcapsulate
Safe casting for newtype enums and their variants
-
ombrac-macros
Safe, fast, small TCP tunnel using Rust
-
equator
Composable assertion library
-
encdec-base
encdec simple encoder/decoder base types and traits
-
dims_macro
Macros for Generating Systems of Units
-
cstl-sys
Low level CSTL Rust bindings generated with bindgen
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
typed_index
A strongly typed Index that know what it is indexing
-
enumtrait
macros for polymorphism using enums
-
zirv-macros
A collection of useful macros for everyday programming
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
cmajor
Rust bindings for the Cmajor JIT engine
-
rust_examples
rust 的学习中的一些例子
-
transitionable
A no_std compatible type to transition
T -> Twhere you have an&mut T -
cubob
Structured output helpers for display mode
-
tuple_list
macro-free variadic tuple metaprogramming
-
impl_ops_cmp
Macros for easy operator overloading without Copy derive
-
calibrator
methods for calibration of scalar and vector measurement systems
-
suika_mime
handling MIME types in the suika web stack
-
ra_ap_edition
Rust edition support crate for rust-analyzer
-
spade-types
Helper crate for https://spade-lang.org/
-
niloecl
axum handler pattern for twilight interactions
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
assert_hex
display assert panics in hexadecimal {:#x?} format
-
ur
Uniform Resources
-
simple-logging
logger for the log facade
-
currying
anything implementing
FnOnce. Arguments can be passed one at a time, yielding a new something implementingFnOnce(and possiblyFnMutandFn) which can be called with one less argument. -
retrieval
Allows the retrieval of trait implementations
-
crate-inspector
inspect the public APIs of Rust crates
-
flagger
Enum flag generator
-
dioxus-config-macros
Macros used internally by codegen
-
macro-bits
performing macro-based bit manipulation
-
maybe-single
A singleton. Maybe.
-
ringstack
A very simple circular buffered stack implementation
-
therror
derive(Error) with a twist (based on thiserror)
-
rust-code-analysis-web
Run a web service to compute and export code metrics
-
patched
Macro for patch like structure
-
retry-backoff
Retry Backoff
-
ty-tag
TypeId for lifetime containing types via type tags
-
kornia-tensor-ops
Tensor operations library in Rust for computer vision
-
nitinol
event sourcing
-
axocli
common code for setting up a CLI App and handling errors/printing
-
arrcomp
Python-style list comprehension syntax for contiguous memory Rust arrays
-
refreshable
wrapper around a value that changes over time
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
syllogism
allow for some specialization using stable Rust
-
oofs
Error handling library that generates and injects context for you
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
noco
no code, no problem
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
sbpf-asm-macros
Ergonomic macros for low-level sBPF ASM functionality
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
re_tuid
128-bit Time-based Unique Identifier
-
easy-err
An easy Error wrapper
-
heterob
conversion between bytes/bits and heterogeneous lists (tuples)
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
hkt-pin-list
Self managed HKT intrusive linked list
-
ff_ce
building and interfacing with finite fields
-
wiwi-macro-decl
declarative macros for wiwi, a library, of, Stuff™ (implementation detail; do not depend on this crate directly)
-
separator
Formats numbers into strings with thousands separators for readability
-
zerror_full
macro for implementing helpful errors
-
ruru
Native Ruby extensions in Rust
-
cew
Personal Rust utility library
-
iter-identify_first_last
A helper iterator, flagging first and last elements
-
size-of-no-padding
A procedural macro to calculate the size of a type without padding
-
drop-stream
A stream that wraps another stream with a closure that is called once it is dropped
-
truc_runtime
Rust code generator for safe, fixed size, evolving records - runtime
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
structmapper
help you generate code that mapped one struct to another
-
default-constructor
Macros for creating pseudo-dsls that constructs structs through default construction and field conversion
-
adjacent-pair-iterator
An iterator over adjacent pairs in another iterator
-
yukon
trait for the ability to cheaply duplicate an object
-
hypotaxis
Uninterrupted method chaining
-
shive
lightweight IOC service container writen for the Rust applications
-
proc-easy
Macros to make writing proc-macro crates easy
-
intertrait
Allow for inter-trait casting
-
map
map!macro andmap_insert!macro, to create a HashMap collection and insert key-value pairs. Inspired by thevec!macro. -
mate-rs
lightweight arithmetic expression interpreter
-
derive-insert
GetOrInserttrait for enums and its derive macro -
variadiz
Variadic function support for rust
-
discriminant-rs
Convert enum to integer type
-
flexi_func_declarative
exposes the fb! macro to create a function with a flexible signature
-
char-device
Character Device I/O
-
safelog
Conditionally suppress confidential information from logs
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
gazebo
A collection of well-tested utilities
-
manifest-dir-macros
function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
nougat
(lifetime) GATs on stable Rust
-
flatcc
Build-time convenience utilities for flatbuffers
-
sw-errors
error parsing and pretty-printing, used across the swtools toolset
-
schemafy_lib
Generates serializeable Rust types from a json schema
-
stock-symbol
A data type for representing stock symbols
-
rw-exact-ext
Extension of std::io to read and write data types with exact amounts of bytes
-
atomicell
Multi-threaded RefCell on atomics
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
dungeon-cell
Store (almost) any value as one type without dynamic memory
-
lichen
Scripting DSL (for Dialogue Graphs, et al)
-
docify_clone
Docify allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples
-
trybuild-internals-api
A fork of trybuild with the internals exposed as a public API
-
path-dsl
DSL and macro to help deal with Paths and PathBufs
-
flarrow-file-ext
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
data-stream
serialization library based on streams
-
slip-10
SLIP10 implementation in Rust
-
prometheus-macros
Macros for declaring prometheus metrics
-
panic-message
Get a panic message from a panic payload
-
tps_minicbor
A CBOR encoder and decoder suitable for
no_stdembedded targets -
checked_decimal_macro
fixed-point numeric library targeting blockchain development. Originally created and used as a part of the Invariant Protocol. The current version leverages macros, traits and generics…
-
lexi-matic
A Lexer Library
-
iced_af
The iced application framework project
-
format-like
Macro for creating format-like macros with any kind of output
-
iter-chunks
Extend Iterator with chunks
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
guarded
Guard macros
-
ctrlgen
Generate enums for message-passing services
-
thiserror_string_context
Adds context string to error enums generated with thiserror
-
sql_tool_kit
合并 sql_tool_core 和 sql_tool_macros 并一起导出，后续新增的功能都将从这个库中导出
-
natrix_shared
Shared code for Natrix framework
-
fmt-interspersed
write an iterator's items, interspersed with a separator, to a destination
-
unzip_iter
Unzip an iterator to iterators
-
generics
macros for parsing generics (with optional where clause) in
macro_rules! -
polkavm-derive
The derive crate for PolkaVM guest programs
-
vsprintf
Rust bindings to the libc vsprintf function
-
options
The package provides a data structure for managing named parameters
-
crony
cron runner that spawns another thread to run your cron jobs
-
error-ext
Error utilities
-
konst_macro_rules
detail of the konst crate
-
unescape_zero_copy
Unescape strings without allocating memory
-
reductor
Generic abstractions for combining and nesting reduction patterns for iterables
-
nzliteral
Macro simplifying use of NonZero literals
-
stecs
Experimental static compiler-checked ECS library
-
rsjsonnet-lang
A Jsonnet evaluation library
-
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
trait_mux
Proc macro library for generating enums that can multiplex different trait objects
-
tartan-bitfield
Define structures with accessors for particular bits or bit ranges
-
kind
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
shared-type
Shared type alias and several traits to simplify working with Arc<Mutex<T>>
-
numtest
Unit testing for numerical methods
-
trybox
stable,
no_std-compatible, fallible heap allocation -
bounds
interact with bounded and unbounded ranges
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
ffi-enum
Simply write and use
enums like rust native enums, freely passing through ffi -
narr
Numeric Calc
-
cowstr
Copy-on-Write shared strings
-
screeps-game-utils
Additional utility functionality for Screeps: World not included in screeps-game-api
-
f3l_filter
3D Point Cloud Library
-
singleton-manager
A programatical singleton manager
-
rhai-rusp
Rhai bindings for the Rust USP toolkit
-
parsy
efficient parser combinators library
-
availability
describing availability of items
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
eros
Context aware, ergonomic and precise error handling
-
hotswap
Easy code swapping in running executables
-
cdumay_error_json
JSON error
-
vector3d
3D vector type
-
ebnsf
A CLI to generate railroad (syntax) diagrams from EBNF specs
-
degeneric-macros
Hides struct generics into trait associated types
-
add_macro
more additional macros to help you write code faster!
-
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
internal_iterator_rec
Recursive extension for the
internal_iteratorcrate -
poison-guard
maintaining sane state in the presence of panics and failures
-
generator-combinator
Composes combinators to generate patterns of increasing complexity
-
failed-result
A small crate for converting various failed value to result with corresponding error type
-
palindronum
Number palindromes
-
defmt-parser
Parsing library for defmt format strings
-
macro-attr-2018
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
enum_ext
procedural macro that enhances enums with additional methods and conversions
-
lachs
automatically creating a lexer based on a given enum
-
atri_plugin
AtriPlugin
-
coercible_errors
Zero-cost error handling for generic traits
-
cecs
Entity database for the game 'Cao-Lo'
-
kurtbuilds_regex
Wraps the regex library to also provide macros
-
io-adapters
Adapters to convert between different writable APIs
-
easy-error
error utilities
-
hexga_generational
GenVec, ideal for MAS (Multi-Agent System), where each agent can be removed at any time and has references to other agents
-
vcell
Cellwith volatile read / write operations -
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.
-
akvakulturregisteret_rs
API for det nye offentlige Akvakulturregisteret
-
lune-std-datetime
Lune standard library - DateTime
-
abcgen
A procedural macro to generate boilerplate code for objects implementing the 'Actor' pattern
-
core-ext
Useful extensions to core::convert library
-
comparable_test
comparing data structures in Rust, oriented toward testing
-
bijective-enum-map
Convert an enum to and from another type, with From (or TryFrom)
-
dyn_std
Dynamic (object-safe) version of std traits
-
xcfg-rs
configuration file parser for Rust
-
elor
Base generic implementation of an Either type
-
wutil
A lightweight library that contains useful functions, wrappers, and macros
-
to-display
A trait that is Display or can be converted to Display
-
lazy-init
Lazy initialization
-
const-macros
Various macros for const contexts
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
friperms
framework for creating typed permission models for whatever system you could phatom
-
predicates
boolean-valued predicate functions
-
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
-
tardar
Extensions for diagnostic error handling with
miette -
struct-metadata
Macros for attaching metadata to structs
-
sayaka
some simple colorful debugging functions
-
snowferris
various unique ID formats for Rust
-
org-rust-exporter
exporter for org mode documents parsed with
org-rust-parser -
chalk-macros
Macros for Chalk
-
flarrow-url-scheme
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
kernelx
𐲕
-
dyn_struct
Construct dynamically sized types safely
-
tosserror
derive(Toss)
-
easy-envar
Enables easy retrieval and export of environment variables in
build.rs -
enum_index
Trait and macros for extracting Enum variant index
-
ocl-macros
Macros for easier/faster working with the ocl crate
-
choices
HTTP configuration service by defining a struct
-
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
hzrd
Shared mutability containers based on hazard pointers
-
smt-str
working with SMT-LIB strings in Rust
-
datafusion-functions-extra
Extra Functions for DataFusion
-
typed_builder_rules
Opinionated and very limited macro_rules reimplementation of the typed_builder macro
-
ffxiv_types_cn
Useful types for FFXIV-related projects
-
blue_typemap
A TypeMap Dependency Injection method for dynamic function parameters
-
fluent-string
Fluent versions of String mutation methods
-
hb_error
Useful macros and traits for creating and handling errors
-
wings_marshal
WASM plugin system for Geese
-
limbo_ext
Limbo extensions core
-
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.
-
fallible-option
Fallible is an Option with inverted Try-semantics
-
murrelet_livecode_macros
livecode macros for murrelet, a livecode framework
-
extend-fn
Use arbitrary FnMut when something that must implement Extend is needed
-
hidreport
HID Report Descriptor and HID Report parser
-
partial_derive2
makes all the properties of a struct type an optional property
-
qm-utils
functions and macros
-
nonasync
A set of utilities useful for building a non-blocking non-async APIs
-
rust_observer_log_macro
Log macro dependency for rust observer
-
linearity
providing various operations commonly found in branchless programming
-
hexga_map_on
Define the map_on! macro that can be used to impl a lot of trait quickly using macros
-
metrics-exporter-scope
Metrics scope exporter
-
null-pointer
0x0.st file uploader
-
isbn
handling ISBNs
-
inherent
Make trait methods callable without the trait in scope
-
singleton-attr
singleton procedural attribute and derive macro
-
native_messaging
Async implementation of MDN native messaging. Provides the ability to install host manifest.
-
smol-symbol
compile-time globally unique, 25-character, 128-bit symbols similar to the Symbol type in Crystal Lang
-
succinct
data structures for Rust
-
cdumay_error_standard
define standard errors
-
fused_error
working with composable errors
-
marker_trait
Implement a blanket implementation for a marker trait
-
decimal
floating point arithmetic for Rust
-
ds-decomp
DS decompilation toolkit
-
xmacro_lib
macro engine for producing multiple expansions
-
coded
concrete error type with an
ErrorKindenum matching Google’s “canonical error codes” -
methods-enum
Two macros for easy implementation of 'state' design pattern and other dynamic polymorphism using enum instead of dyn Trait
-
const_struct
macro that allows const structures to be passed as const generics
-
macro_lisp
Lisp-like DSL for Rust language
-
cve-rs
Blazingly fast memory vulnerabilities, written in 100% safe Rust
-
map_range_int
map a value from one range to another
-
ellie_core
Core modules for ellie
-
coroutine
in Rust
-
cge
Common Genetic Encoding (CGE) for directly-encoded neural networks
-
effing-mad
The hottest algebraic effects library in Rust
-
data_models
used to lookup the sizes of various C-types of historical data models
-
plain_hasher
Hasher for 32-byte keys
-
deptypes
Dependent types
-
axum-routes
Create an axum Router from an enum and resolve routes
-
isr-macros
Macros for ISR
-
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
-
tryiter
functions for Iterators of Results
-
ra-ap-rustc_type_ir
Automatically published version of the package
rustc_type_irin the rust-lang/rust repository from commit ac17c3486c6fdfbb0c3c18b99f3d8dfbff625d29 The publishing script for this crate lives at:… -
control-flow
A hack to control control-flow outside closures
-
enum_discriminant_traits
Internal implementation of traits for enum_discriminant crate
-
kstring
Key String: optimized for map keys
-
dicebag
Dice rolling!
-
subslice-to-array
Extract fixed-range subslices as arrays, with compile-time checks
-
nonany
Integer types with customizable niche values
-
lucidity
A distributed orchestrator platform for Rust
-
chain-reader
Combining multiple [
Read] instances into a sequential read pipeline with configurable error handling 将多个 [Read] 实例组合为具有可配置错误处理的顺序读取管道 -
home-prelude
Prelude library to support home applications
-
lucene_query_builder
A procmacro derive crate to generate lucene query builder for Rust structs :
-
meticulous
Result extension to add more meaning to unwrapping
-
explicit-error-http
Explicit concrete Error type to manage and monitor errors that generate an HTTP response. It has dedicated feature flag to integrate well with most populars web frameworks.
-
inline-option
A memory-efficient alternative to Option that uses a pre-defined value to represent None
-
var_num
Variable length number implementation that can be used as a drop in replacement for any number primitive
-
derive-merge-struct
A derive macro to partially update a named struct
-
match-commutative
Match on patterns commutatively, reducing the use of duplicated patterns. ↔️
-
pin-macros
primarly used to simplify the proccess of working with self-referencial structures
-
hexga
include all other console hexga crate in one !
-
one-dto-mapper
One DTO mapper
-
softfloat-sys
Rust bindings for Berkeley SoftFloat 3
-
defer-heavy
A versatile and easy to use defer statement for Rust. Similar to Go's or Zig's defer.
-
declarative_enum_dispatch
Declarative macro generating boilerplate for enum dispatch
-
oint
oint ('optional int') provides total operations on arithmetic
-
implicit-fn
A macro that adds support for implicit closures to Rust
-
pubserve
generic observer trait
-
plectrum
An easy way to represent lookup tables in a db as rust enums
-
thin_cstr
An experimental crate which provides a truly thin std::ffi::CStr
-
market
Infrastructure for producers and consumers
-
effective
An effects library, an alternative to keyword generics
-
hook
A filtering mechanism where functions (filters) can be registered, prioritized, and applied sequentially to values associated with named hooks. In Rust.
-
torq_lang
A programming language for concurrent dataflow
-
fn_macro
函数宏
-
strawboat
A native storage format based on Apache Arrow
-
throw
Efficiently add statically-calculated stack traces to errors
-
eventually
using Event Sourcing in Rust applications
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
macro_error
A macro to display error message
-
incomplete
incomplete!(), a compile-time checked version of unimplemented!()
-
tuplemagic
manipulating tuples through various operations like mapping, filtering, nesting, and reducing
-
tskit
rust interface to tskit
-
thisctx
Easily create error with contexts
-
sealed_trait
making sealed traits more accessible
-
tree-splicer
grammar-based test case generator (black-box fuzzer)
-
partial_application
partial function application via the partial! macro
-
nvim-oxi-api
Rust bindings to Neovim's C API for nvim-oxi
-
nolife
open a scope and then freeze it in time for future access
-
shuriken-bindings
Safe bindings for the [Shuriken bytecode analyzer
-
yara-x-parser
A parsing library for YARA rules
-
up_set
Set values, or update them using a closure
-
quick-error
A macro which makes error types pleasant to write
-
named-block
Macro implementing early-exit-from-any-block
-
sodium
FRP (Functional Reactive Programming)
-
emboss_common
Common types and constants for emboss
-
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)
-
has-some
The opposite of is_empty (and is_empty for filters)
-
async-session-types
Asynchronous Session Types
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
stratagem
A trait library that enables state management and command execution with built-in undo support, inspired by the Command design pattern
-
anon_enum
Enum types with fully-generic variants
-
summum-types
A sum-type macro crate with all the conversions, accessors, and support for abstract methods across variants, and interoperability between sum-types
-
qaq-macro
qaq
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
refl
reflencoding which you can use to provide a proof witness that one type is equivalent (identical) to another type. You can use this to encode a subset of what GADTs allow you to in Haskell -
seventy
Newtype sanitization and validation
-
either_of
working with enumerated types that contain one of 2..n other types
-
deep_safe_drop
Safe dropping of deep trees that otherwise could cause stack overflow
-
assemblist
Define your builder patterns as you use them
-
errore
error handling and tracing
-
iter-comprehensions
iterator comprehensions
-
dirty-fsm
A quick and dirty state machine library
-
sourceannot
render snippets of source code with annotations
-
webidl-utils
working with the WebIDL AST, by extending weedle2
-
tea-error
creating custom errors for tevec
-
typemap-meta
compile-time macro to create type-to-value maps
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
erased-discriminant
Type-erased version of core::mem::Discriminant<T>
-
syrette
The convenient dependency injection framework
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
branded
types for Rust
-
simple_parse
A declarative converter for Rust type to and from binary
-
hado
Monadic do notation using a macro
-
adhesion
A set of macros for design by contact in Rust. The design of this library was inspired by D's contract programming facilities.
-
async-safe-defer
Minimal async- and sync-capable
defercrate -
split-every
Split for every n occurrences of a pattern iteratively!
-
proto-mapper
A Macro library for easier mapping between custom models and proto generated code
-
zero_v
implementing iterators over function outputs for collections of types implementing a common trait, without using vtables/ dynamic polymorphism
-
dyn-dyn
Flexible trait object downcasting using ptr_metadata
-
once_cell_serde
Single assignment cells and lazy values
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
bty
Streamlined definition and usage of branded types in Rust
-
fixed-macro-types
Macro aliases used in the
fixed-macrocrate -
yadir
Dependency Injection Registry for Rust
-
assert_unordered
A direct replacement for
assert_eqfor unordered collections -
ointers
What do you call a pointer we stole the high bits off? An ointer
-
coc
A useful macro collections for struct
-
min-max
max! and min! macros
-
rustato
A global state management library for Rust applications
-
bongonet-error
Error types and error handling APIs for Bongonet
-
ckb-verification-traits
The CKB verification traits
-
chassis
Compile-time dependency injection framework
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
semester
High efficiency classnames macro
-
parameterx
flexible and type-safe parameter management system for Rust applications. This library provides multiple ways to store and retrieve typed values using a key-value structure, with support…
-
zh_num
Convert ASCII numbers and zh words
-
enum_delegate
Easily replace dynamic dispatch with an enum, for speed and serialization
-
unwrap-macros
Convenience macro for unwrapping result and option
-
bip_bencode
Efficient decoding and encoding for bencode
-
enum_downcast
Safe downcasting for enums
-
extended_matrix
A matrix calculation module
-
inline_dyn
A container type for storing dynamically-sized types inline
-
sid
Id. Tiny crate providing strongly typed ids and an id-based vector.
-
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
variant_counter
Rust's Enum variant counter
-
nipdf-cff-parser
that parses CFF files, part of nipdf library
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
proc-bitfield
expressively declare bitfield-like structs
-
romap
A trait for read-only-maps
-
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
-
instruct-macros-types
Instructor Macro Types are a collection of simple types that we export to work with the instruct-macros crate
-
type_description
Machine-readable type descriptions
-
enum_handler
A macro to generate a handler trait for enums variants
-
letter-sequence
A method to create sequence displayed as uppercase or lower letters, or digits
-
mapcomp
Python-like list comprehensions for standard containers
-
prctl
This package provides safe abstraction to the linux prctl() interface. Some functions may be architecture-specific.
-
laxcow
Clone-on-write smart pointer with relaxed trait constraints
-
fmttools
Tools for modifying text without allocating any intermediate buffers or unsafe code
-
datafusion-functions-window
Window function packages for the DataFusion query engine
-
pipelining-macro
A convenience macro for the pipeline syntax pattern
-
flarrow-flows
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
deranged
Ranged integers
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
slog-bunyan
Bunyan formatter for slog-rs
-
ser_mapper
Mapped DTO serialzation wrapper for DBO/Model
-
ref_wrapper
Wrapper of dynamically borrowed data
-
iter_fixed
Iterator of fixed length
-
useful_macro
Collections of useful macros
-
differential-dataflow-master
An incremental data-parallel dataflow platform
-
annasul_macro
annasul: macro library
-
singlemap
rust single map a macro
-
assert_has_field
macro for checking if a struct has a specific field
-
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
-
anyreader-walker
reading streams of compressed and uncompressed data without knowing the format in advance
-
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
multer-derive
derive for constructign type from multer Multipart
-
warnalyzer
Show unused code from multi-crate Rust projects
-
gull
type generation
-
openapi_type
OpenAPI type information for Rust structs and enums
-
variant_count
Derive macro for enum which adds to it the count of variants
-
interpolate
form of string interpolation
-
err_mac
no dependency macro for creating error enums with automatic
Fromimplementations -
simconnect
Rust bindings for SimConnect
-
ebacktrace
error wrapper which captures a backtrace and can carry an optional textual description
-
jnt
full of just neat things
-
ref-ops
An escape hatch for implementing
opstraits for references to newtypes -
accursed-unutterable-type-id
A worse version of std::any::TypeId
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
smd_tests
Tests for the smd! macro
-
trustmebro
macro that magically turns unsafe code into ‘totally safe, bro’ with no consequences. Ideal for those who want to assert dominance over the compiler and live on the edge of catastrophe.
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
atom
A safe abstraction around AtomicPtr
-
r-ex
Zero-bloat Rust core library extensions
-
imageproc
Image processing operations
-
dare
daring flexible data representation
-
shorter-bounds
Write shorter bounds with a trait alias macro
-
comprehensive_dns
A DNS resolver for https://crates.io/crates/comprehensive
-
rusttype
pure Rust alternative to libraries like FreeType. RustType provides an API for loading, querying and rasterising TrueType fonts. It also provides an implementation of a dynamic GPU…
-
should_match
Pass a test if the output matches a pattern
-
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
applying
Apply functions in method-position
-
aspect
Toolkit for Rust
-
transient-btree-index
allows you to create a BTree index backed by temporary files
-
typeables
type aliases. By SixArm.com.
-
maybe_path
Zero overhead static initializer for Path
-
cpclib-asm
cpclib libraries related to z80 assembling
-
lef21
Exchange Format (LEF) Integrated Circuit Layout Parser & Writer
-
windows-helpers
Helpers for the windows crate
-
retrying
General-purpose retrying library for Rust with macros and functions
-
rocketmq-error
Rocketmq rust error module
-
tiny-ordered-float
Tiny version of OrderedFloat
-
tonlib-core-anychain
Data structures library for tonlib-client
-
peckr
Rust pointer type that allows packing additional data along with the underlying memory offset
-
debug-fn
A function adapter that implements Display and Debug
-
tuple_key
A serialization format for lexicographically sorted tuples
-
common-error
High performance universal error code management for Rust in Rust
-
pre
Compile-time assistance for working with unsafe code
-
px-wsdom-dom
wsdom crate
-
bflib
a BrainFuck-to-Rust transpiler using Rust proc macro
-
std_utils
Standard utilities for Rust
-
tiny-input
Tiny input macros
-
docsplay
A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc
-
enumx
Ad-hoc enum extension
-
str-macro
The str!() macro, similar to vec![] but for strings
-
rvs
defining and evaluating random variables using a simple DSL
-
pbrt
https://pbrt.org/
-
cuda_std
Standard library for CUDA with rustc_codegen_nvvm
-
koute/nes
emulator written in Rust
-
thread-scoped-ref
that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
byte_set
Efficient sets of bytes
-
moro-local
Experimental structured concurrency support for async Rust (similar to trio's nurseries). Works with non-Send futures on stable Rust.
-
kmacros
Useful macros
-
veho
a iterable toolset
-
error-iter
Error::sources on stable Rust
-
grouping_by
allows the user to group an iterator by various ways
-
fn_zip
zip trait for functions, allowing two functions to be combined before being called
-
cryo
Extend the lifetime of a reference. Safely.
-
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
set_derive
Using Macros to Implement List comprehension Similar to Python Language
-
buggy
A less panicky replacement for unreachable!() and unwrap
-
opensearch-dsl
Strongly typed OpenSearch DSL
-
sirena
Digital audio signal processing primitives
-
mago-type-syntax
core utilities useful for building lexers and parsers within Mago
-
clap-doc
Create markdown descriptions for
clap::Commands -
downgrade
mutable reference to an immutable one
-
ai_iter_utils
A short description of my package
-
prev-iter
Iterator which allows you to view the previous element
-
rlz
Relative Lempel-Ziv (RLZ): a LZ based compressor against a large static dictionary
-
multihash-derive
Proc macro for deriving custom multihash tables
-
zlink-macros
Macros providing the high-level zlink API
-
core-nightly
Nightly build of libcore from the rust repo
-
hello-world-in-rust
Hello World!
-
reax
A reactivity system for Rust that infers dependencies between functions
-
event-listener-primitives
Low-level primitive for building Node.js-like event listeners
-
as_num
Checked conversions between Rust's numeric types
-
right-as
Chain call assigns tuple elements to outside
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
irox-types
Enums and structs to describe Rust's basic type system
-
kube-core
Kube shared types, traits and client-less behavior
-
sst
sorted string table abstraction
-
shoggoth
Generic and type-level programming for Rust
-
imgref-iter
A small crate for iterating over the rows or columns of
imgrefbuffers -
tupletools
functions for tuples
-
mutcy
Zero-cost safe mutable cyclic borrows using borrow relinquishing
-
sly_static
Seamless Rust Static Initialization: Effortless and Efficient
-
async_fn_traits
Trait synonyms for “Fn[…]”-trait bounds returning futures
-
medi-rs
mediator library for Rust
-
audiotags-dev-macro
macros used during the development of audiotags
-
goof
A reusable, composable, aggregate and
no_std-friendly error library -
progress-streams
Progress callbacks for types which implement Read/Write
-
lazyinit
Initialize a static value lazily
-
bit_roles
Granular role management based on bit flags
-
simple_search
searching objects
-
scientisto
A light-weight Rust implementation of the github/scientist library used for careful refactoring of critical code paths
-
result-ext
Extends
Resultwith additional operations -
k8s-controller
lightweight framework for writing kubernetes controllers
-
is_slice
Macro to answer the question: is it a slice?
-
odesolver
solving ODE's
-
recursive_reference
way to walk on recursive structures easily and safely
-
numeric
N-dimensional matrix class for Rust
-
retry-policy
Retry Policy
-
nject
Zero cost dependency injection module
-
gur
A undo-redo framework
-
yoyo
Animation library for Polyhorn
-
traitreg
Create a registry of implementations of a trait
-
sized-dst
Owned container for dynamically-sized types backed by inline memory
-
yikes-intenum
Augment integer-based enums with an unknown variant; a macro that makes you say "yikes!"
-
reltester
Automatically verify the correctness of [Partial]Eq/Ord implementations
-
tectonic_errors
A boxed error type for Tectonic, with supporting utilities
-
tri_ton
A Macro for Handling Exceptions
-
the-string-macro
The missing
string!macro to constructStringvalue from string literal -
partially
Partial trait, and an optional macro to mirror a struct, wrapping each field in an Option
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
defer-rs
Deferred execution Rust utilities
-
wx-core
微信数据解析工具
-
std-ext
Extend the standard library functionality
-
layered-crate
Proc-macro to declare internal dependencies amongst modules inside a crate
-
kinded
Generate enums with same variants, but without data
-
emplacable
Return unsized values from functions
-
haz
A thin abstraction over polymorphic environments
-
float_plus
Additional features for float values
-
zipped
recursively unzipping tuples, Options of tuples and Results of tuples
-
nade
Adding named and default arguments to Rust functions
-
guarded-tls
Guarded thread-local variables
-
scoped-writer
Scoped writer utility
-
spawns
Async runtime agnostic thread context task spawner for Rust
-
hip-runtime-sys
Bindings for the HIP runtime
-
ad-hoc-iter
Ad-hoc exact size owning iterator macro and other optional utils
-
ddi
Dynamic dependency injection library for rust
-
lsp-document
Helpers to convert between LSP documents and Rust strings
-
internship
Interned string and more
-
illicit
An implicit thread-local environment which is indexed by type
-
rs-std-ext
An extension for the standard library
-
intuicio-framework-pointer
Raw pointer framework module for Intuicio scripting platform
-
notzero
macro for constructing
std::num::NonZero*from constants -
banquo
An offline monitor for Signal Temporal Logic formulas
-
recore
A re-implementation of various ::core features
-
ez-err
error handling library with support for ergonomic and fast error handling
-
rust2fun
functional programming in Rust
-
chasa
A parser combinator with
manytaking iterator, conditional branching, and method chain -
string-literals
Rust macros to more easily create String types
-
tryvial
Small crate for ok-wrapping and try blocks
-
seesaw
generate traits from C header files
-
xtaskops
Goodies for working with the xtask concept
-
throwing
Create explicit errors easily with a handy macro
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
stackstring
A fixed-size string
-
objid
Generate a random object identifier
-
dyn-error
Error-related utilites for Rust
-
hand
Easy to use, pretty cmd log for lazy devs
-
std_io_iterators
An iterator for
STDINand a wrapper forSTDOUT. Allows easy piping, and graceful closing of application if pipe breaks -
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction -
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
pin-init
Safe pinned-initialization in Rust
-
collapse
Trim and collapse consecutive whitespace to a single space
-
derive_constructors
Deriving From, TryFrom and create new_with_*args* functions
-
posix-errors
Posix error codes and handy functions for using them
-
high_mem_utils
bunch of mem safe abstractions,some involving transmute
-
flow-control
Declarative macros for common flow-control use cases such as break, continue, and return
-
multiple_errors
Propagate multiple errors instead of just the first one
-
cantor
A general toolkit for working with types that have a small number of values
-
plain_enum
Mimicing Java's enum::values() and EnumMap
-
sawp-ffi
FFI helper macros and traits
-
cmp
convenience macros and function for comparing
-
unreachable
code optimization hint in stable rust
-
axerrno
Generic error code representation
-
ownref
Provide the smart pointer type that bundles the data with its owner
-
schema_org_types
Schema.org schemas as Rust types
-
netcdf3
A pure Rust library for reading and writing NetCDF-3 files
-
interning
Thread-Lcoal and Global Interning Library
-
tggen
A mildly competent autogenerated telegram bot api wrapper (helper crate)
-
assert-within
Macro for testing that (generic) floating point numbers are within some tolerance
-
uwuizer
Rust Macro to UwUize your text. UwU.
-
tailsome
Blanket traits providing
.into_ok(),.into_err(), and.into_some()for happier method chaining -
projecture
Easy arbitrary type projections without proc macros
-
enum_pipeline
way to use enums to describe and execute ordered data pipelines
-
nova
Macro to derive newtypes with support for serde and sqlx
-
smart-string
A collection of string types and traits designed for enhanced string manipulation
-
standback
New standard library, old compiler
-
cfgenius
Conditional compilation with macro support in Rust
-
rsor
Reusable slice of references
-
davisjr
HTTP framework designed around simplicity and ease-of-use
-
bbtk
A collection of frequently used libraries that should be in stdlib
-
wherr
Enhance Rust errors with file and line details using the
#[wherr]macro for clearer debugging -
shorten
A collection of convenience functions, macros and traits to shorten repetitive code
-
open-vaf
A compiler frontend for VerilogA aimed predominently at compact modelling
-
arkham
TUI made simple
-
slice-diff-patch
providing utility functions for diff and patch of slices
-
nonicle
Tools for type-safe, canonical data representations
-
bumpalo
A fast bump allocation arena for Rust
-
unused
Allows for unused generic parameters that do not act like they are owned
-
brain_flak_macro
Brain-Flak macro
-
panda-re
The official library for interfacing with PANDA (Platform for Architecture-Neutral Dynamic Analysis)
-
defer-lite
A lightweight high-performance implementation of Go's defer statement
-
keypath
Derivable, type-safe Swift-style keypaths
-
selfref
Semi-pain-free self-referential pinned types
-
simple_detailed_error
Stack and specify errors explainations saying what happened, why, how, where, how to solve it and its causes
-
simple-life
async lifecycle trait and convenient macros
-
axum-embed
Serve embedded files with axum
-
squeak
providing types allowing execution of callbacks in response to values being broadcast or mutated
-
ruma-identifiers-validation
Validation logic for ruma-common and ruma-macros
-
devela_depend
Optional external dependencies for
devela -
shared_singleton
trait provides singleton pattern state management with shared container
-
crashreport
Automatic GitHub crash reporting system for any Rust crate
-
color-core
Color shared definition
-
scoped_thread_local
Highly flexible Scoped thread local with HKT builtin
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
arc_macro
A macro wrapper around Arc::new() for convenience
-
ak_macros
faster development and simpler syntax with Macros Ak-Macros Group
-
sylt-typechecker
Typechecker for programs in the Sylt programming language
-
tapir
Adding tapping functionality to rust
-
buffer
Safe, write-only, generics-free buffer abstraction
-
lurk-ipld-macro
lurk-ipld macro
-
memtable
Inmemory tables for use in Rust
-
stream_assert
Macros to simplify testing of
Streambased APIs -
docpos
Compact-document items after defining them (fn, struct, enum) + document fn parameters with rustdoc (⑂roxygen)
-
desaturate
This package aims to makes it easier to maintain a single code base for both regular and async functions
-
almost
comparing floating point numbers
-
air-macros
Macros for the TNJ Assembly Intermediate Representation (AIR)
-
os-thread-local
OS-backed thread-local storage. This crate provides a
ThreadLocaltype as an alternative tostd::thread_local!that allows per-object thread-local storage, while providing a similar API… -
zkp-macros-decl
Procedural macros
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
rewrap
Result<Result<T, E>, F>->Result<T, F> -
source_generator
Basic source code generation features
-
delegare
delegate struct easy
-
libipld-macro
ipld macro
-
stated-scope-guard
A more flexible RAII pattern for stated resouce management
-
audi
Generic listener abstraction
-
num-sign
enum Sign { Positive = 1, Negative = -1 }
-
nonminmax
Primitives types which cannot be their minimum/maximum value
-
enum_macro
Useful macro for enum
-
hlua
Zero-cost high-level wrapper for Lua
-
async-iterator
An async version of iterator
-
peeking-iter
An iterator adapter that allows infinitely-deep peeking
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
explicit-error-exit
Explicit concrete Error type to manage errors that end a process/program
-
type-uuid
Safe, stable IDs for Rust types
-
libccp
Rust bindings for libccp, a library for implementing CCP-compatible datapaths
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
sensulator
sensor simulator, provides noisy readings of ideal measurements
-
envro
load environment variables from a .env file into the process environment variables
-
struple
Convert structures from and to tuples
-
name-it
Give a name to async fn return types
-
axmac
Readable indexing macros for 1-4 dimensional data structures
-
intern-arc
An interner that deallocates unused values
-
fold-license
Folding licenses from multiple dirs with
cargo/Cargo.toml andyarn/package.json -
state_maschine
A State Machine Framework written in Rust
-
non-empty-slice
Non-empty slices
-
cifg
A macro for defining #[cfg] if/else blocks; alternate to cfg-if
-
cubiomes-sys
Raw ff binding for the cubiomes library
-
thisisplural
#[derive(Plural)] for creating frictionless new types with any collection type like Vec or HashMap
-
multi-array-list
A
MultiArrayListstores a list of a struct -
lifterr
A small set of adapters extending Rust's error-handling capabilities
-
dec-number
Decimal Floating Point Arithmetic for Rust
-
permeable
A permission-demand trait. Decouples the permission-demander from the permission / auth provider.
-
ddd-rs
Domain-Driven Design (DDD) building blocks, for Rust applications
-
asmov-common-traitenum
using fieldless enums as schema definitions
-
id_sys
data structures which can be marked such that they only work with similarly marked integer data types
-
derive-name
Derive macro to get the name of a struct, enum or enum variant
-
serde_fs
[De]serializing data structures as files
-
postfix-macros
Postfix macros on stable Rust, today
-
find_all
A (nearly) identical alternative for
Iterator::findwhich returns anOption<Vec<usize>>containing all elements which meet a given predicate (instead of just the first) -
libdusk
implements most of the compiler for the Dusk programming language, in library form
-
head-tail-iter
An iterator that repeatedly splits head & tail
-
fluent-asserter
write tests assertions with a fluent interface
-
jget
Rust tools
-
const-exhaustive
Enumerate all values of a type at compile time
-
efmt_core
Core library for efmt crate
-
no-std-thiserror
thiserror but no_std compatible
-
serde_table
Write structs in an easy table format
-
rustc-std-workspace-std
Workaround for rustbuild
-
rust-fp-categories
A Functional Programming Library in Rust, Category
-
iridis-message
iridis is a framework that lets you define and build dataflow applications with ease
-
unroll_range
Repeats a block of code for each number in a specified range
-
rust_book_code
The code of rust book
-
option-chain
A macro for using
?operator in functions that don’t returnOption -
fd_bs58
Optimized Base58 codec for 32 and 64 byte numbers
-
sod-crossbeam
Service Oriented Design - Crossbeam
-
sqnc
Traits and adaptors for sequences
-
cmdstruct
A lightweight macro for implementing commands with a struct
-
yansongda-utils
rust 中一些关于我自己的常用工具
-
scad
generating OpenSCAD models using rust
-
pipeop
Adding the pipe operator to Rust with a declarative macro
-
sql_tool_core
这个库是 sql_tool_macros 库的核心，存储 trait
-
linq
Language Integrated Query in Rust
-
rpi-derive-key
deriving secure device-specific keys on Raspberry Pi
-
precisej-printable-errno
Printable system call errors for nix
-
peekable-fwd-bwd
Iterator Peekable with multi-forward-peek and multi-backward-peek
-
oop
Object-Oriented Inheritence in Rust
-
yadi
Dependency Injection framework for writing applications with Rust programming language
-
aranya-buggy
A less panicky replacement for unreachable!() and unwrap
-
roopert
object-oriented toolkit for Rust
-
dbg_unreachable
Switch between unreachable! and unreachable_unchecked with a single macro
-
dev_bestia_url_utf8
url utf8 encode/decode
-
big_s
Rust’s missing
Stringliteral -
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
isnt
Inverted versions of boolean-valued stdlib functions
-
async_to_iter
Convert async functions to generators on stable Rust
-
facet-opaque
Type-erased pointer helpers for Facet types
-
vec3
-
elise
A concurrent GC
-
dyn-eq
Test equality between trait objects
-
redb_model_trait
Redb model trait
-
higher-kinded-types
"Generic generics" / higher-kinded APIs in stable Rust
-
summavy_codecs
Fast field codecs used by tantivy
-
u-plus
Pretty Unicode code point literals: U+12345 instead of '\u{12345}'
-
oxydized-money-macros
Companion library to oxydized-gains providing convenience macros
-
fuck-backslash
replace the backslash with slash in-place in your PathBuf
-
error-ex
designed for those who desire clear, explicit, and easy-to-use error creation and handling
-
bitmask
generator for enum scoped bit flags
-
isclose
A collection of trait and macros for comparing approximate equality
-
derive_destructure2_examples
Examples for crate derive_destructure2
-
xavier
lightweight and versatile XML parsing library designed to streamline the process of handling XML data with ease and efficiency
-
fluid-macro
Write long method chains as a series of steps instead, and more!
-
audiotags-macro
macros used during the development of audiotags
-
thistermination
add the Termination trait to error enums inspired by thiserror
-
dynerr
Macros for dynamic error handling
-
common_macros
common macros like
hash_map!orhash_set!(WIP) -
wurm
Non-fatal, strongly typed errors
-
benri
Convenient macros wrapping the standard library
-
repeated
Allows you to repeat a block of code a number of times
-
box-dyn
Macro to derive the implementation of Trait for Box<T: Trait>
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
utils-results
The easiest and most intuitive error handling solution
-
entrance
A command line argument parser library which provides type assisted tools
-
typestate-builder
Derive-macro-based generator that combines
TypestateandBuilderpatterns -
validity
A type safe wrapper for enforcing arbitrary properties at compile time
-
diatom-std-core
Diatom core standard library
-
hyphenation_commons
Proemial code for the
hyphenationlibrary -
init_with
Helper trait to initilize an array with a function
-
codespan-derive
derive(IntoDiagnostic) for easy codespan integration
-
embed-nu
Embed the nu engine in your rust application
-
portaldi-core
Core functionalities for portaldi
-
diesel_derives_traits
Traits for diesel_derives_extra
-
crete
Ergonomic, thread-safe & flexible state management
-
collected
Summation, product, maximum and more special collectors for Rust iterators
-
typed-sql
A strongly typed sql serialization/deserialization framework
-
ratelimit_rs
The ratelimit package provides an efficient token bucket implementation
-
static_interner
Similar to
internmentcrate, but with interface and performance tweaks -
wec
Useful vec!-like macros
-
type-variance
Marker traits for subtype variance
-
readonly
Struct fields that are made read-only accessible to other modules
-
birds
Combinators using Rust macros
-
mdbx-derive-tests
poorman MDBX orm
-
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!,include!, orconcat_idents!) -
wtflip
A language in a Rust macro... or something.
-
enum-display
A macro to derive Display for enums
-
diffuser-edit
Edit diffuser models without GPU and Python
-
kust
Kotlin-like APIs for Rust
-
thiserror_lite
Almost drop-in replacement for thiserror, implemented using 100% declarative macros
-
pnet_macros_support_bandwhich_fork
Support library for libpnet_macros
-
ryu_floating_decimal
Fast floating point to floating decimal conversion. See the crate 'ryu' for more details
-
tor-async-utils
Async/futures helpers for use with Tor
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
wrapp
Add additional functionality to Rust errors using a wrapper
-
derive
providing a minimal example of a derivable trait (via companion crate derive-derive) for testing and illustration
-
phantasm
Small lib that helps with variance
-
dess
Differential Equation System Solver (DESS) is a Rust crate implementing fixed-step and adaptive-step solvers and designed especially for modeling physical systems. Seven explicit ordinary differential equation (ODE)…
-
copilot-rs
SDK for interacting with chat models, providing easy-to-use functions and tools
-
ptrplus
Additional funtionality for pointer types
-
look_inside
Look inside structs, enums, and unions!
-
cdumay_error_base64
base64 error
-
object-id
Unique object ID with no generation
-
equationx
parsing and evaluating simple mathematical expressions/equations
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
bestbefore
A procedural macro for marking code with expiration dates
-
sbse
skylar's simple errors
-
is_empty
Easily check if the struct is empty
-
serde-textual
derive Display/FromStr by using serde
-
rustrix
Supports macro and basic operations for matrix
-
failchain
Ergonomic companion library for failure
-
tupl
Perform generic operations on tuples
-
enum_variant_macros
Macros to generate From & TryFrom for enums
-
ara_parser
A fault-tolerant, recursive-descent parser for Ara Programming Language 🌲
-
enum-rotate
Rotate and iterate your enums
-
smallint
optimized arbitrary precision integers
-
plrust-trusted-pgx
Minimal set of
pgxrexports for plrust, which the authors have deemed trusted -
phantom-enum
macro library for creating phantom enums
-
iter_ref
Traits for iterating over referenced data without consuming the iterator
-
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
-
ptrscan
Pointer chain scanner
-
subprocess-test
Convenience macro for creating tests which run in child process
-
ctjs
compile time javascript as a rust proc macro
-
todo_using
A super small crate only exporting a single macro to "use" parameters
-
hashed-type-def
hash based type identifier: hash code is computed on the basis of type definition
-
log_limit
A rate limiting logging crate
-
simplicio
Gets rid of the boilerplate in rust
-
tracel
SDK
-
ngram_iter
An iterator of arbitrary N-grams of rust Copy types
-
cowlang
Python-like scripting language
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
redox_simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
check-ends-macro
A couple of macros to simulate match with starts and ends of a string
-
read-restrict
Restrict the number of bytes read from a reader
-
ratpack
HTTP framework designed around simplicity and ease-of-use
-
splop
Helper functions to determine the first/last repetition of something
-
spire_enum_macros
Procedural macros distributed by the crate
spire_enum -
edisp
Dispatch-on-collect for Rust enums
-
oxyroot
attempt to make library reading and writing of
.rootbinary files which are commonly used in particle physics -
peak-result
trait that extends the standard Result enum to allow you to run some code in case of error or success
-
actix-web-error
Derive ResponseError for your errors
-
valued
Describe your data in terms of basic data structures. Get serialization and other facilities for free
-
string-eyre
Convenience traits for dealing with errors that don't want to eyre
-
wrapping_macros
A macro for wrapping arithmetic
-
valq
macros for querying and extracting value from structured data by JavaScript-like syntax
-
urid
idiomatic URID support
-
os-query-builder-rs
Open Search query builder
-
derive-adhoc
An ergonomic way to write derive() macros
-
sha2-derive
exporting a derivable
Hashabletrait that works withsha2 -
jsi
Write React Native JSI modules in Rust
-
rust_kafka_like
A Kafka-like message broker in Rust
-
simple-undo
Easy to use undo-redo library
-
iterator-ext
An extension to Rust's Iterator
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
anyhow_ext
Extension of anynow
-
for-loop-iterator
Iterators like traditional for loops
-
struct_scheme
structure scheme display
-
sod-mpsc
Service Oriented Design - Multi Producer Single Consumer
-
cron_macro
cron macro
-
messages
Runtime-agnostic actor library
-
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…
-
rustler
Safe Rust wrappers for creating Erlang NIF functions
-
doc-image-embed
Embed images in Rust documentation
-
any-fn
Dynamically-typed functions to represent any functions in Rust
-
dmx-struct
A struct that holds a DMX Addresse with parsing capabilities
-
cbsk_mut_data
ref mut tool
-
dbg_mac
Handy debug only macros
-
function_string_builder
A string builder that takes a user-provided function
-
enum-extract-error
A companion crate for
enum-extractthat exports an error type -
match_opt
A macro for turning a partial match into a full match returning an option
-
oc-hook-macros
Some convenient macros for hooking Objective-C functions
-
enum-derive-2018
macros for deriving additional functionality for enums
-
print_typewriter
easy way to print strings on character at a time
-
input-macro
No-nonsense input!(...) macro for Rust
-
atomic_non_null
An atomic wrapper around NonNull
-
hazmat
A collection of helpers for working with hazardous materials in Rust crates
-
leptos_datatable
A leptos component for creating tables with data validation
-
spanned_error_message
Pretty error messages with spans outside of proc macros
-
slice_map
A generic container to store a single type of data into unevenly sized slices
-
combine_traits
A Macro to create Traits wich are just a combination of existing ones
-
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…
-
cell-project
Safe interface for cell projection
-
macro_clap
Command-line argument parsing to its simplest
-
build-env
Extract information about the build process from the environment
-
option-like
Create your own Option-like enum
-
rust-enum-derive
(and program) for generating rust enums and associated traits from text files
-
eager
macro expansion
-
stylish-core
The semver-stable subset of
stylish -
boost-rs
boosting your develop productivity on Rust
-
size-trait
Traits for restricting the size of type parameters
-
iter_accumulate
An iterator adaptor that accumulates the elements and yields the current accumulated value for each iteration
-
xstd
eXtended STandarD library
-
gesha-macros
Macors for Gesha proejct
-
fieldfilter
trait that lets you filter stuff!
-
kathy
Const-evaluated swift-style keypaths
-
windows_quote
Code gen support for the windows crate
-
num_string
perform conversion between string and number
-
srce
Self-Ref Cell Environments
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
esvc-traits
Traits for ESVC
-
kti_cqrs_provider_rs
CQRS provider with ioc container
-
typesets
Enables generating subtypes and supertypes of a given type via derive macros
-
poolite
A lite threadpool library
-
tailwag_macro_inline
The logic for A collection of macros to support the tailwag crate
-
md_match
A macro to support md-match syntax
-
liftor
Functors for Rust lifetimes
-
specializer
Safe specialization on stable Rust with builder-like pattern
-
comparator
A Java-like Comparator type
-
uiio
stdio protocol for debugging
-
conventus
Traits for assembling and disassembling items
-
lyneate
beautiful code underlining and error reporting
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
as-result
Traits for converting types which may be interpreted as or into a result
-
kommons_macros
a set of macros with utils
-
teloc
compile-time DI framework for Rust
-
persian_str_rs
functions for working with Persian strings in Rust
-
boundnum
Bounded number type
-
en
The easiest numeric traits!
-
cronjob
scheduling your methods
-
filestructure-rs
sloppily create a filestructure in memory and write it to disk
-
okk
approach to replacing the
Ok(()) -
crossdylib
Cross-platform shared state across shared libraries/modules
-
libmw
constructing a pipeline of middleware functions
-
for_each_repeat
Iterator::for_eachthat can repeat current iteration -
pattern_code
Given a path patterm matched source code
-
oso
open source policy engine for authorization that’s embedded in your application
-
i-codegen-code
Common tools supporting the
derive-codegencrate -
rayon-par-bridge
Process Rayon parallel processing with a traditional sequential Iterator
-
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
materially
A macro for material implication
-
match_to_str
match pattern to str
-
lock-free-freelist
A fast lock free limited length free list for multiple producer and consumer
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
detalib
Rust bindings for the Deta Base and Drive HTTP API
-
from_variant
Automatically derive From impls for enums
-
handlevec
Small abstraction over index-style iteration over a vector, with deletion, insertion, and other operations on the vector while iterating
-
dto_derive
Derive for automatic mapping DTOs to Entities and vice versa
-
io-read-line-prototype
Prototype for io::read_line
-
actify
An intutive actor model with minimal boilerplate
-
const-type-layout
Derivable const trait to view and compare the layout of a struct, union, or enum
-
rustkell
haskell like functions in rust
-
derive-ctor
Adds
#[derive(ctor)]which allows for the auto-generation of struct, enum, and union constructors -
swamp-script-error-report
Swamp script error report
-
krenz
collection of my frequently used functions and macros
-
base1112031
way to represent numbers using all Unicode characters except ASCII control characters
-
bytify
macro that can write given const-expr values into a continuous byte array
-
concat_strs
Macro for quickly building a String from components
-
catalyser
A comprehensive collection of extensions to simplify and enhane rust development
-
async-select
select!multiplex asynchronous futures simultaneously -
debug2
Space Efficient Pretty Printer
-
strum-lite
Lightweight declarative macro for sets of strings
-
breakable-block
A shim library for a stable implementation of what is proposed in RFC 2046
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
urlqstring
A URL query string for rust
-
vnum
Create enums with a constant value associated to every variant
-
ctor-lite
Run code at program startup or shutdown
-
rustc-ap-syntax_pos
Automatically published version of the package
syntax_posin the rust-lang/rust repository from commit 625375400cdd172877e81c3ce44ce68f2011af2d The publishing script for this crate lives at: https://github… -
html5ever_macros
High-performance browser-grade HTML5 parser − compiler plugins
-
panicking
std::thread::panickinganalog available in theno_stdcontext -
lisbeth-error
Span handling, error generation and reporting crate
-
curmacro
usefull macros like struct getters and setters creation macros
-
targets
Some helpers to get you started with declarative programming in Rust
-
helper
provided some useful proc macros for Rust
-
unwind_safe
Readable unwind-safe code thanks to a try-finally-looking builder pattern
-
ghost-lite
custom PhantomData types
-
enum_to_enum
Derives possibly effectful conversions between enums
-
xdc
eXperimental Dynamic Casting - support library
-
libpy
imports functions from the python standard library
-
retryable
Automatic function retry macro
-
ftkit
A small set of utilities for newcomers learning Rust
-
label
functions and iterate over them
-
json_extract
This macro reduces boilerplate when using serde_json::Value variants when trying to get into a nested property
-
private-gemm-x86
x86 matmul impl
-
esync
This package contains some useful synchronization primitives
-
borked
convienient error handling library for rust
-
inline-const
Inline consts implemented as a macro
-
cgp-core
Context-generic programming core traits
-
structre
Static-checked parsing of regexes into structs
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
ctrl_macros
Control flow macros for Option and Result
-
noticeable
lazy observables
-
mat-rs
no_std implementation of mathematical matrix types
-
fast-rustc-ap-rustc_errors
Automatically published version of the package
rustc_errorsin the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
intercom
writing COM visible Rust components
-
lewp-css
Domain model for CSS Stylesheets. Allowing effective minification and transformations such as autoprefixing and removal by other crates. Updated and maintained version for lewp.
-
discard-while
Get the first non-matching element, and the amount of discarded elements
-
ndless-static-vars
storing static, program-wide parameters for Ndless
-
scope-guard
RAII scope guard
-
iterator-endiate
Extension method for (exact size) iterators which yields tuple containing whether item is last in iterator
-
infix_macro
macro that generates the neccesary boilerplate to use "*operator*" infix functions
-
algebloat_macros
RustAlgebloat utility macros
-
cart_prod
Cartesian product of iterators
-
ioc
An Inversion-of-Control library in Rust
-
type-registry
Static type registration
-
mdo
Monadic do notation for rust using macro and duck typing
-
error-chain-mini
error-chain for minimalist
-
xkcd_unreachable
macro xkcd_unreachable!() inspired by https://xkcd.com/2200/
-
rustructure
Run-time introspection on compile-time flagged structures
-
axum-ctx
Error handling in Axum inspired by anyhow
-
flat_vec
macro to flatten nested Vecs. Particularly useful when you want to write a rules of egg which contains rules both => and <=>.
-
qol
Quality Of Life functions and macros
-
enum-code
derive(Code) simplifies error handling by providing an easy-to-use enumeration of error codes
-
escher
Self-referencial structs using the async/await transformation
-
cargo-toml-macros
Convinient macros for pulling fields from your Cargo.toml. Prettier than std::env
-
closure
A macro for capturing variables on a per variable basis
-
unwind-unsafe
Zero-sized marker types which do not implement UnwindSafe or RefUnwindSafe
-
jmdict-enums
Autogenerated enums for the jmdict crate. Do not import directly.
-
try_buf
no-panic API for bytes::Buf
-
kind-derive
Derive generator the kind compiler
-
supply-chain-trust-crate-000022
Single assignment cells and lazy values
-
unwrap_let
macro for quickly unwrapping a refutable pattern
-
arcref
For when you need a pointer and don't care if it's &'static T or Arc<T>
-
read_buffer
ReadBuffer, a wrapper to safely read into a buffer from a Read
-
rerast_macros
Macros for use in Rerast rules
-
fatal-error
Differentiate errors and fatal errors
-
bit
helpers to manipulate bits and bit ranges
-
ara_reporting
A Reporting library for for Ara Programming Language 📃
-
envsafe
safely combine dotenv files with existing environment
-
brado
brazilian docs validator
-
singleton-trait
Singleton trait for types with unique values and Erased type for zero-sized ownership proofs
-
fastperm
A dead-simple, extreme fast permission flag system for Rust with no dependencies
-
list_comprehension
A macro for Haskell-like list comprehensions in Rust
-
ordered_iter
Ordered iterators
-
docima
Generate images at build time & embed them in the Rust documentation
-
pipeliner
nice interface for parallel programming with iterators
-
poetic
parse and interpret poetic source code
-
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…
-
int-to-c-enum
TryFromInt - A convenient derive macro for converting an integer to an enum
-
strongly
A proc macro to create strongly-typed primitives
-
repr-trait
Traits to represent Rust reprs
-
kaboom
Intuitive library for Next-Gen application exiting
-
fractran_macros
A compiler plugin that converts Fractran code into Rust at compile time, letting your Fractran programs be optimised by LLVM to super-fast native code
-
extract-variant
Destructure expressions into, and return assignments from, a single pattern
-
big_mac
A metamacro toolkit for writing complex macros
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
globiter
Replace with description
-
slip
A hassle-free utility to encrypt error handling strings in your public binaries to protect your business logic
-
tuplify
Generic hlist/tuple library
-
pfn
Provide fn_trait’s
call,call_mut, andcall_onceon Stable Rust -
mcurry
Macros for creating curried functions
-
macon_api
builder macro-based generator with its own idioms
-
splitbits
Concise bit field extraction
-
citadel
-
platform-cast
Platform-specific safe cast
-
ouroboros_examples
Examples for the ouroboros crate
-
dogma
Named,MaybeNamed,Labeled,MaybeLabeled,Collection, andCollectionMuttraits -
bittorrent-primitives
collections of basic types for BitTorrent projects
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
trait-union
Stack-allocated trait objects
-
raise
yeet!all the things -
crosstrait
Cast from
dyn Anyto other trait objects, with no_std, no alloc support -
oxidd-core
Core traits and types of the OxiDD decision diagram framework
-
dependent_ghost
Matt Noonan's 'Ghosts of Departed Proofs'
-
oneline-eyre
A fork of
simple-eyrewhich outputs errors on a single line -
mini-macro-magic
Export tokens to other modules and crates. Now with 100% less proc macros!
-
iter_from_fn
Create iterator from repeatedly aplying a function that takes no parameters
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
noders
NodeJS-like event loop environment for Rust
-
impl-converter-helper
declarative macro library to help you implement the
FromorTryFromtrait for your type -
easy_switch
A macro for traditional C-style switch statements
-
rusty-hkt
Higher-kinded types for Rust
-
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
test_help-rs
Test helpers for Rust
-
bump-into
a no_std bump allocator sourcing space from a user-provided slice
-
copy_impl
Macro for effortlessly duplicating impl block code across various types in Rust
-
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
-
classes
Dependency-free macro that simplifies the process of building class strings for DOM elements
-
vec-string
To print Vec<Display>
-
axum-typed-routing
Typed routing macros for axum
-
simple_scan
Iterator extensions for simple scan operation
-
anony
Anonymous struct
-
anyhow-loc
anyhow with location
-
atruct
macros for anonymous structs in Rust
-
rs_osrm_serde
rust wrapper for osrm, folk from TehGoat/rs_osrm
-
rusty-typesh
A flexible type pattern matching system for Rust
-
transmute_guard
Transmute between types that have been marked as safe by the marker type
-
shared-expiry-get
concurrent async get with expiration for Rust
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
scalar_map
mapfor scalar types -
derive_struct_fields
way to work with struct fields programmatically
-
futures-macro-await-preview
Definition of the
await!macro for thefuturescrate -
radiation
Convert Rust type into raw bytes and vice versa
-
into-static
Upgrading to static lifetimes
-
finte
convert between integer and Rust enum
-
swamp-semantic
semantic types for swamp
-
rollercoaster
Extra iterators for grouping, sorting, arithmetic, and more
-
fullypeek
Peek forward in an iterator as far as you'd like, memory allowing!
-
magic_static
Global singletons initialized at program start, an alternative to lazy initialization
-
class-rs
Reads/writes a .class file into/from an almost 1-to-1 matching struct
-
custom-format
Custom formatting for Rust
-
drop-bin
Defer running expensive destructors until later
-
match_any
declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
common_regex_rs
Set of common regex for Rust
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
checked-float
making invariant-enforcing floating point wrappers
-
io-ensure
Prototype of the
std::io::ensurefamily of macros -
trait-alias-macro
Trait Bound Alias using Macros
-
zkp-error-utils
Assertion like macros for returning
Result::Err -
seestr
pointer-wide nul-terminated strings with ownership semantics
-
dom_renderer
rendering html (or other DOMs) strings
-
switch_statement
switch statement macro
-
core_float
based on the Rust Core Library and aims to provide an identical set of APIs for f32 and f64 floating-point types
-
fallible_map
fallible mapping over
Optionand iterators using functions that can returnResults -
description
like Display, but 'static
-
std_nightly_to_stable_3db085279c83
-
log_err
Log error messages from Unwrap and Expect with log crate
-
scanfmt
easy to use macro for parsing a string
-
py-comp
A macro implementing a Python-like generator expression
-
known-types
Well-known types
-
extrust
intended as an extension of the standard library
-
signrel
Trait expressing relationship between integers of different signedness
-
quantified
Specify the universe: None, Some, Excluding, and All
-
pending_unwind
converting unwindings into
pending -
macroquest
Write MacroQuest plugins in Rust
-
mail-headers
[mail/headers] header parts for the mail crate (inkl. header map and standard header impl)
-
stuff
Stuffing things into pointers
-
cardseed
Pseudo-random numbers derived from playing cards using PBKDF2
-
traverse
Proof-of-concept trait for internal iterators called traversals
-
io-arrays
Random-access I/O
-
htmxpress
Procedural macros for generating htmx strings
-
vm6502
A 6502 virtual machine backend
-
bon-cli
Dev tool for working with the
boncrate -
bitmatch
A macro to allow matching, binding, and packing the individual bits of integers
-
lignin-schema
An HTML schema interface through which lignin Node trees can be created with efficient compile-time checking
-
tao-of-rust
《Rust编程之道》随书源码
-
std_prelude
prelude that the rust stdlib should have always had
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
diva
Opinionated convenience wrappers for
std::process::Commandand friends -
multiline-str
multiline string Rust macro, which allows you to write multiline strings in a more readable way. It allows for any combination of space-joined and newline-joined strings.
-
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.
-
trait-set
Support for trait alias feature on stable Rust
-
rsb_derive
An opinionated macro implementation for Rust struct builder pattern with compile-time validation
-
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…
-
tuple_utils
A set of utilities to enable higher level operations over tuples
-
typify-impl
typify backend implementation
-
intfloat
Fast and simple hashable float alternative using ints
-
apply_conditionally
Chain and apply methods on objects conditionally
-
ambient-authority
Ambient Authority
-
error_log
struct-based Error-Handling
-
typed_macros
Adds typing to your macro's arguments, making it a lot less of a pain to deal with them
-
httpwg-macros
Macros to allow generating httpwg unit tests
-
collar
easy array collection
-
lambda-types
Puts the lambda calculus in Rust...'s type system
-
smartcow
a cow for smartstrings
-
genz
Uniqueness of types via invariant lifetimes
-
modular
arithmetic in rust
-
linreg
Calculates linear regresssions of two-dimensional data. Does not use stdlib, only depends on numeric traits.
-
byteorder_slice
Byteorder like crate for &[u8]
-
rewind
Strong exception guarentee support types
-
random-trait
random trait meant to produce random generic types
-
loop-let
An immutable loop structure that can be used as an expression
-
phantomdrop
Go-like deferring of function calls
-
rs-flow
Create flows to execute based in components created and yours connections
-
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
ocaml-interop-dune-builder
A helper crate for ocaml-interop build scripts to build OCaml code using Dune
-
const_power_of_two
working with constant generics that are powers of two
-
dry-mods
Macros to make your module management DRY
-
exun
Handle unexpected errors
-
erdp
display an error and its nested errors
-
gilder
Golden testing library
-
stump
Simplified command line logging
-
new_flattened
Macro to flatten nested calls of
news -
zkp-criterion-utils
Criterion helpers to benchmark over size and number of processors
-
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
-
rexpr
Rust Json Object access Runtime
-
formy
derive macro to turn structs into html forms
-
detach
helper type for being able to detach/reatach a member item
-
await_macros
Macros that expand to
(expr).await -
analisar
A Lua parser for Rust
-
dev_bestia_string_utils
string manipulation
-
eso
Type machinery to build Cow-like containers
-
itermap
Iterator tools for maps (
HashMap,BTreeMap, etc.) -
iota-rs
macro for other Go refuges who miss const blocks and iota
-
builder-pattern
A derivable macro for declaring a builder pattern
-
buffed
Traits & implementation of parsing buffered IO
-
rustils
Utilities for rust
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
sync_stream
Aggregate multiple streams by polling stream items in order, keeping the consumption of multiple streams in sync
-
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:…
-
ts-type
types for working with TypeScript type representations in Rust
-
telocs
compile-time DI framework for Rust
-
twurst-error
Twirp error struct
-
error_hook
error hook
-
lgio
Lightweight, generic, no_std IO
-
fallback-if
Fall back to an alternative given some predicate
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
galvan
A higher-level programming language that transpiles to Rust
-
package_info
exposing Cargo Package Information to Rust code
-
custom_derive
(Note: superseded by
macro-attr) This crate provides a macro that enables the use of custom derive attributes -
jsonrpc-test
test framework for JSON-RPC
-
funkjon
One of the worst macros this world has ever been (dis)graced with
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
enum_primitive
Macro to generate num::FromPrimitive instances for enum that works in Rust 1.0
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
strflags
A string-enum and string-flags with fixed variants that can also accept arbitrary data
-
tensor-macros
A compile time optimised tensor library
-
sylt-machine
VM for running programs in the Sylt programming language
-
rstgen
Even simpler code generation for Rust
-
errify
Function error context provider
-
borrow_channel
A channel for borrows
-
pflow-metamodel
Declarative Petri-nets using a rust DSL
-
fat_type
A type which permits thin references to arrays and dynamic types
-
the-newtype
The Newtype trait
-
doxed
making Rust doc strings available at runtime
-
slice-copy
Go style copying for slices
-
tracing-assert-macros
A macro for capturing trace logs
-
iter-n
functions returning impl Iterator to return one of several distinct types
-
flow_impl
Definition of an Implementation trait for flow functions, and a derive macro
-
loop_chain
Macro for writing nested Loop expressions
-
validus
A string validation library
-
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
standard_test
A set of tests checking the properties of your impls of std traits
-
mint
Math interoperability standard types
-
bitrange
plugin to map bits in integer values to fields
-
warrant
A Swift-guard-like macro for Rust
-
unwrap-enum
generate methods to access enum variants
-
rombok
boilerplate generation macros like lombok
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
rustollens
A small and experimental library with a type-level representation of booleans with companion connectives for compile-time sort-of fun with logic
-
vk_method
Standart of VK Method
-
zkp-logging-allocator
Wrapper around the system allocator that logs large allocations
-
transaction
abstraction library (a.k.a. transaction monad)
-
foreign-types-shared
An internal crate used by foreign-types
-
cyclic_data_types
Cyclic data types are series of structs, enums, types and functions to create a series of fast data types
-
floretta
Automatic differentiation for WebAssembly
-
generator_extensions
Basic extensions to Generator types to bring parity with Iterators
-
cex
Checked exception simulation
-
shoogah
Add some syntactic 'shoogah' to Rust
-
zerogc-context
Handles the context of a zerogc collector
-
dyngo
Type-safe dynamic (type-erased) generic outparams
-
extensor
the main extensor crate for building arbitrary valent tensors and more
-
multindex
Index slices with multiple const indices/ranges
-
then
bool::then functions but named properly
-
fix_me
A very simple macro that lets you write temporary code that WILL NOT build in release mode
-
bitty_write_macro
A drop-in
write!replacement that optimizes non-formatting writes for code size -
backyard-nodes
Nodes representing PHP code AST
-
packetize
encode and decode your packet with stream channel
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
packer
Pack static files into your binary at compile time
-
context-rs
Pass values down the async call stack, with no_std and no_alloc support
-
surprise-me
Derive macro to generate random type instances
-
type-census
Track the number of extant instances of your types
-
veccell
variant of Vec with interior mutability
-
apply_attr
A syntax extension providing higher-order attributes to Rust
-
thiserror_core2
derive(Error) (no_std-enabled using core2)
-
lifted
Higher-kinded types in Rust
-
aranya-trouble
A wrapper to implement the Error trait
-
enum-unit
Generates unit-variant enums from existing enums
-
statenum
enabling enums in state-pattern logic
-
directed
Evaluate programs based on Directed Acyclic Graphs
-
sod-bus
Service Oriented Design - Single Producer Multi Consumer
-
binjs_es6
ES6 component of the Binary AST reference implementation
-
source-chain
Formats StdError with it's source chain
-
vesta
Extensible pattern matching
-
tor-basic-utils
General helpers used by Tor
-
nested-ref
References to data contained in one or more nested RefCells
-
racros
Collection of rust macros
-
arbintrary
Proof of concept for arbitrary integer sizes using generic const
-
split-optional
It split from a source
strtoOption<&'a str>per an element -
iter2
Iterator
chaining,cmping and more as free functions taking twoIntoIterators -
swamp-script-ast
ast types for swamp script
-
iex
Idiomatic exceptions
-
with-api
macro for shrinking scope
-
rvs-c-api
C-API for Rvs - A library for defining and evaluating random variables using a simple DSL
-
consume_on_drop
A zero-cost abstraction that allows Drop::drop to consume self by value
-
captur
Macro to capture whole structs from disjoint fields in a closure
-
eliza_error
“Times are bad. Children no longer obey their parents, and everyone is writing an error handling library.” — Cicero
-
hatch_result
A result-like struct that returns on Ok, instead of on Err when ? operator is used
-
ironplc-dsl
Domain-specific language objects for IEC 61131 language elements
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
collections_macros
a collection of macros to make making collections easier
-
nb-from-env
A convenient way to construct structrual configuration from environment variables
-
call-once
A type that can only be called sucessfully once
-
cargo-manifest
Helper crate to parse and manipulate manifests -
Cargo.tomlfiles -
usize_cast
Compile time checked cast from and to
usize/isize -
tagname
get the name of a variant in your enum as a string
-
kwarg_macros
Keyword argument plugin
-
trait_enum
Easy enum wrapper that implements all traits that the wrapped objects implement
-
fracints_internals
Internal utilities for the
fracintssystem of crates -
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
derive_variants
derives an additional enum from a nested enum that contains only variants and no nested fields
-
datafusion-functions-table
Traits and types for logical plans and expressions for DataFusion query engine
-
ataraxy
Discord slash commands framework for Serenity
-
self-reference
Helper
-
transitive_from
Helper macros for creating hierarchies of transitive
Fromimplementations -
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
flarrow-message
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
macro-while-mut
Macro that allows create while-cycle with mutable condition state
-
xcsp3-rust
that help constraint programming solvers implemented by Rust to read XCSP3 files
-
superfusion
A general purpose project merger library
-
brain_rust
A BF transpiler to rust written as a rust declarative macro
-
generic-mutability
Allows the creation of APIs that are generic over mutability
-
x-bow
Precise State Management Library
-
powerfmt
powerfmtis a library that provides utilities for formatting values. This crate makes it significantly easier to support filling to a minimum width with alignment, avoid heap… -
taxi
Navigation library for Polyhorn
-
function-compose
lib to allow composition of sync and async rust functions
-
spawn_interval
Call a subroutine at a constant time interval
-
fb_cloned
Cloned macro
-
iter_peek_end
current element the last one of a peekable iterator ? (
is_last()andis_not_last()) -
derive-into
derive macro for easily creating conversions between structs and enums
-
awint_internals
Internal utilities for the
awintsystem of crates -
enum-to-types
Macro for generating pseudo-enums for type-level programming
-
string-builder
string builder type
-
throws
A macro for easy creation per-function errors
-
adrop
fast dedicated thread drop
-
funfun
Macros for working with closures
-
xylem
Building context-sensitive type conversion
-
ternop
A tiny macro that implements a ternary operator for Rust
-
introsort
Fast sorting compatible with #[no_std]. Also has (optional) support for efficient and robust sorting of floating point numbers. Currently, introsort only builds on nightly
-
user_stable_vtable
A partial implementation of [RFC 2955], written in stable rust
-
cmd-macro
makes std::process::Command simple to use
-
element-ptr
A macro to make accessing elements through raw pointers easier
-
macro-utils
Some macros to make code writing more elegant and funny
-
fast_async_trait
Fast async traits for Rust
-
tupleops
work with tuples
-
win-events
A poor attempt to implement WaitForMultipleObjects and the ManualReset, AutoReset and Pulse types
-
gavl
A fast implementation for a map and a set using an AVL tree
-
abi_stable_shared
detail of abi_stable
-
min-specialization
Experimental implementation of specialization
-
babygiant-alt-bn128
implementing a multi-threaded version of the baby-step giant-step algorithm on the Baby Jubjub curve (it is the curve whose base field is the scalar field of alt-bn-128 aka bn254) to decrypt u40 integers…
-
first_crate
dealing with vectors calculations more convenient
-
qed
Compile-time assertions
-
yui
An attribute reader generator for Rust
-
hex-serde-util
A helper crate for manipulating hex strings with serde
-
ser_raw
fast serializer
-
to_vec
convenient to_vec, to_set and to_map methods on iterators
-
modifier
Fluid chaining APIs for both mutable ownership types
-
arrays
Construct an array from an iterator
-
atomic_cell
Lock-free thread-safe mutable memory locations
-
cdumay_error
Streamlining Error Handling in Rust
-
orx-linked-list
A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations
-
extrude
A macro for unwrapping an enum value into an Option
-
project-uninit
Macros for safe references to and initialization of fields in MaybeUninit structs
-
turbostate
Finite State Machine
-
safe_unwrap
allows unwrapping and annotating that the unwrap will never fail. Does not require
std. -
incrstruct
Build self-referencing structs using two-phase initialization
-
hexga_tools
miscellaneous stuff, when somethings will be too big it will be on a separate crate
-
hexga_bitflags
Bitflags utilities
-
iterify
Turn any type into an iterator with closures!
-
shallowclone
Traits for working with copy-on-write types more efficiently
-
noneifempty
Convert T to None if empty
-
alternator
Tools for building effect system -like functionality by abusing async
-
roopert_macro_common
object-oriented toolkit for Rust (common data)
-
env_init
Small crate to help initializing environment structs
-
spans
Split an iterator into contiguous spans
-
rustcomp
Adds vector, map, set, and iterator comprehensions to Rust
-
quick-error2
A macro which makes error types pleasant to write
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the *relative* difference
-
aspect-weave
An Aspect Toolkit for Rust
-
remit
Rust generators implemented through async/await syntax
-
polimorphism
Function overloading via a procedural macro
-
validator_types
Basic type for validator and validator_derive
-
spawn_timeout
Call a subroutine after a constant time interval
-
lens-rs
lens implemented in rust
-
memprint
A way to print memory layout of a struct
-
into_index
Helper traits allowing indexing into vectors and similar types by other types than
usize -
more_collection_macros
Adds new macros to rust for creating collections
-
kti_cqrs_rs
CQRS pattern in Rust
-
filters
Build filters/predicates with the builder pattern
-
static_assert_macro
so-called
static_assert -
anonymous-trait
Anonymous trait implementation with capturing the environment
-
xdi
Rust di containers system
-
cfg-or-panic
Replace function bodies with
unimplemented!()when condition is not met -
locate-error-core
Types and utilities for locate-error
-
swamp-types
types used in Swamp
-
rich-result
Rich result type differentiating between recoverable & fatal errors
-
negative
impls in stable Rust
-
affair
A Tokio-based worker abstraction layer
-
should_error
The test should fail with Err
-
size
expressing, formatting, and interacting with file sizes
-
components-arena-traits
Does not intend for direct use
-
try_ops
try catc... ops macro
-
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
-
wrapping-macro
wrapping macro
-
see-through
traits to provide access to internal fields of generic structs
-
select_indices
Iterators for taking multiple shared/exclusive references from a slice
-
displaythis
derive(Display)
-
tuple_split
An extension for the tupleops crate which adds a trait for splitting tuples
-
impl_ops
Macros for easy operator overloading
-
try-drop
Batteries included error handling mechanisms for drops which can fail
-
join_to_string
Join a list of items to string/buffer
-
det
Calculate the determinant using a macro
-
array_trait
A generic trait for any array, with item as type and length as const parameter
-
advance-iter
A small crate to help with "stepping through" iterators
-
destruct
structs and enums for simpler combinator implementation
-
tylar
Type-Level Arithmetic in Rust
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
cismute
Safely transmute type to itself in generic contexts
-
fuzzypath
Quick & dirty fuzzy path comparison
-
new_type
Experimental implementation of newtypes by type level logic
-
scope-exit
The util to call procedure when exit current scope. scope exit. like defer in go.
-
gamo
A Range like struct for user defined types
-
topdown-rs
A top-down parsing library
-
rudeboy
Rlua User Data Extension Boy - Derive/attr macros and traits for easily exporting user data to RLua
-
kmacros_shim
Useful macros
-
near-safe-cell
A more ergonomic 'UnsafeCell' wrapper/replacement
-
token-ref-cell
Interior mutability cell using an external token to synchronize accesses
-
swiss-army-knife
Common utility code to support linux-support and other projects
-
niceowner
A stupid library that allows you to own a value, even if it comes from a reference. No cloning.
-
maflow
Flow macros: basically unwrap for return, continue and break
-
hetseq
Defines traits and types to work with heterogenous sequences
-
mapro
A tiny macro library for creating std::collections
-
rustitude-core
create and operate models for particle physics amplitude analyses
-
mods
Simpler module declaration
-
cor_iter
Correlate of two iterators
-
podio
Additional trait for Read and Write to read and write Plain Old Data
-
humane_commands
Allows you to write more shell-like Commands
-
is-same
A trait for comparing object equality
-
typed-generational-arena
A safe arena allocator that supports deletion without suffering from the ABA problem by using generational indices. Now with typed indices and custom integer types for generations!
-
fieldx_plus
Design patterns built on top of fieldx crate
-
partial-borrow
Partially borrow a struct
-
statum-core
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
stackstack
A singly linked list intended to be chained along stack frames
-
hex-display
Display impl for byte slices which provides a hexdump
-
try-traits
Alternatives to std lib traits that can fail
-
cereal
data serialisation library
-
slist
Algebraic lists with statically determined size that live on stack
-
litto
Building blocks for DSL scripting language interpreters that interact with native Rust code
-
vec_vec
When dealing with
Vec<Vec<T>>is unavoidable -
nclosure
composable, nameable closure types with separated states and functionality for use in APIs where anonymous types are unavailable
-
strung
Easy access of struct fields in strings using different/custom pre/postfix: "Hello, {field}"
-
iter-flow
Functional programming utilities for Rust
-
const_str_slice_concat
const concatenation of string slices
-
units
Measure for Rust. Easy to use, type-safe and customizable.
-
hex-slice
Extends the std::fmt::*Hex traits to slices
-
endian_trait
A trait for Endianness conversions that can be implemented on most types
-
conditional-assignment
very simple, small crate to help make conditional assignments more ergonomic
-
enum_properties
A macro for declaring static properties on enum variants
-
uni_rc_lock
trait which may represent either Rc<RefCell<T>> or Arc<RwLock<T>>
-
user-panic
Error messages
-
interior_mutability_pointer
A wrapper around
Rc<RefCell<T>>allowing immediate access to inner methods -
take-static
Static items that provide mutable access only once
-
rs_state_machine
A business-oriented state machine library
-
fstrings-rust
Python3 fstring interpolation in Rust
-
version
A very simple library who's job is to return the version of your crate if you're building with Cargo
-
errer
Flexible error management for Rust. An middle-ground between failure and SNAFU
-
unreachable_checked
unreachable!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won't panic.
-
recursion-schemes
cache-aware stack safe recursion (this is the really haskell brained one)
-
inline_default
Macro for inline Default implementation
-
swahili-dsl
A Swahili-based DSL made for educational purposes
-
stringish
A smaller and easier copy-on-write string
-
proclock
cross-process locking API
-
enstream
Conversion from Future to Stream
-
viewbuilder
Cross-platform UI framework
-
uninitialized
Opt-in unsafe uninitialized memory
-
cute
A macro for Python-esque comprehensions
-
set_slice
A macro for assigning values to slices
-
fix_fn
Macro to create recursive closures (similar to the Y combinator)
-
take_mut
Take a T from a &mut T temporarily
-
macro-map
Closure-less
Result::map_errandOption::ok_or_else -
const_typed_builder
Compile-time type-checked builder derive using const generics
-
atomic_refcell_try
Threadsafe RefCell
-
iter-python
Python generator expressions and 'list' comprehensions
-
sod-tungstenite
Service Oriented Design - Tungstenite
-
smurf
SMall Useful Rust Functions
-
rustato-macros
Macros for the Rustato library
-
stable-pattern
Stable port of std::str::Pattern and friends
-
on_drop
on drop
-
partial-default
PartialDefault, a trait similar to Default but with fewer guarantees
-
define_into_enum
Defines Into<T> on an enum where all variants wrap T
-
composing
Tools to compose functions
-
okey
Everything is Result::Ok
-
steloc
compile-time DI framework for Rust
-
mago-syntax-core
core utilities useful for building lexers and parsers within Mago
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
rwtypes
Adds methods to read/write binary numbers to the Read and Write traits
-
const-assert
Assert struct for const generics
-
parameterized_test
A macro to support providing arguments to test functions
-
microparsec
parser combinator crate for Rust
-
brazier
A mediator implementation in Rust, heavily inspired by the .NET MediatR package (https://github.com/jbogard/MediatR)
-
let_clone
Declarative macro to clone multiple values at once
-
litenum
minimal convertion utilities between literal and enum
-
fb_stats_traits
Traits for stats crate
-
catch-unwind
Wrappers for catch_unwind that handle the edge case of the caught panic payload panicing
-
batch_oper
some batch operation macro for some operations
-
dyn_traits
Magically derive non-object-safe traits
-
scope-functions
Kotlin-inspired scope functions for use in almost any situation
-
iceyee_error
Error Message
-
ibmfloat
IBM floating point number types
-
any_ref
To capture and move things that are NOT 'static with memory safety
-
ref-map
Helper trait for Option and Result to map references
-
dirk_framework
Dependency Injection for Rust
-
ufcs
Helper trait to call free functions using method call syntax
-
rustbench
A lightweight Rust procedural macro for benchmarking function execution time
-
chain_linq
.NET's LINQ in rust as a declarative macro
-
slid
labeled IDs
-
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
-
storagevec
Feature-gated heap-based/stack-based map and vector structures
-
pigeon-core
Generate recursive-descent & precedence climbing parsers. (traits)
-
phtm
Re-exports for common uses of
PhantomData -
resp-protocol
REdis Serialization Protocol
-
loggy-neko
thread-safe logging tool with dynamic log level configuration
-
upget
Super simple trait that patterns the value "updae" and "get"
-
always_equal
A wrapper for types that can't implement Eq
-
enum-to-string-traits
EnumToStringderive macro which implements the methodsas_str()andas_dbg()to enums with no associated values -
bitflags-derive
bitflags-aware #[derive] macros
-
diatom-std-os
The diatom programming language
-
instancebuilder
Convenient way of managing dependency injection
-
constant
evaluation tools for Rust
-
have_len
container empty ? (
is_empty()andis_not_empty()) -
tuple-traits
Additional tuple traits to enable ergonomic types
-
greattraits
My own collection for traits extending standard library types
-
matrix_match
Macro to match on two values at the same time
-
option_macro
a convenience macro
-
fluent_builder
builder API
-
anyflux
Generic flux-like state management
-
newtype-enum
Traits to convert between enums and their variant types
-
alua
generating lua lsp annotations from Rust types
-
chainer
A cursed crate that allows for global call chaining with access to chained function results
-
assert-impl
Macro for static assert types implement a trait or not
-
contains
A Container trait
-
ast2str
pretty-printing ASTs and other recursive data structures
-
n-functor
Faux-derive a
mapfunction for types with one or more type parameters -
callable
closures implementing PartialEq and argument operations
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
fancy-ip
Fanciest way to initialize IP addresses
-
coe-rs
Type coercion
-
disown
Drop ownership via a method
-
trait-bound-typemap
create typemaps with additional trait restrictions and implementations
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
not-so-fast
data validation with derive macro
-
berusty
Me practicing Rust
-
event-observer
observer pattern by rust
-
beaver
setting up Rust objects inspired by factory_bot
-
interlink
Framework for writing async code
-
facet-poke
Build and alter arbitrary Facet types
-
lox_utils
General helpers used by Lox
-
pipette
Polymorphic function pipelines without traits or macros
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
type_hash
Generate a hash for a Rust type. The primary use-case for this crate is for detecting differences in message types between versions of a crate. The
TypeHashtrait is implemented… -
multiref
Multireferences: a safe way to do [&T] -> &[T]
-
box-macro
Literally just the macro
box_!which isBox::new -
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
lit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
ffh
ffh makes it easy to read and write files
-
stats_traits
Traits for collection-like types to calculate statistics
-
mod
project that provides two simple and useful utility functions for converting between Option and Result types
-
fourcc
Syntax extension to generate FourCCs (four-character code)
-
predicate
Use enum to predicate something, support & and | operator
-
dynamic-plugin
Write compile-time-checked, dynamically-loaded plugin libraries for your Rust software
-
zonbi
Type-Erase tools for non-
'statictypes -
rstring-builder
String builder type
-
pure_decimal
A decimal type with no NaN and Infinity
-
error-type
macro for constructing unifying error types
-
inline_newtype
newtype macro inspired by kotlin's inline class
-
dynamic-cast
The fifth pillar of OOP: dynamic casting
-
controlflow_inspect
inspect_* methods for ControlFlow
-
namedarg_rustc_macro
namedarg main package
-
transactional_iterator
Iterator that allows to commit or abort progress
-
buco
A compile-time builder pattern implementation for Rust
-
stable_borrow
A marker trait indicating that borrows are address-stable
-
structural-convert
Derive conversion traits (From, Into, TryFrom, TryInto) when fields are structurally similar in enums or structs
-
fn_name
Macros that produce the name of the function they're invoked within
-
scopefn
Scope functions for Rust
-
assert-type-eq
Macro to assert types across potentially different crate versions are compatible
-
once-option
OnceOptiontype, similar toOption, with the constraint that once emptied it cannot be re-set to contain a value. Useful for members that need to be consumed on drop or cannot be re-set otherwise (e… -
abort_on_panic
Intercept panic! from unsafe locations and abort the process
-
shrinkwraprs
Auto-derive for Rust conversion traits -- make working with newtypes a breeze
-
bogdan_hello_macro
adds the method hello_macro that generates a greeting based on the name of the struct
-
tt-call
Token tree calling convention
-
hexga_array
that impl trait / new functions for array
-
wrapped-list
Macro for wrapping elements of a list with an object, function, or another macro at compile time
-
bg
builder + generics
-
has_fields
Some macros helpful for processing forms with optional fields
-
strong
Strongly typed String
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
context-iterators
Iterators adaptors with associated read-only data
-
aggregate
attributes of structs for runtime
-
mathelogos
as a functional programming language
-
derive-alias
Alias multiple derives as one
-
peresil
simplistic string parsing library
-
containerof
Macros and traits facilitating the use of intrusive structures in Rust
-
integer_or_float
A data type holding an ‘integer or float’ (a data type in the Unified Font Object specification, among others)
-
random_stuff
A pile of random helpers, macros, extension traits… that I didn’t care to write a separate crate for. Probably nothing to do with
randcrate. -
swamp-ast
ast types for swamp
-
forwarding_gen
Syntax processing for emulating OOP Inheritance in Rust by forwarding trait methods
-
dynamic
A dyanmically typed value with fast downcasting
-
static-cond
Macro for performing comparisons during macro expansion
-
clone-spl-discriminator
Solana Program Library 8-Byte Discriminator Management
-
multiconst
destructures an expression into multiple constants
-
io-arc
Proof of concept Arc with IO trait delegation
-
respan
Macros to erase scope information from tokens
-
chonk
A lightweight parser combinator framework
-
attr_alias
Reduce attribute repetition with aliases
-
cfixed-string
Pass Rust strings to C with potentially not needing heap allocation
-
visita
Elegant implementation of the Visitor Pattern
-
drop_ok
.drop_oksyntax sugar forResult. It’s instead of.map(|_|()). -
introspectable
Basic introspection via the Introspectable trait
-
nstd-sys
Cross platform general purpose C library written in Rust
-
error
A fancy error type for highly generic cases
-
anyint
traits and structs for working with integers of any bit size
-
tap-trait
Inspect and mutate values without leaving the method chain
-
typedopts
Type aware command line parser
-
nan-tag
NaN-tagged pointers in Rust, storing an f64 in the same space as a pointer
-
nohash-hasher
std::hash::Hasherwhich does not hash at all -
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
plmap
Parallel pipelined map over iterators
-
vec_remove_if
Extract elements from a vector based on supplied criteria
-
wopt
A procedural macro that automatically generates an Option-wrapped version of a struct, reducing boilerplate for optional updates
-
rcrefcell
Wrapper type for Rc<RefCell<A>>
-
epui
Equisized (primitive) unsigned ints for primitive ints: u8 for u8, u16 for i16, etc
-
serde_gelf
Gelf serialization using serde
-
uutils_term_grid
formatting strings into a grid layout. Fork of term_grid.
-
bloc
A state management library
-
kaydle-primitives
Low level primitive parsers for KDL, intended as a building block for higher level parsers or deserializers
-
nix-compat-derive
Nix protocols and data formats
-
std-io-peek
Peek trait
-
struct-builder
Derive a builder for your structs
-
merge2
Merge structs into single by values
-
cargo-subcommand-metadata
Embed metadata into a Cargo subcommand, so that
cargo --listcan show a description of the subcommand -
borrown
Borrowed or owned, simplified for no-std
-
chained
lazily chaining functions
-
index_vec
Newtype-style helpers for
Vecandusize -
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
gluesql-derive
Derive traits for GlueSQL
-
error-context
Methods and types that help with adding additional context information to error types
-
endors
Validation library
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
rustica
functional programming library for the Rust language
-
simple-di
dependency injection for Rust
-
bos
Flexible Borrowed, Owned or Shared (B.O.S.) smart pointers. Like std's Cow but with Rc/Arc and without the ToOwned requirement
-
wdl-macros
Macros used within the
wdlcrate ecosystem -
string-newtype
New Type idiom helper for string-like types
-
frankencell
An alternative to
qcellandghost-cellthat instead uses const generics -
partial-result
results that return success for non-critical errors
-
erroneous
Minimalistic helper for using errors
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
whiskers-widgets
Dynamic UI sub-system for whiskers
-
strunemix
allows to build a struct with a form of its fields, by deriving enums of them
-
levitate
Just works solution to numbers, mainly aimed at floats and mathematical use cases
-
unwrap_goto
unwrap Option an Result or goto
return/cotinue/breakas you want -
maybe-owned-trait
Either an owned or borrowed value, with type known at compile time
-
optargs
Easily create macros for functions with optional arguments
-
map-to-const
Easily convert HashMap<K, V> to constant [(K, V); N] values
-
tany
Type-erased container with inline storage for small values
-
perhaps
Maybe monad implementation with a more intuitive name. Using Certain and Dubious instead of Just and Nothing
-
daml-macro
Helper macros for working with the Daml Ledger API
-
batbox-tuple-macros
Macro for calling your macro for all tuple sizes
-
better-as
Explicit type casting
-
lazy_thread_local
Lazily initialised per-object thread-local storage
-
svgmacro
Write any SVG easily from Rust!
-
borrowck_sacrifices
Necessary sacrifices to keep the Borrow Checker happy and developers sane
-
maparr
macro to build a static
Mapbased on const array -
printf-compat
printf reimplemented in Rust
-
negative-impl
Negative trait implementations on stable Rust
-
finite-state-machine
A type and trait based finite state machine macro
-
derive_environment
modifying structs via environment variables
-
arch-into
safe type conversions between pointer-sized types (usize/isize) and types with fixed size
-
macron
Comprehensive Rust macros toolkit for everyday development tasks. Includes convenient string formatting (str!), regex pattern matching (re!), streamlined collection creation, and custom derive macros for Display…
-
merg
Merge multiple values into one
-
tuple_tricks
A couple of traits on tuples that allow inductively building new traits
-
html5ever-atoms
Static strings for html5ever
-
ghosts
Type-check non-existing
Phantomcode for Fun And Profit™ -
maybe_null
A pointer type for handling potentially null values without accidental dereference
-
ownit
Easily turn borrowed type into owned values
-
orion-exchange
exchange data struct
-
tagged-pointer-as-enum
A set of structs, traits and macros to implement tagged pointers
-
mail-headers-ng
[mail/headers] header parts for the mail crate (inkl. header map and standard header impl)
-
iso3166-1
ISO 3166-1 data
-
cisness
Runtime 'live witness' of two types being the same
-
polymorph
A set of utilities to better enable polymorphic behavior in Rust
-
take-if
A tiny utility for conditionally taking the contents of an option
-
typesafe-builders
Infallible compile-time checked builders for your structs
-
cassandra_macro
Create Cassandra tables and CRUD CQL prepared statements from Rust structs. (custom derive: cassandra_macro_derive)
-
cursor
A more free Rust-Iterator
-
trace-error
Extensions to Rust's error system to automatically include backtraces
-
zconvertenumn
Convert number to enum
-
option_into_controlflow
Option into ControlFlow conversion
-
field-projection
Field projection experiment
-
expression_format
format Rust expressions in a string, similar to f-string formatting in Python
-
compost
Adds a macro to decompose tuples into tuples containing a subset of their values
-
intuple
Convert structs and enums into tuples (of refs) and back - recursive, ignore fields
-
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
chain_tools
A set of traits allowing for more a erganomic style of chain programming
-
rubber_duck
Enables building functions that can be called with named arg syntax
-
macroland
macro shorthands of various types in Rust
-
lifelink
Erase covariant lifetime parameters from anything, with generic associated types
-
array_init_macro
initialization macro for arrays
-
bevy_cell
Attach Bevy's Handles/Entities statically to Types
-
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
-
read-primitives
traits to read primitive types from any type that implements std::io::Read
-
count-tts-inner
macro for counting any position tokens
-
unibox
Universal Box that can store any type using static or dynamic memory
-
dupit
copy or clone a value
-
duplex
trait: interactive streams
-
lang_extension
Rust Lang Extension
-
qwutils
some utilities
-
scones
Generates simple constructors for structs
-
declarative_type_state
A collection of declarative macros to reduce boilerplate code when implementing type-state patterns
-
arr_ty
Macros for smart array initialization (best for trait object element types)
-
ferric_parser
The Parser and currently the code gen for the ferric group of languages
-
clonesure
A helper macro to create closures which will clone its environment
-
doless
macro to simplify struct mapping and function utilities
-
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
-
anysafe
any safe
-
bounded_types
type representing bounded integers, implemented using const generics
-
arraytools
A variety of helpful methods for working with fixed-size arrays
-
struct2vec
Rust structure to slice
-
total_float_wrap
Floating point wrapper implementing Hash and Ord according to IEEE 754 totalOrd
-
with-thread-local
A micro crate that simplifies a bit the use of the std macro
thread_local! -
drop_some
.drop_somesyntax sugar forOption. It’s instead of.map(|_|()). -
collect-all
vec! for everything: easily make literals of any collection!
-
tuple_length
determining the length of a tuple
-
checked_array
A checked API for array types
-
iter_mod
A macro for enumerating all the constants in a module
-
another_pipe_macro
Adds a macro for composing functions
-
loopcell
cell for multiple routes of access that are only used one-at-a-time in sequence
-
usage
A convenient alternative to the newtype pattern
-
static-cow
Cowat the type level: a framework of traits for writing types that are generic over ownership of their contents -
keepops
Extension traits for keeping the input of mapping functions
-
vet
Arbitrary type validation
-
sc2-macro
Procedural macros for rust-sc2 API
-
archery
Abstract over the atomicity of reference-counting pointers
-
irox-enums
Traits for better Enumerated Types
-
roxygen
Seamlessly document function parameters with rustdoc
-
tearor
Easily turn data races into data corruption!
-
typed_key
Strongly-typed string keys for configuration
-
type-sets
Sets implemented in the rust type-system
-
as_base
Cast trait objects to some base class
-
identifiers
working with rust identifiers and keywords
-
deferrer
defer! macro for deferring functions
-
macro-dep-test
testing version resolution for associated macros
-
int_ranges
ranges tools for integer
-
stringlit
A macro to convert from str to String
-
rusty-value
Create a generic inspectable value from any rust type
-
kv-derive
Derive struct conversions from and to key-value vectors
-
smart
dynamically-dispatched smart pointers
-
rvs-parser
Parser for Rvs - A library for defining and evaluating random variables using a simple DSL
-
rustility
A collection of utilities I often find myself using in Rust
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
pages
A dynamically-sized heap-backed data page. Comprises a user-chosen header and data array packed into a single allocation.
-
damock
Derivable data mocking for tests
-
mut_family
A GAT-based library for writing code that is generic over exterior/interior mutability and mutability of references
-
html_stack
A stack based dsl for writing html. This is not an html template!
-
thin_delegate
Auto implementation of trivial delegation to inner types
-
json-keypath-iter
Iterator for traversing serde json objects, yielding a flattened path and value of each element
-
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…
-
zc_io
zero-copy I/O
-
constany_blank
Convert any function to constant
-
cs-utils
Common utilities
-
oneshot-fused-workaround
Fused wrapper for futures::channel::oneshot
-
into_inner
IntoInner trait for Rust newtypes
-
telecomande
A small crate providing a primitive for the execution of asynchronous tasks by processor through commands
-
disuse
The way to notify the implementation which return value is disuse
-
aligned_ptr
Wrappers of functions defined in core::ptr and core::slice modules with alignment and null checks
-
tyfling
todo
-
destruct-lib
Destruct structs and enums for simpler combinator implementation
-
open-ambient
Open files and directories with constant paths
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
bstringify
stringify! that yields byte string literals instead
-
const_type
define enum-like const-types, but with aliases for variants
-
derive_screaming_snake_case
A lightweight Rust proc-macro crate that implements the Display trait for enums with unit variants by converting each variant's name into SCREAMING_SNAKE_CASE
-
displaydoc-lite
Implement the Display trait using your standard doc comments
-
bulwark
Panic-aware scope guards
-
errling
A collection of intrinsically useful errors
-
value_unit
every unit imaginable. Also contains a handy macro
-
unsaferef
An unsafe reference without explicit lifetime
-
type_utilities
Implementing more methods to rust type primitives
-
nagios-range
types to parse and operate on Nagios ranges
-
explicit_cast
explicit widening, truncating, and sign casting of primitive integers
-
try-iterator
Adds a few fallible methods to iterators
-
cmd_error
print an error message and exit while unwrapping Options and Results
-
dyn_struct2
Construct dynamically sized types safely. Supports arbitrary unsized types, not just slices
-
fstrings
Python3 fstring interpolation in Rust
-
type-factory
unique opaque types
-
assert_into
For when writing .try_into().unwrap() feels too long
-
shared_error
SharedError wrapper for cloneable Error
-
guest_cell
Storage space for externally-owned private data
-
static-include-bytes
Like the built-in
include_bytes!macro but produces a static array definition -
jsonbuilder
A json builder used to create JSON structures using a simple DSL
-
const-anonymous-functions
macro to create const anonymous functions
-
struct2map
Procedural macro library for converting between Rust structs and associative containers
-
nes
New Error System for rust
-
irox-structs
Traits for Struct Types - linearly serialized big/little endian bytes
-
default_macro
My default!() macro
-
display_container
implement Display
-
error-macro
error macro
-
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
pipe-chain
Combinators & parser library
-
arraylib
Tools for working with arrays
-
amass
Automatically generate
Fromimpls for nested enums, even across crates -
io-cast
a high-level io function similar to Python's input function
-
ocm
Outcome type for a value and its errors
-
temporary_enum_delegate_0_3_0
trait delegation functionality for enums and structs
-
simplerror
A zero-dep macro to declaratively define error enum types and their common trait implementations
-
trait-gen
Trait implementation generator macro
-
fdb_tuple
convert between FoundationDB Tuple Layer tuples and Rust tuples
-
same-types
Ensure that two types are the same
-
option-cell
OptionCell: OnceCell but derivable from Option
-
literal
Literals for Rust's collections
-
lazier_static
A thin wrapper around
std::sync::OnceLockproviding cached, static, lazy initialization -
slyce
Python-like slices
-
lua-macros
Useful macros to join Lua with Rust
-
memory-size-type
A data type for dealing with memory sizes
-
multi_try
Safely combine results
-
assert-cmp
Convenient assertion macros that print the failed expressions and their evaluated values
-
msiz_rustc-ap-syntax
Automatically published version of the package
syntaxin the rust-lang/rust repository from commit 74d5c70b174f06843049af2d764ff57ddc81c81c The publishing script for this crate lives at: https://github… -
simple-color
color struct
-
nearly_eq
Nearly(Approximately) equal traits and assertion
-
arrcat
Array concatenation
-
symbolism
Unique symbols made from human readable tags
-
exit
Custom exit status codes with ? in main
-
fmt_adapter
newtype adaptors to and from any formatting trait
-
championship
Generate championship fixtures using the round-robin tournament algorithm
-
derive_di
realized the dependency injection pattern
-
hexga_core
Basic set of functionalities common to all hexga crate
-
generic-global-variables
tools for implement generic global variables
-
engineer
master builder!
-
closure_capture
Capture variables are moved into closure or async block
-
tagged_cell
Fast, initializable, and thread safe static variables
-
unwrap_helpers
Helper macros for unwrapping
-
untrusted_value_derive_internals
aim to provide a type-safe way to handle and sanitize potentially untrusted values like user input
-
strdeser
A struct serializer for rust empowered with a macro
-
mixed_array
Construct arrays of mixed types
-
newtype-derive-2018
macros for deriving common traits for newtype structures
-
structify
A procedural macro to transform functions into structs with state and execution dependencies
-
tuple-fn
call functions and closures with tuple of arguments
-
what-i-want
Some tools to help with the return value
-
sorted
compile time guarantees for sorted sequences
-
delegatemethod
Delegate method calls to a field
-
if-none
Early break/continue/return if an optional expression evaluates to
None -
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
using
A macro for simpler builders with method cascading
-
into_variant
Easily convert your types into the corresponding enum variant
-
isrepr
Generating validation from arbitrary memory to repr(C) types
-
sac
A macro for constructing collections
-
array-fu
Construct arrays using simple syntax
-
soft_assert
Non-panicking assertions
-
columnation-master
An experimental columnar arena
-
anygma
makes it easy to define arrays containing different types
-
enum-tools
Automatically derive functions and trait implementations for enums
-
asenum
Small derive macro to safely convert the numerical value of an enum to the enum
-
structmap
Procedural macro library for converting between Rust structs and associative containers
-
macro-attr
macro_attr!macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derivecrate. -
id_cache
A cache data structure which generates sequentially-assigned ids for unique values
-
generic-lexer
A generic lexer using a simple match function
-
result-inspect
Adds the missing Result::inspect() function
-
scalar_types
A module that wraps scalar types in an endian safe type
-
kinds
Higher-Kinded Types simulated by GATs
-
facet-types
Core types and traits for the facet reflection library
-
mic
Facilitates answering to competitive programming problems
-
orderless
Orderless/named functions in Rust.
add!(b = 2); // 4. -
shellexpand-fork
Shell-like expansions in strings
-
holder
getter setter auto gen with holder trait
-
display_with
Return opaque impl Display and/or impl Debug types via display_with and debug_with
-
structural
Field accessor traits,and emulation of structural types
-
existential
quantification over lifetimes
-
sanitizeable
derive structs without certain fields
-
tartan-c-enum
Define FFI-safe enums that support unknown values
-
mopa-maintained
My Own Personal Any: get your own Any with additional functionality
-
unnest
Macros for an unnested control flow
-
macro_const
A macro for creating corresponding macro definitions for constants which evaluate to the same values
-
cartesian_array_product
Arrays of the cartesian product of a set of items
-
valico
JSON Schema validator and JSON coercer
-
blk_count_macro
macro for counting a number of comma-separated tokens at compile time
-
iterr
Combinators for dealing with iterators of
Results -
assert_ok
A macro that asserts a Result is Ok
-
derive-ex
Improved version of the macro to implement the traits defined in the standard library
-
internal
fields in Rust
-
sqlx-executor-alias-macro
SQLx Executor alias macro
-
pure_cell
Alternative to GhostCell that provides safe interior mutability via const expressions
-
hooks-core
Compile-time, async hooks
-
whiteout
macros that erase the type of any value into an impl Trait for a given trait
-
arrutil
Functions for manipulating arrays from slices
-
cflp
A context-free-language parser generated by procedural macros
-
dispatchtable
Small library used to specify function dispatch tables HashMap<K, Box<Fn(..)>>
-
injectify
impl Trait in structs
-
zisvalidator
A validator for struct and enum
-
pointer-identity
Wrapper type to treat the pointer address of types as identity rather than the value
-
status
Error container
-
dst
Data structures for DSTs
-
maller
that calls closures depending on the input data
-
index-fixed
convert slices into arrays using indexes ([T] -> [T;N])
-
generic_once_cell
A bring-your-own-mutex version of once_cell
-
serde_extra
Various de/serialization methods
-
array-lit
Macros for array and
Vecliterals with superpowers -
spidermeme
Traits to test for type equality and type inequality
-
rs-utilities
Some utilities
-
pin-projections
Declarative macro for creating projection functions for pinned objects
-
test-results
A series of utility macros for outputting testing results
-
rand_macros
#[derive]-like functionality for therand::Randtrait -
arraybox
A box with fixed capacity, backed by a byte array (it can be stored on the stack too). Implements fixed capacity
ArrayBox. -
err-convert-macro
Errors converting macros
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
cmp_any
Comparison for &dyn types
-
dispair
(Disp-Err) is a zero-dependency (other than
std) library that provides a simple wrapper struct that implementsErrorfor any type that implements bothDebugandDisplay -
actuate-core
A reactivity framework
-
maplit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
descriptive_toml_derive
Procedural derive macro for serializing a struct into a TOML template with field descriptions that is easily edited and deserialized
-
dyn_safe
Take control of the Semver hazard of the
dynsafety of your traits! -
elicit_macro
SmartPointer-like structure for polymorphism
-
aliri_braid_examples
Examples demonstrating usage of the
aliri_braidcrate -
cloneable-file
Cloneable file descriptor
-
array_manipulation
Methods for manipuling arrays in a Vec-like fashion. It will (probably) get into core once const expressions get less experimental.
-
tested-trait
Associate tests with traits
-
heredom
Tuple notations to describe XML-like trees
-
ternary-rs
emulating the ternary operator from C/C++ (among other languages)
-
downcast-trait
Allow casting between traits
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
brainfuck_macros
A compiler plugin that converts brainfuck code into Rust at compile time, letting your BF programs be optimised by LLVM to super-fast native code
-
derive-for
Macro for defining structs using the same derive procedural macros
-
heraclitus-compiler
Compiler frontend for developing great programming languages
-
if-let-return
macro for
if let ... pattern -
io-window
Seekable I/O adapter that limits operations to a byte range
-
pino_utils
general rust utility functions and macros
-
eieio
Error Implementing
Eq + Clonereplacingstd::io::Error -
init-token
one-time safe initialization of static, without overhead
-
bind_match
Convenience macro similar to
matches!but binds to variables in the pattern and returns anOptionof the result -
anyinput-core
An internal helper library of anyinput
-
scones_examples
Examples (and tests) for the Scones crate
-
collect_array
Allows for collecting an Iterator into an exactly sized array
-
thin-slice
An owned slice that packs the slice storage into a single word when possible
-
serde_str_helpers
Helpers for using serde with strings
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
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.
-
convertable
Non-reflexive version of From and Into
-
slicefields
Allows for data structures whose members are sub byte aligned (e.g. a one bit alignment)
-
template-builder
making idiomatic, declarative, builder-like patterns that use the struct literal syntax
-
fn_chain
Helper macro/function to create function chaining
-
into-result
convenience trait for converting something into a
ResultorOption -
id-arena
id-based arena
-
object-safe
Implement object-unsafe traits for trait objects
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
zkp-macros-lib
procedural macros implemented using
proc_macro2 -
type_traits
Collection of utilities related to types and their properties
-
build-deftly
Derive custom builders, using the derive-deftly macro system
-
num-conv
num_convis a crate to convert between integer types without usingascasts. This provides better certainty when refactoring, makes the exact behavior of code more explicit, and allows using turbofish syntax. -
xpr
A general purpose generic expression template library
-
tcp-struct
Share structs over tcp
-
error-utils
Some rust macros to simplify common error handling patterns
-
struct-validation
trait and derive to validate structs and return a list of errors
-
hash_table_datastruct
Adds a HashTable type, allowing to store values in a table with integer-indexed rows and hashable keys for columns
-
byte-slice
Byte slice manipulation macros
-
tuple-conv
Allows converting tuples of one element to vectors
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
derive_default_builder
derives a builder implementation relying on all fields implementing Default
-
anymap
A safe and convenient store for one value of each type
-
type-layout
Derivable trait to view the layout of a struct, useful for debugging
-
slice_trait
A generic trait for any slice, with item as a type parameter
-
specialize-call
A macro to invoke a function with type-arguments substituted according to a runtime value
-
tyenum
Attribute macro for type enums
-
merge-hashmap
Merge multiple values into one
-
get-field-by-type
Get a value of field, based on the type of a field
-
turbonone
macro for calling functions with Option<T> arguments
-
lifetime
Traits and derive macros to change the lifetime of a type, allowing efficient reuse of your stucts or enums with any lifetime requirement
-
static_leak
Leak references with static lifetimes from static Mutexes and RwLocks
-
value-enum
Macro for generating enums associated with values
-
nbytes
Rust compile-time evaluation of byte unit conversions
-
async-rusqlite
A tiny executor agnostic wrapper around rusqlite to make calls to it async
-
into_ext
Extension trait for the “Into” trait, offering a method “.into_::<T>()” to specify the target type of conversion
-
rev_slice
A newtype for operating on a reversed view of a slice
-
gtk_widget_macro
A derive macro helps you handle Gtk widgets
-
binary-utils
Binary utilities
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
random-number-macro-impl
Generate random numbers quickly
-
oxc_index
Newtype-style helpers for
Vecandusize -
tinytest
Write more compact unit tests with a small macro
-
cow_arc
CowArc can be useful for decreasing memory allocations by sharing immutable memory
-
nested-struct
Create nested structs using a macro
-
uninit-tools
that allows working with uninitialized memory entirely in safe code
-
clone-into-box
cloning trait objects
-
multi-trait-object
A type to store an object with all associated traits
-
debug-map-sorted
Sorted Debug impl for HashMap
-
slots-slice
manipulating slices of optional values
-
bit_fiddler
Macros for common bit operations with multiple convenient patterns
-
into_inner_drop
A helper library for implementing into_inner method for drop types safely
-
io-extra
An extension trait for
std::io::Error, with shorthand constructors for variousstd::io::ErrorKinds -
io_err
serializable
std::io::Errorwith improved ergonomics -
coproduct
Generic coproduct type with minimal memory footprint
-
pia
that adds packed integer arrays for mass storage of oddly sized variables
-
bidirectional_enum
Automatically generates conversions between an enum type and any other type
-
test-macro
macro for writing Rust test code in an easy way
-
archway
Rust traits for Rc and Arc interoperation
-
piping
Pipeline syntax in Rust.
4isize |> double(__) |> __ as usize. -
stack-trait
Stack trait with entry API for the LIFO element
-
generics2
macros for parsing generics (with optional where clause) in
macro_rules!- enhanced fork of generics -
oneoff
one-off types
-
sod-log
Service Oriented Design - Log Integrations
-
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…
-
string_iter
An overly designed &str iterator made with zero-copy parsing in mind