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