-
anyhow
Flexible concrete Error type built on std::error::Error
-
once_cell
Single assignment cells and lazy values
-
bytes
Types and traits for working with bytes
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
pin-project
A crate for safe and ergonomic pin-projection
-
ordered-float
Wrappers for total ordering on floats
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
memoffset
offset_of functionality for Rust structs
-
thiserror
derive(Error)
-
predicates
An implementation of boolean-valued predicate functions
-
bitflags
A macro to generate structures which behave like bitflags
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
snafu
An ergonomic error handling library
-
async-trait
Type erasure for async trait methods
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
dyn-clone
Clone trait that is object-safe
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive -
typed-builder
Compile-time type-checked builder derive
-
ouroboros
Easy, safe self-referential struct generation
-
beef
More compact Cow
-
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.
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
approx
Approximate floating point equality comparisons and assertions
-
smol_str
small-string optimized string type with O(1) clone
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
async-recursion
Recursion for async functions
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
indoc
Indented document literals
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
bitfield
This crate provides macros to generate bitfield-like struct
-
educe
This crate provides procedural macros to help you implement Rust-built-in traits quickly
-
human-panic
Panic messages for humans
-
scoped-tls
Library implementation of the 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 -
auto_impl
Automatically implement traits for common smart pointers and closures
-
inlinable_string
The
inlinable_stringcrate provides theInlinableStringtype – an owned, grow-able UTF-8 string that stores small strings inline and avoids heap-allocation – and theStringExt… -
az
Casts and checked casts
-
typenum
Typenum is a Rust library for 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…
-
macro_rules_attribute
Use declarative macros in attribute or derive position
-
error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
derivative
A set of alternative
deriveattributes for Rust -
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
cynic
A GraphQL query builder & data mapper for Rust
-
frunk
Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
joinery
A small crate for generically joining iterators with a separator
-
scroll
A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
similar-asserts
provides assert_eq! like macros with colorized diff output
-
shellexpand
Shell-like expansions in strings
-
float-cmp
Floating point approximate comparison traits
-
assert_matches
Asserts that a value matches a pattern
-
konst
Const equivalents of std functions, compile-time comparison, and parsing
-
static_assertions
Compile-time assertions to ensure that invariants are met
-
tap
Generic extensions for tapping values in Rust
-
void
The uninhabited void type for use in statically impossible cases
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
enumflags2
Enum-based bit flags
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
tt-call
Token tree calling convention
-
assertables
Assertables: Rust crate of macros
assert…!for better testing, quality assurance, and runtime reliability -
orchestra
Generate an orchestra of subsystems from a single struct
-
deku
bit level serialization/deserialization proc-macro for structs
-
by_address
Wrapper for comparing and hashing pointers by address
-
conv
This crate provides a number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
lazy-static-include
This crate provides
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
flagset
Data types and a macro for generating enumeration-based bit flags
-
cascade
Dart-like cascade macro for Rust
-
arrayref
Macros to take array references of slices
-
standback
New standard library, old compiler
-
size
A crate for expressing, formatting, and interacting with file sizes
-
metered
Fast, ergonomic metrics for Rust!
-
gazebo
A collection of well-tested utilities
-
scopeguard
A 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… -
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
synstructure
Helper methods and macros for custom derives
-
bounded-integer
Bounded integers
-
nonempty
Correct by construction non-empty vector
-
lazy_format
A utility crate for lazily formatting values for later
-
const_fn
An attribute for easy generation of const functions with conditional compilations
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
fp_rust
Implement fp features for Rust
-
sugars
An useful collection of macros to make tasks easier
-
send_wrapper
This Rust library 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…
-
rust-code-analysis-web
Run a web service to compute and export code metrics
-
buffered-reader
A super-powered Reader
-
memoize
Attribute macro for auto-memoizing functions with somewhat-simple signatures
-
if_chain
Macro for writing nested
if letexpressions -
serde_closure
Serializable and debuggable closures. This library provides macros that wrap closures to make them serializable and debuggable
-
tlua
Zero-cost high-level wrapper for Tarantool-LuaJIT
-
rustrict
rustrict is a profanity filter for Rust
-
assert_approx_eq
assert approximately equal
-
float-ord
A total ordering for floating-point numbers
-
tokenlock
Provides cell types that decouple permissions from data
-
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]checks -
evcxr_repl
A REPL for Rust
-
async-once-cell
Async single assignment cells and lazy values
-
packable
A crate for packing and unpacking binary representations
-
codegen
Library for generating Rust code
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
auto_enums
A library for to allow multiple return types by automatically generated enum
-
flex-error
Flexible error definitions using macros and traits
-
libc-print
println! and eprintln! macros on libc without stdlib
-
tuples
Provides many useful tools related to tuples
-
rustdoc-types
Types for rustdoc's json output
-
function_name
macro that expands to the name of the annotated function
-
one_err
OneErr to rule them all
-
enumn
Convert number to enum
-
iri-string
IRI as string types
-
diff-struct
A trait for diffing and applying diffs to types
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
readonly
Struct fields that are made read-only accessible to other modules
-
virtue
A sinless derive macro helper
-
buildstructor
Macro to derive a builder from a constructor function
-
ghost
Define your own PhantomData
-
tryhard
Easily retry futures
-
failsafe
A circuit breaker implementation
-
volatile
A simple volatile wrapper type
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
streaming-iterator
Streaming iterators
-
macro-attr-2018
This crate provides the
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
random-number
Generate random numbers quickly
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
derive-where
Deriving with custom trait bounds
-
vcell
Cellwith volatile read / write operations -
opaque-debug
Macro for opaque Debug trait implementation
-
nougat
(lifetime) GATs on stable Rust
-
assert_unordered
A direct replacement for
assert_eqfor unordered collections -
amplify_derive
Amplifying Rust language capabilities: derive macros for the 'amplify' library
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
cubob
Structured output helpers for display mode
-
rust-fsm
A framework for building finite state machines in Rust
-
advent-of-code
Solutions to Advent of Code
-
exponential-backoff
A small and flexible backoff function
-
openapiv3-extended
This crate provides data structures that represent the OpenAPI v3.0.x specification easily deserializable with serde
-
k8-client
Core Kubernetes metadata traits
-
semval
Semantic validation
-
deserr
Deserarialization library with focus on error handling
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
simple-error
A simple error type backed by a string
-
arrow2_convert
Convert between nested rust types and Arrow with arrow2
-
binread
A Rust crate for helping read structs from binary data using ✨macro magic✨
-
safe-transmute
A safeguarded transmute() for Rust
-
bool_ext
A crate which defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
maybe-owned
provides a
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
take_mut
Take a T from a &mut T temporarily
-
snailquote
Escape and unescape strings with shell-inspired quoting
-
objid
Generate a random object identifier
-
fragile
Provides wrapper types for sending non-send values to other threads
-
fn_graph
Dynamically managed function graph execution
-
fatality
Fatality extension to
thiserror::Error -
mirai-annotations
Macros that provide source code annotations for MIRAI
-
inherent
Make trait methods callable without the trait in scope
-
easy-cast
Type conversions which are expected to succeed
-
nu-utils
Nushell utility functions
-
drop_bomb
A runtime guard for implementing linear types
-
subplotlib
Utility functions and types for
subplot codegengenerated Rust based test suites. Relies onsubplotlib-derivefor associated macros. -
dync
An efficient alternative to
dyn Traitfor containerized types -
tiny-bench
A tiny benchmarking library
-
mapper
Mapping macro to help to reduce mapping boilerplate
-
unit-conversions
Various units of measurement conversions
-
entrait
Loosely coupled Rust application design made easy
-
konst_macro_rules
Implementation detail of the konst crate
-
manifest-dir-macros
This crate provides function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
with_drop
Nostd wrapper for using a closure as a custom drop function
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_partsandVec::into_raw_parts -
naan
A fast, easy, and tasty functional programming prelude
-
int-enum
A derive macro for conversion between integer and enum types
-
impls
Determine if a type implements a logical trait expression
-
stdext
Extensions for the Rust standard library structures
-
generics
Provides macros for parsing generics (with optional where clause) in
macro_rules! -
concat-with
Extend the function of the
concat!macro instd -
inventory
Typed distributed plugin registration
-
ownedbytes
Expose data as static slice
-
dilib
A dependency injection library for Rust
-
enum-assoc
Procedural macro to associate constants with enum variants
-
read_input
Ask for user input until the data inputted is valid
-
qttypes
Manually maintained buildings for Qt value types
-
apple-bundles
Interface with Apple bundle primitives
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
frunk_laws
frunk_laws contains laws for algebras declared in Frunk
-
thiserror-no-std
derive(Error)
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
fstrings
Python3 fstring interpolation in Rust
-
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
ffi_helpers
A crate to help make working with FFI easier
-
yaserde
Serialization and deserialization library
-
inline-python
Inline Python code directly in your Rust code
-
typeables
Typeables: Rust crate of type aliases. By SixArm.com.
-
lazycell
A library providing a lazily filled Cell struct
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
unarray
Utilities for working with uninitialized arrays
-
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
-
oofs
Error handling library that generates and injects context for you
-
envsubst
Variables substitution
-
more-di
Provides support for dependency injection (DI)
-
generativity
Generation of unique invariant lifetimes
-
libipld-macro
ipld macro
-
components-arena
Simple library for creating complex domain-specific self-referential data structures
-
sawp-flags
SAWP BitFlags Handling and Storage
-
globals
Painless global variables in Rust
-
andex
Safe, strongly typed array indexes and wrappers for rust with zero dependencies
-
validator_types
Basic type for validator and validator_derive
-
atom
A safe abstraction around AtomicPtr
-
cryo
Extend the lifetime of a reference. Safely.
-
dyn-stack
Dynamic stack wrapper for unsized allocations
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
nameof
Provides a Rust macro to determine the string name of a binding, type, const, or function
-
field-offset
Safe pointer-to-member implementation
-
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
atomic
Generic Atomic<T> wrapper type
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
indicator
Abstractions for stream aggregation, we call them
Indicators -
cast
Ergonomic, checked cast functions for primitive types
-
deno_broadcast_channel
Implementation of BroadcastChannel API for Deno
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
metered-macro
Fast, ergonomic metrics for Rust!
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
bevy-ui-build-macros
A collection of macros to speed up the process of defining UIs in bevy
-
messages
Runtime-agnostic actor library
-
range-map
Maps and sets implemented using ranges
-
safelog
Conditionally suppress confidential information from logs
-
singleton-manager
A programatical singleton manager
-
microtype
A crate to simplify the creation of microtypes
-
ff_ce
Library for building and interfacing with finite fields
-
zzz
Fast progress bar with sane defaults
-
derive_builder_macro
Rust macro to automatically implement the builder pattern for arbitrary structs
-
structmap
Procedural macro library for converting between Rust structs and associative containers
-
qjsonrpc
JSON-RPC over QUIC comm
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
rust-fsm-dsl
Macros for rust-fsm DSL
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
sawp-ffi
FFI helper macros and traits
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
tia
tia; trait, impl, accessors | automatic
-
cw2
Definition and types for the CosmWasm-2 interface
-
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
tartan-bitfield
Define structures with accessors for particular bits or bit ranges
-
asm_block
Translate tokens to string for Rust inline assembly
-
tremor-kv
A logstash inspured key value extractor
-
data-rw
io buffer write reader
-
actix_extract_multipart
ActixExtractMultipart is a library for parse actix_multipart into a structure that you defined
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
flowync
A simple utility for multithreading a/synchronization
-
compound-error
Compound errors with flat hierarchy
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
aoc-main
A macro which defines a handful main for the Advent of Code
-
formatx
A macro for formatting non literal strings at runtime
-
twitch_types
common types for Twitch
-
enum-derive-2018
This crate provides macros for deriving additional functionality for enums
-
socketpair
Cross-platform socketpair functionality
-
anyerror
A type of any error for transport
-
prima_bridge
A library to implement the bridge pattern
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
aligners
Utilities for alignment guarantees for data
-
frunk_proc_macro_helpers
Common internal functions for frunk's proc macros
-
rubbl_core
Core types and traits for Rubbl, a Rust package for astrophysics
-
bit_field
Simple bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
veil
Rust derive macro for redacting sensitive data in
std::fmt::Debug -
predicates-core
An API for boolean-valued predicate functions
-
copyless
Ways to eliminate memcpy calls when using the standard library
-
clone_cell
A Cell that works with a restrictive form of Clone
-
rc-box
Known unique versions of Rc and Arc
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
io-streams
Unbuffered and unlocked I/O streams
-
rust_info
Extracts the current rust compiler information
-
retry-error
An error type for an operation that can fail more than once
-
with_locals
Function attribute to return references to locals by using CPS
-
mode
A behavioral state machine library written in Rust
-
expect-exit
Result.expected(): display an error message and exit without a panic
-
sealed
Macro for sealing traits and structures
-
rquickjs
High level bindings to the QuickJS javascript engine
-
nop-json
JSON serialization/deserialization (full-featured, modern, optimal, streaming, direct into struct, binary-ready)
-
magic_static
Global singletons initialized at program start, an alternative to lazy initialization
-
sloggers
This library provides frequently used slog loggers and convenient functions
-
openapi_type
OpenAPI type information for Rust structs and enums
-
parameterized_test
A macro to support providing arguments to test functions
-
cstr-argument
A trait for converting function arguments to null terminated strings
-
nu-pretty-hex
Pretty hex dump of bytes slice in the common style
-
tor-units
Provides macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
every_variant
Provides an EveryVariant trait that provides the every_variant method on types. Allows you to easily generate every combination of variants in structures that contains Enums, or in nested enum trees…
-
advancedresearch-path_iter
A cocategory enumeration library based on path semantics
-
rtml
(r)ust macros for h(tml) expansion => rtml. (r)ust type safe (css) => rcss
-
fixnum
Fixed-point numbers with explicit rounding
-
auto_ops
Macros for easy operator overloading
-
extended-primitives
A library providing primitive-like types for use
-
page-turner
A generic abstraction of APIs with pagination
-
abi_stable_shared
Implementation detail of abi_stable
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
strck
Checked owned and borrowed strings
-
rt-format
Fully-runtime equivalent of the format! macro
-
result-like
Option/Result-like monad interface for your own enum
-
inout
Custom reference types for code generic over in-place and buffer-to-buffer modes of operation
-
blanket
A simple macro to derive blanket implementations for your traits
-
validated
The cumulative sibling of
ResultandEither -
hs-bindgen
Handy macro to generate C-FFI bindings to Rust for Haskell
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
dims_macro
Macros for Generating Systems of Units
-
bump-into
a no_std bump allocator sourcing space from a user-provided slice
-
copy_from_str
An extension trait to copy a string into another string
-
error-code
Alternative Error for Rust
-
funty
Trait generalization over the primitive types
-
extension-trait
Macro to declare extension traits
-
derive_destructure2_examples
Examples for crate derive_destructure2
-
trait_cast_rs
Get your own Any with support for casting to trait objects
-
variant_count
Derive macro for enum which adds to it the count of variants
-
hex-display
Display impl for byte slices which provides a hexdump
-
arr_macro
Initialize arrays with ease!
-
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
-
downcast
Trait for downcasting trait objects back to their original types
-
aliri_braid_examples
Examples demonstrating usage of the
aliri_braidcrate -
nonmax
Numeric types that cannot hold maximum values
-
enum-display
A macro to derive Display for enums
-
tor-basic-utils
General helpers used by Tor
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
engineer
The engineer is a master builder!
-
cassandra_macro
Create Cassandra tables and CRUD CQL prepared statements from Rust structs. (custom derive: cassandra_macro_derive)
-
ptrplus
Additional funtionality for pointer types
-
shoulda
derive macro for test assertions
-
newstr
Simple macros for declaring String-base new types
-
safecast
Traits to define safe casting between types
-
projecture
Easy arbitrary type projections without proc macros
-
valued-enums
Macros collection and specify trait for creating valued or python-like enums
-
heterob
Library for conversion between bytes/bits and heterogeneous lists (tuples)
-
version
A very simple library who's job is to return the version of your crate if you're building with Cargo
-
enum_delegate
Easily replace dynamic dispatch with an enum, for speed and serialization
-
nova
Macro to derive newtypes with support for serde and sqlx
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
duplex
The Duplex trait: interactive streams
-
human-errors
An error library focused on providing your users with relevant advice for any problem
-
nolife
Crate to open a scope and then freeze it in time for future access
-
autofolder
Single-element folding wrapper
-
peeking_take_while
Like
Iterator::take_while, but calls the predicate on a peeked value. This allows you to useIterator::by_refandIterator::take_whiletogether, and still get the first value… -
outref
Out reference
-
pipe-trait
Make it possible to chain regular functions
-
concat-string
Provides macros for concatenating string slices into owned strings
-
background-jobs-actix
in-process jobs processor based on Actix
-
methods-enum
Attribute-like macro for 'state' and 'state machine' design patterns, without dyn Trait (based on generated enum)
-
custom-format
Custom formatting for Rust
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
fluvio-types
Fluvio common types and objects
-
better_any
Type id and Any for non static types
-
itermore
🤸♀️ More iterator adaptors
-
deluxe
Procedural macro attribute parser
-
atri_plugin
AtriPlugin
-
tokio-pg-mapper
Proc-macro library used to map a tokio-postgres row to a Rust type (struct)
-
collate
Traits and a data structure to support collation and bisection
-
interim
parses simple English dates, inspired by Linux date command, and forked from chrono-english
-
funcmap
Derivable functorial mappings for Rust
-
abi_stable_derive
Implementation detail of abi_stable
-
typestate
A proc macro DSL for typestates
-
degeneric-macros
Hides struct generics into trait associated types
-
intertrait
Allow for inter-trait casting
-
forward_ref_generic
Generically forward references for operations on Copy types
-
shrinkwraprs
Auto-derive for Rust conversion traits -- make working with newtypes a breeze
-
problem
Error handling for command line applications or prototypes
-
fortify
A simple and convenient way to bundle owned data with a borrowing type
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator -
try_match
An expression macro to match a pattern and return the bound variables in
Result -
builder-pattern
A derivable macro for declaring a builder pattern
-
tor-error
Provides the unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
tc-error
TinyChain's generic error struct
-
tiny-fn
Type erased closures on stack
-
io-arrays
Random-access I/O
-
enum-unitary
Trait and macro for unitary enums
-
launchdarkly-server-sdk-evaluation
LaunchDarkly feature flag evaluation engine
-
microjson
No frills JSON parsing without allocations
-
lichen
Scripting DSL (for Dialogue Graphs, et al)
-
integer_or_float
A data type holding an ‘integer or float’ (a data type in the Unified Font Object specification, among others)
-
shopify_function
Crate to write Shopify Functions in Rust
-
mapper-api
Api of the
mappercrate -
dyn_struct
Construct dynamically sized types safely
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
qed
Compile-time assertions
-
const-cstr
Create static C-compatible strings from Rust string literals
-
arraygen
Derive macro for generating arrays from struct fields
-
defer-drop
Defer dropping large types to a background thread
-
zerovec-derive
Custom derive for the zerovec crate
-
iter-identify_first_last
A helper iterator, flagging first and last elements
-
elor
Base generic implementation of an Either type
-
superstruct
Versioned data types with minimal boilerplate
-
fused_error
A simple library for working with composable errors
-
printc
Print-clean macro. Like
println!but cleaner input. -
iso7816
Types for ISO 7816
-
gen_ops
Macros for operator overloading for generic types
-
dynamize
trait objects with variable associated types
-
iter-python
Python generator expressions and 'list' comprehensions
-
custom_derive
(Note: superseded by
macro-attr) This crate provides a macro that enables the use of custom derive attributes -
tynm
Returns type names in shorter form
-
unconst_trait_impl
Function-like macro that "unconsts" trait implementations
-
psl-types
Common types for the public suffix implementation crates
-
derive_destructure2
Destructure structs that implement Drop
-
r-ex
Zero-bloat Rust core library extensions
-
structview
Viewing binary data as high-level data structures, safely
-
const_sort_rs
Sort slices in const items
-
pin-project-internal
Implementation detail of the
pin-projectcrate -
selfie
Experimental, macro-free and allocation-free self-referential structs
-
lazy-init
Lazy initialization
-
hex-slice
Extends the std::fmt::*Hex traits to slices
-
rsb_derive
An opinionated macro implementation for Rust struct builder pattern with compile-time validation
-
smarterr
Smart error handling library
-
runestr
User-perceived characters related types and data structures
-
drop_guard
The drop_guard crate enables you to implement the Drop trait on any type. So you can run a closure on any value running out of scope
-
shaku
Compile Time Dependency Injection for Rust
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
aoc_driver
helper macros and functions for AoC
-
quick-error
A macro which makes error types pleasant to write
-
merge
Merge multiple values into one
-
soa_derive
Automatic Struct of Array generation
-
rog
A Rust logger
-
metastruct
Abstractions for iterating and mapping over struct fields
-
ebacktrace
A simple error wrapper which captures a backtrace and can carry an optional textual description
-
panicking
Provides a
std::thread::panickinganalog available in theno_stdcontext -
constcat
concat! with support for const variables and expressions
-
ext-trait
Annotation to easily define ad-hoc / one-shot extension traits
-
winresult-types
windows result types
-
warned
struct Warned<T, W> { value: T, warnings: Vec<W> }, which represents a value with warnings
-
char-device
Character Device I/O
-
eventsourced
Persistent event sourcing
-
dyn_safe
Take control of the Semver hazard of the
dynsafety of your traits! -
assert-parse
The util to assert macro parsing
-
near-safe-cell
A more ergonomic 'UnsafeCell' wrapper/replacement
-
cursive-extras
Extra views for the Cursive TUI library as well some helper functions and macros
-
bumpalo-herd
Support for bumpalo in scoped threads & rayon
-
veccell
Provides VecCell, a variant of Vec with interior mutability
-
arcow
Atomically Reference-counted Copy-On-Write shared pointer
-
hatch_result
A result-like struct that returns on Ok, instead of on Err when ? operator is used
-
copstr
Yet Another COpy STRing module
-
simple-logging
A simple logger for the log facade
-
keepops
Extension traits for keeping the input of mapping functions
-
static_cell
Statically allocated, initialized at runtime cell
-
agb_fixnum
Library for abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
cynic-querygen
QueryFragment generation for cynic, a GraphQL query builder & data mapper for Rust
-
cell-project
Safe interface for cell projection
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
rcrefcell
Wrapper type for Rc<RefCell<A>>
-
jcers
jce in rust
-
thiserror_core2
derive(Error) (no_std-enabled using core2)
-
derive-adhoc
An ergonomic way to write derive() macros
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
newtype-derive-2018
This crate provides macros for deriving common traits for newtype structures
-
derive-ex
Improved version of the macro to implement the traits defined in the standard library
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
unwind_safe
Readable unwind-safe code thanks to a try-finally-looking builder pattern
-
self-reference
A Self-Reference Helper
-
generic_singleton
A library crate allowing for generic singleton patterns
-
result-ext
Extends
Resultwith additional operations -
stack-string
A wrapper around SmartString which adds support for various extensions
-
ffizz-string
FFI string implementation
-
hb_error
Useful macros and traits for creating and handling errors
-
thisctx
Easily create error with contexts
-
tdlg
Generates a grid of cells that could be used to build a top-down game map. Used by me to learn Rust.
-
visita
Elegant implementation of the Visitor Pattern
-
enum-ptr
Ergonomic tagged pointer
-
maybe-single
A singleton. Maybe.
-
thin-slice
An owned slice that packs the slice storage into a single word when possible
-
overwrite
A simple trait that defines how to overwrite a type by another types. Mainly useful to create an app configuration from different sources
-
numeric_cast
safe cast between numbers
-
inline_default
Macro for inline Default implementation
-
assert_ok
A macro that asserts a Result is Ok
-
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
retrieve
#[{pub_}mod_{pub_}use(a,b,c,...)] => {pub }mod a; {pub }use a::*; and also b,c,
-
wintun
Safe idiomatic bindings to the WinTun C library
-
deltoid
A library to calculate and apply deltas to structs and enums
-
see-through
A library of traits to provide access to internal fields of generic structs
-
utils-results
The easiest and most intuitive error handling solution
-
open-ambient
Open files and directories with constant paths
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
podio
Additional trait for Read and Write to read and write Plain Old Data
-
cronjob
cronjob library for scheduling your methods
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
dicom-dictionary-std
Standard DICOM attribute dictionary
-
stringconverter
A simple set of functions for crudely converting strings to floats or integers
-
iter-comprehensions
A library for iterator comprehensions
-
ghost-lite
custom PhantomData types
-
api-client
Provides a macro for quickly creating REST api client structs
-
dyn-context
Simple mechanism for lifetimes erasing
-
simple_parse
A declarative converter for Rust type to and from binary
-
similar-structs-macros
Quality-of-life macros for more concise struct/enum definitions
-
struct-convert
Auto Convert between structs
-
ethers-fixed-hash
Macros to define custom fixed-size hash types
-
expand
Macro to expand byte string and string literals
-
frunk_proc_macros
Proc macros for Frunk
-
erasable
Type-erased thin pointers
-
avr-boot
Self Programming functions for AVR MCUs
-
sashay
Type-erased and lifetime-erased references and slices
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
filters
Build filters/predicates with the builder pattern
-
assert-impl
Macro for static assert types implement a trait or not
-
anyhow_ext
Extension of anynow
-
cast_trait_object
Cast between trait objects using only safe Rust
-
laxcow
Clone-on-write smart pointer with relaxed trait constraints
-
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…
-
orfail
Error handling library for portable unrecoverable errors
-
option-ext
Extends
Optionwith additional operations -
rusty-xinput
Safe dynamic loading of xinput
-
thiserror-core
derive(Error)
-
inter-struct
Automatically generated traits for arbitrary structs
-
prctl
This package provides safe abstraction to the linux prctl() interface. Some functions may be architecture-specific.
-
lset
Data types describing linear sets
-
syllogism
Utilities to allow for some specialization using stable Rust
-
atruct
macros for anonymous structs in Rust
-
ang
Angular types and common helper methods
-
proc-easy
Macros to make writing proc-macro crates easy
-
try_as
Macros and traits to ease using enums whose sole purpose is to enumerate a set of types
-
inline_dyn
A container type for storing dynamically-sized types inline
-
meticulous
Result extension to add more meaning to unwrapping
-
closure
A macro for capturing variables on a per variable basis
-
progress-streams
Progress callbacks for types which implement Read/Write
-
syner
A procedural macro to generate a parser for attributes from a struct
-
yup-hyper-mock
A utility library for testing clients using hyper
-
file_into_string
file_into_string: Rust crate of utility functions to read a file into a string, or a vector of strings, and preserving line endings
-
rvs-c-api
C-API for Rvs - A library for defining and evaluating random variables using a simple DSL
-
as-is
An abstraction over ownership
-
rawpointer
Extra methods for raw pointers and
NonNull<T>. For example.post_inc()and.pre_dec()(c.f.ptr++and--ptr),offsetandaddforNonNull<T>, and the functionptrdistance. -
impl-enum
Macros that make using enums like trait objects more convenient
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
const-type-layout
Derivable const trait to view and compare the layout of a struct, union, or enum
-
mac
A collection of great and ubiqutitous macros
-
typebitset
Type-level bitset implementation
-
gstuff
Small macro and trinkets that make my life easier
-
extent
replacement for std::ops::{Range,RangeInclusive}
-
fat_type
A type which permits thin references to arrays and dynamic types
-
implementation
The implementation crate
-
dyn-clonable
Attribute wrapper for dyn-clone
-
chainerror
Make chaining errors easy
-
mixed-num
A trait for generic implementations of numerical methods
-
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
-
frust
Functional Programming in Rust
-
unstringify
Procedural macro implemention of the reverse operation of
stringify! -
menv
Pulling in arguments from environment variables
-
byteorder_slice
Byteorder like crate for &[u8]
-
graphannis-capi
This is the C-API to the ANNIS linguistic search and visualization system
-
format-bytes
A macro to format bytestrings
-
enumeration
An extension to rust enum
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
batch_oper
batch_oper provides some batch operation macro for some operations
-
compost
Adds a macro to decompose tuples into tuples containing a subset of their values
-
hado
Monadic do notation using a macro
-
flatty
Flat message buffers
-
nshare
Conversion between n-dimensional types in different Rust crates
-
any_ref
To capture and move things that are NOT 'static with memory safety
-
apparat
A lightweight event-driven behavioral state machine
-
peak-result
A simple trait that extends the standard Result enum to allow you to run some code in case of error or success
-
aleo-std-storage
Convenience methods for accessing resources in Aleo storage
-
event-listener-primitives
Low-level primitive for building Node.js-like event listeners
-
slice-diff-patch
Library crate providing utility functions for diff and patch of slices
-
cyclic_data_types
Cyclic data types are series of structs, enums, types and functions to create a series of fast data types
-
scanfmt
Scanfmt: easy to use macro for parsing a string
-
rassert-rs
Simple macro for expressing Result-returning assertions
-
illicit
An implicit thread-local environment which is indexed by type
-
mpst-seq
A library with macro for mpstthree
-
mbox
malloc-based box. Supports wrapping pointers or null-terminated strings returned from malloc as a Rust type, which will be free'd on drop
-
random_variant
To be used with all variant, contains the derive macro
-
iter_fixed
Iterator of fixed length
-
scoped-tls-hkt
A more flexible version of
scoped-tls, allowing the following additional features: Storage of references to dynamically sized types. Storage of mutable references. Storage… -
format
A utility crate to make it easier to work with the formatter
-
atomicell
Multi-threaded RefCell on atomics
-
sophia_indexed
A Rust toolkit for RDF and Linked Data - Utility traits and functions for index-based implementations of graphs and datasets
-
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
-
big_mac
A metamacro toolkit for writing complex macros
-
regex-bnf
A deterministic parser for a BNF inspired syntax with regular expressions
-
assert-cmp
Convenient assertion macros that print the failed expressions and their evaluated values
-
bitmask
A bitmask generator for enum scoped bit flags
-
scsys-core
scsys-core implements several mission-critical primitives and utilities generalized for day-to-day use
-
nclosure
Provides composable, nameable closure types with separated states and functionality for use in APIs where anonymous types are unavailable
-
elastic_types_derive_internals
Codegen internals for elastic_types
-
inline_newtype
A rust newtype macro inspired by kotlin's inline class
-
hermit-sync
Synchronization primitives for kernels
-
const_fn_assert
Assertions for const functions
-
separator
Formats numbers into strings with thousands separators for readability
-
assure
Assure: macros for Rust runtime checks and error handling
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
eternal_iterator
Trait implementation to promise that the iterator iterates forever
-
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
fehler
A library for error-handling syntax in Rust
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
join
Macros which provide useful shortcut combinators, combine sync/async chains, support single and multi thread (sync/async) step by step execution of branches, transform tuple of results in result of tuple
-
easy-error
Simple error utilities
-
std_io_iterators
An iterator for
STDINand a wrapper forSTDOUT. Allows easy piping, and graceful closing of application if pipe breaks -
tindex
Vec, slice and bitset with custom index types -
sophia_rio
A Rust toolkit for RDF and Linked Data - Common code for Rio adapters
-
css-color-parser2
Easy-to-use Rust parser for CSS3 color strings
-
plain_enum
Mimicing Java's enum::values() and EnumMap
-
starstuff-types
A simple star catalog parser and primitive types for star coordinates and astronomical times
-
fsize
fsizeis aliased to the floating-point type of pointer size -
scientisto
A light-weight Rust implementation of the github/scientist library used for careful refactoring of critical code paths
-
type_description
Machine-readable type descriptions
-
error-trees
Fail with multiple errors, istead of only the first
-
bytestream
Provides a convenient way of writing binary data to a buffer
-
strong
Strongly typed String
-
derive-debug-extras
More customisable #[derive(Debug)]
-
wai-parser
Parser for WAI syntax
-
cell-family
Cheap cells accessed through unique owners
-
abscissa_tokio
Support for launching Tokio runtimes within Abscissa applications
-
ees
Simple error-handling library
-
retrommo-fetch
Wrapper around the RetroMMO API
-
string-utility
Provides simple substring implementation (with the RangeBound trait), keep string before or after a specified string, etc
-
structural
Field accessor traits,and emulation of structural types
-
flows-connector-dsi
Data struct interface used in flow functions of flows.network
-
impl-converter-helper
declarative macro library to help you implement the
FromorTryFromtrait for your type -
auto-impl-ops
semi-automatic implementation proc-macro for binary operations
-
result-extensions
A simple rust library that provides extensions for the Result<T,E> type
-
async-wormhole
Async calls across non-async functions
-
enum-tools
Automatically derive functions and trait implementations for enums
-
cowstr
Copy-on-Write shared strings
-
css-color-parser
Easy-to-use Rust parser for CSS3 color strings
-
bitrange
Simple plugin to map bits in integer values to fields
-
generic_once_cell
A bring-your-own-mutex version of once_cell
-
everybody_loops
A Replacement for the
-Z unpretty=everybody_loopspass to rustc -
fluid-macro
Write long method chains as a series of steps instead, and more!
-
rubber_duck
Enables building functions that can be called with named arg syntax
-
zero_v
A library for implementing iterators over function outputs for collections of types implementing a common trait, without using vtables/ dynamic polymorphism
-
cismute
Safely transmute type to itself in generic contexts
-
generic-vec
a vector implementation that can be used in
no_stdenvioronments -
restcrab
Procedural macro to automatically generate a REST client from a trait definition
-
imgref-iter
A small crate for iterating over the rows or columns of
imgrefbuffers -
vnum
Create enums with a constant value associated to every variant
-
helper
A library provided some useful proc macros for Rust
-
match_opt
A macro for turning a partial match into a full match returning an option
-
struct-path
A helper macros to build a string that represents struct fields path at compile time (such as <field-name>.<field-name>)
-
fnrs
A simple crate with some useful functions i like
-
chunk_iter
Chunked iterator generic over any iterator
-
hotswap
Easy code swapping in running executables
-
ez-err
A simple error handling library with support for ergonomic and fast error handling
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
kaydle-primitives
Low level primitive parsers for KDL, intended as a building block for higher level parsers or deserializers
-
ref-ops
An escape hatch for implementing
opstraits for references to newtypes -
gazebo_derive
Derive macros for the Gazebo library
-
partial_application
partial function application via the partial! macro
-
fixed_trigonometry
Fixed point numerical approimations to trigonometric functions
-
round
This crate provides utilities to round your floats with precision from 1 to 10
-
raekna-parser
This crate provides the code needed to parse string slices into Expressions that can later be evaluated
-
gtmpl_value
Internal value format for gtmpl-rust
-
new_type
Experimental implementation of newtypes by type level logic
-
mt-dom
A library for generating patches as a result diffing virtual DOM tree
-
components-arena-traits
Does not intend for direct use
-
rich-result
Rich result type differentiating between recoverable & fatal errors
-
ip-family
IP family enum with functions to get special ips of the right family
-
blue_typemap
A TypeMap Dependency Injection method for dynamic function parameters
-
influxdb2-structmap
Procedural macro library for converting between Rust structs and associative containers
-
regex-macro
A macro to generate a lazy regex expression
-
test-macro
This is a macro for writing Rust test code in an easy way
-
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
iterwindows
An iterator adapter to iterate over all contiguous windows of length N
-
html_stack
A stack based dsl for writing html. This is not an html template!
-
selfref
Semi-pain-free self-referential pinned types
-
mvcc_cell
Software-transactional memory for Rust
-
zc_io
Simple zero-copy I/O
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
static_assert_macro
Library implementation of so-called
static_assert -
prometheus-metric-storage
Derive macro to instantiate and register prometheus metrics without having to write tons of boilerplate code
-
as-any
provide the AsAny trait
-
trait-bound-typemap
A crate to create typemaps with additional trait restrictions and implementations
-
kube-core
Kube shared types, traits and client-less behavior
-
nanoid-dictionary
Popular alphabets for use with nanoid
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
error-iter
Error::sources on stable Rust
-
grouping_by
A simple library which allows the user to group an iterator by various ways
-
tuple_list
Crate for macro-free variadic tuple metaprogramming
-
kv-derive
Derive struct conversions from and to key-value vectors
-
zst
Zero-sized generic type with the associated type exposing the type parameter
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
alt-enum
Various macros providing a more beautiful syntax for enums
-
davenport
Ergonomic thread-local workspaces for intermediate data
-
hs-bindgen-traits
Utility traits behind hs-bindgen ergonomics
-
rocket_lang
rocket_lang provides a configurable enum type for multi-language rocket applications
-
lifterr
A small set of adapters extending Rust's error-handling capabilities
-
trait-set
Support for trait alias feature on stable Rust
-
string-sharp
traits implementing on string similar to c#
-
curerr
Rust crate for easy error handling
-
oofs_derive
Error handling library that generates and injects context for you
-
cfg_rust_features
Set cfg options according to probing for Rust compiler, language, and library features
-
tagged_cell
Fast, initializable, and thread safe static variables
-
error_def
A Rust syntax extension for generating error-handling boilerplate code
-
spawn_timeout
Call a subroutine after a constant time interval
-
spawn_interval
Call a subroutine at a constant time interval
-
stackvec
A crate to use stack-allocated Vectors (performance and/or no-std)
-
spectral
Fluent test assertions
-
tagname
get the name of a variant in your enum as a string
-
u16cstr
A macro for creating c-style u16 wide strings at compile time
-
direction
Representations of directions
-
js_option
An Option-like type with separate null and undefined variants
-
struct2map
Procedural macro library for converting between Rust structs and associative containers
-
extrust
A library of utilities intended as an extension of the standard library
-
slice-copy
Go style copying for slices
-
tryvial
Small crate for ok-wrapping and try blocks
-
null-terminated
Library of null-terminated slices and UTF-8-encoded strings with thin references
-
rxml_validation
Plumbing crate for rxml and rxml_proc crates
-
infix_macro
Provides a macro that generates the neccesary boilerplate to use "*operator*" infix functions
-
set_slice
A macro for assigning values to slices
-
event_system
Simple lightweight event system
-
expecto-patronum
A library to add beatiful animals to your panic outputs
-
pre
Compile-time assistance for working with unsafe code
-
lurk-ipld-macro
lurk-ipld macro
-
exun
Handle unexpected errors
-
owning_ref
A library for creating references that carry their owner with them
-
macrofied-toolbox
This library provides an ergonomic experience of adding debugging messages to rust's Result<T,E> and Option<T> patterns
-
another-visitor
Lets you derive visitor pattern implementations
-
rs-sandbox
Sandbox
-
cantor
A general toolkit for working with types that have a small number of values
-
tmux-lib
Tmux helper functions
-
refl
Provides a
reflencoding which you can use to provide a proof witness that one type is equivalent (identical) to another type. You can use this to encode a subset of what GADTs allow you to in Haskell -
pathbuf
A macro to conveniently build PathBufs
-
yew-callbacks
Create and manage callbacks per component without creating duplicates
-
iterator-endiate
Extension method for (exact size) iterators which yields tuple containing whether item is last in iterator
-
htmlificator
Generate HTML source code through rust functions!
-
crc-frame
simple functions for reading and writing crc32'd framed buffers
-
extract-variant
Destructure expressions into, and return assignments from, a single pattern
-
pin-projections
Declarative macro for creating projection functions for pinned objects
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
variant_access_derive
Prodedural macros for deriving the VariantAccess traits
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
edsm-dumps-model
Data models for EDSM dump data
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
scoped_reference
Runtime-checked borrow lifetimes
-
persian_str_rs
This library provides functions for working with Persian strings in Rust
-
nomore
Personal Standard Rust Lib Publics for reuse and to avoid redefinition
-
wrapped-vec
Macro for generating wrapped Vec types and associated boilerplate
-
ex3-canister-error
Underlying error types used over ex3 core canisters
-
sv_str
Scalar Value string
-
thin_cstr
An experimental crate which provides a truly thin std::ffi::CStr
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
opcode-macros
Macros for opcodes encoded in bit fields
-
tuple
Element-wise operations on tuples
-
coproduct
Generic coproduct type with minimal memory footprint
-
monch
Inspired by nom, but specifically for strings
-
require_unsafe_in_body
Make
unsafe fnstill requireunsafeblocks in the function’s body -
sauron-core
An html library for building client side webapps
-
velcro_core
Core dependencies used by the
velcrocrate. Seevelcrofor documentation. It is not advised to depend on this crate directly; it is an internal dependency ofvelcroand may be subject to breaking changes. -
is_empty
Easily check if the struct is empty
-
defmac
A macro to define lambda-like macros inline
-
posix-errors
Posix error codes and handy functions for using them
-
ident-util
Provides a Rust macro to determine the string name of a binding, type, const, or function
-
refute
Add a refute! macro(Elixir inspired). Essentially assert!(false).
-
select_indices
Iterators for taking multiple shared/exclusive references from a slice
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
struct_field
Derive macros for generating each field in a struct
-
escher
Self-referencial structs using the async/await transformation
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
diff-ba-rs
This library provides macros to get the difference of variables caused by a procedure
-
gen-iter
temporary util for creating iterators using generators
-
warnalyzer
Show unused code from multi-crate Rust projects
-
inner
The inner! macro descends into an enum variant. It's more flexible than try!() and unwrap(), and it works with your enum, too!
-
wurm
Non-fatal, strongly typed errors
-
foreign-types
A framework for Rust wrappers over C APIs
-
extended_matrix_float
Float trait for extended_matrix lib
-
multindex
Index slices with multiple const indices/ranges
-
tuple_length
Library for determining the length of a tuple
-
namedarg_rustc_macro
namedarg main package
-
fn-traits
Provides function traits like the standard library ones, but can be used in stable Rust
-
stringy
A tiny Rust crate for generating byte-sized enums that represent a fixed, ordered set of &str data
-
str-macro
The str!() macro, similar to vec![] but for strings
-
bidirectional_enum
Automatically generates conversions between an enum type and any other type
-
slid
Simple labeled IDs
-
unnest
Macros for an unnested control flow
-
ddd-rs
Domain-Driven Design (DDD) building blocks, for Rust applications
-
indiscriminant
A proc-macro for mapping between values and enum discriminants
-
if-none
Early break/continue/return if an optional expression evaluates to
None -
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
common-path
Finds the common prefix between a set of paths
-
spez
Macro to specialize on the type of an expression
-
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
-
multicall
Macro to simplify multiple operations or calls on a single object
-
rollercoaster
Extra iterators for grouping, sorting, arithmetic, and more
-
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
-
lens-rs
lens implemented in rust
-
hex_lit
Hex macro literals without use of hex macros
-
arrays
Collect an iterator into an array
-
quick-error2
A macro which makes error types pleasant to write
-
throttle_my_fn
Throttle your functions
-
current
A library for setting current values for stack scope, such as application structure
-
foreign-types-shared
An internal crate used by foreign-types
-
with-thread-local
A micro crate that simplifies a bit the use of the std macro
thread_local! -
exec-rs
Library 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
-
vg_errortools
Helpers for better error legibility in std/tokio io errors and error handling in main functions
-
heimdall_errors
Macros for From trait errors
-
beaver
A library for setting up Rust objects inspired by factory_bot
-
nyar-error
Shared error types for Nyar VM
-
teloc
Simple, compile-time DI framework for Rust
-
ed
Encode and Decode traits
-
debug-map-sorted
Sorted Debug impl for HashMap
-
slice-dst
Slice-based custom DSTs
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
bitsparrow
BitSparrow implementation in Rust
-
validify_types
Derive macros for the Validate trait of
validify -
assume
Macro for stating unsafe assumptions in Rust
-
value-enum
Macro for generating enums associated with values
-
lucene_query_builder
A procmacro derive crate to generate lucene query builder for Rust structs :
-
tch-tensor-like
Derive convenient methods for struct or enum of tch tensors
-
enum_index_repr
EnumIndexRepr provides a small macro which allows getting the index on an enum
-
static-cow
Cowat the type level: a framework of traits for writing types that are generic over ownership of their contents -
dynamic-struct
A derive macro for creating push-based reactive properties for structs with named fields
-
recursive_reference
This crate provides a way to walk on recursive structures easily and safely
-
pin-init
Safe pinned-initialization in Rust
-
derived
Derive macros for automating the boring stuff
-
evcxr
An Evaluation Context for Rust
-
once
This crate provides an assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
yui
An attribute reader generator for Rust
-
coercible_errors
Zero-cost error handling for generic traits
-
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…
-
negative-impl
Negative trait implementations on stable Rust
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
rog_anime
Types useful for translating images and other data for display on the ASUS AniMe Matrix display
-
phantasm
Small lib that helps with variance
-
giveup
User-geared error messages and hints
-
libcnb-data
Types for data formats specified in the Cloud Native Buildpack specification, used by libcnb.rs
-
wysk
A statically typed functional language with type inference, ad-hoc polymorphism, and an extensible operator syntax. Influenced by Rust, ML, and Haskell.
-
discrim
Construct enum variants from their tag
-
scratchstack-errors
Error trait for AWS/AWS-like services
-
moveslice
A one-function crate to move chunks in a slice around
-
simple-life
Simple async lifecycle trait and convenient macros
-
json_extract
This macro reduces boilerplate when using serde_json::Value variants when trying to get into a nested property
-
rvs-parser
Parser for Rvs - A library for defining and evaluating random variables using a simple DSL
-
precisej-printable-errno
Printable system call errors for nix
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
common-strings
Macro for storing common strings as enum variants
-
rsor
Reusable slice of references
-
arcerror
Provides thin wrappers around Arc<T> and Rc<T> where T: Error. Impls Error for both of these types. No unsafe, no dependencies.
-
wider_primitives
Wider primitive integer types
-
bswap
A Rust library for byte-swapping integers, pointers, and slices
-
finny
Finite State Machines with a procedural builder-style API and compile time transition checks
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
dungeon-cell
Cell and cell-like types that can store any static type
-
getargs-os
Provides a way for
getargsto parse OS strings -
munge
Macro for custom destructuring
-
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
-
common_regex_rs
Set of common regex for Rust
-
todo_using
A super small crate only exporting a single macro to "use" parameters
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
stable-pattern
Stable port of std::str::Pattern and friends
-
flatty-base
Flatty traits and primitives
-
do_while
A simple macro allowing clean 'do-while' loops in Rust
-
as_num
Checked conversions between Rust's numeric types
-
lup
A custom indexed loop macro library for Rust
-
precomputed-hash
A library intending to be a base dependency to expose a precomputed hash
-
abi_stable_derive_lib
Implementation detail of abi_stable
-
defer-lite
A lightweight high-performance implementation of Go's defer statement
-
rvs
A library for defining and evaluating random variables using a simple DSL
-
open-enum
An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
soup3-sys
Sys functions for the Rust bindings of the javacriptcore library
-
modifier
Fluid chaining APIs for both mutable ownership types
-
fixed-macro-types
Macro aliases used in the
fixed-macrocrate -
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
overload
Provides a macro to simplify operator overloading
-
cursor
A more free Rust-Iterator
-
intuple
Convert structs into/from tuples - recursive, ignore fields, distinct traits
-
stats_traits
Traits for collection-like types to calculate statistics
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
general_tools
This crate offers many functions for many different types of operations, such as operations with strings, numbers, files, and more!
-
devela
rust development helper & extension utilities
-
printrn
A macro to replace
println!(), that will replace all\nwith\r\n, e.g. for crossterm or other raw terminal work. -
polymorphic-constant
A macro to define a numerical constant in multiple types at once
-
another_pipe_macro
Adds a macro for composing functions
-
squeak
Library providing types allowing execution of callbacks in response to values being broadcast or mutated
-
icacher
A minimal crate for caching functions
-
nonicle
Tools for type-safe, canonical data representations
-
iter-scan
Iterator scan methods that don't suck
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
ghosts
Type-check non-existing
Phantomcode for Fun And Profit™ -
iter-flow
Functional programming utilities for Rust
-
digenum
An enum variant extractor
-
guest_cell
Storage space for externally-owned private data
-
impl_ops
Macros for easy operator overloading
-
rvs_derive
A helper macros implementation for Value Classes in Rust
-
autowired
Rust dependency injection
-
typename
Stable alternative to Rust's type_name intrinsic
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the *relative* difference
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
termcolor_output
Interface crate for styled output to termcolor through macro
-
try-blocks
macro to emulate the upcoming
tryblock feature on stable -
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
binhoc
Generate code for rust clients communicating with axum servers
-
koval
A very minimal IOC container
-
sfio-promise
Helper types and functions for making oo-bindgen future interfaces drop-safe
-
uniswap-utilities
A set of utility functions to interact with the uniswap protocol
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
kanaria
This library provides functions such as hiragana, katakana, half-width and full-width mutual conversion and discrimination
-
generic_static
Generic static variables in generic functions
-
cmd_error
Simple crate to print an error message and exit while unwrapping Options and Results
-
istring
A replacement for String that allows storing short strings of length up to sizeof<String>() - 1 without a heap allocation
-
throw
Efficiently add statically-calculated stack traces to errors
-
named-block
Macro implementing early-exit-from-any-block
-
morton-index
Types and functions for efficiently and easily work with Morton indices
-
unsafe-any-ors
Traits and implementations for unchecked downcasting
-
leetcode_utils
Boilerplate and helper functions for leetcode exercises
-
serde_str_helpers
Helpers for using serde with strings
-
ascii-read
BufRead-like methods for reading into anAsciiString -
gamma
Graph primitives and traversals for Rust
-
eager
Crate for eager macro expansion
-
endian_trait
A trait for Endianness conversions that can be implemented on most types
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
harled
Helper traits for developing derive macros similar to darling
-
extsort-iter
external sorting for all types for all iterators
-
sing_rs
Macros for generating STDIN/STDOUT interfaces to trait objects
-
string_mac
A lazy man's String macro
-
remove_macro_call
Attribute macro that removes a call of a function-like macro
-
reaktor
Reaktor
-
literally
Macro literals for members of std::collections
-
i2c-linux-sys
Linux i2c-dev ioctls
-
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
constrained_type
On the fly value objects in Rust
-
reax
A reactivity system for Rust that infers dependencies between functions
-
stack_epic_wallet_impls
Concrete types derived from libwallet traits
-
catch_panic
A helper macro for safe Java-Rust interop that "catches" Rust panics and rethrows them as Java exceptions
-
init-token
A crate for one-time safe initialization of static, without overhead
-
field-projection
Field projection experiment
-
enum_properties
A macro for declaring static properties on enum variants
-
mutexpect
Utility functions for determining potential point mutations in a genetic sequence and their statisical probability
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
exclusive_cell
A thread-safe, non-blocking, no-std cell that can only be accessed once
-
eprompt
Easy to use interactive prompt library. No complex structs or traits, just a few simple to use functions.
-
random-number-macro-impl
Generate random numbers quickly
-
tracked
A stringly-typed Error that includes
#[track_caller]information -
generic-matrix-impl
Simple implementation of generic matrices and their associated operations
-
incomplete
Provides incomplete!(), a compile-time checked version of unimplemented!()
-
containerof
Macros and traits facilitating the use of intrusive structures in Rust
-
ferrite-session
Session Types DSL for Rust
-
bruh_moment
Re-export of the anyhow crate, but with Bruh as the error type
-
kozo
syntax sugars for structs
-
qol
Quality Of Life functions and macros
-
dynamic-dispatch
Allows compiling generic functions that do not have generic parameters inside a library, specifying all the possible specializations for each generic type
-
quark
Types for manipulating numeric primitives at the bit level
-
typemap-ors
A typesafe store for many value types
-
rc-borrow
Borrowed forms of Rc and Arc
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
vector3d
A simple 3D vector type
-
rustc-hex
rustc-serialize compatible hex conversion traits
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
rs-utilities
Some utilities
-
recursion-schemes
cache-aware stack safe recursion (this is the really haskell brained one)
-
tartan-c-enum
Define FFI-safe enums that support unknown values
-
trait_enum
Easy enum wrapper that implements all traits that the wrapped objects implement
-
emboss
A small macro to embed metadata as an ELF/Mach-O section in your final binary
-
py-comp
A macro implementing a Python-like generator expression
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
custom-format-macros
Procedural macros for the custom-format crate
-
static_leak
Leak references with static lifetimes from static Mutexes and RwLocks
-
is_trait
Add a macro to check if a type implements a trait at runtime
-
to_unit
ToUnit; Any type to () syntax sugar
-
convertable
Non-reflexive version of From and Into
-
rexpr
Rust Json Object access Runtime
-
ctaphid-types
Data types for the CTAPHID protocol
-
iterx
Rust library that provides several functions on the Iterator trait not found in std::iter or Itertools
-
singleton-trait
Singleton trait for types with unique values and Erased type for zero-sized ownership proofs
-
oneline_str_enum
Format and parse enums as strings with macros
-
tupleops
Utility library to work with tuples
-
displaythis
derive(Display)
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
serde-mobile
Move-oriented sequence and map access types for serde deserializers
-
stringish
A smaller and easier copy-on-write string
-
flatty-portable
Flatty portable trait and primitives
-
phantom-enum
A simple macro library for creating phantom enums
-
engineer_derive
The engineer is a master builder! And this's it's derive
-
impl_serde_serialize_error
Macro for fast implementing error methods in serde::Serializer trait
-
eventually
Crate for using Event Sourcing in Rust applications
-
thread-scoped-ref
A library that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
flanker-assert-float
Assertions for floating-point numbers
-
dfdi-core
The core components of dfdi
-
elain
Set a type's minimum alignment with const generics
-
dyn_ord
Equality and ordering for trait objects
-
ref-map
Helper trait for Option and Result to map references
-
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…
-
flanker-assert-str
Assertions for strings
-
dfdi
Dependency For Dependency Injection
-
take-until
A take until extension for iterators
-
structx
Simulating anonymous struct and named arguments in Rust
-
macro-map
Closure-less
Result::map_errandOption::ok_or_else -
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
constany_blank
Convert any function to constant
-
srce
Self-Ref Cell Environments
-
market
Infrastructure for producers and consumers
-
try_as_traits
Traits to ease using enums whose sole purpose is to enumerate a set of types
-
ward
Provides a 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
-
try-drop
Batteries included error handling mechanisms for drops which can fail
-
never
A stable version of the unstable never type (!)
-
repr-with-fallback
Automatically generate From and Into impls for enums with custom discriminant values and a fallback variant. Useful for parsing when you might encounter unknown variants and want to hold on to their value.
-
mopa-maintained
My Own Personal Any: get your own Any with additional functionality
-
beetle-fraction
functions & structs for doing math with fractions
-
match_any
Provides a declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
is_option
Tell you if your type is an
Option<_> -
sharedlib
A cross-platform shared library loader
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
mownstr
Maybe Owned String
-
butcher
An easy way to interact with structs and enums wrapped in Cows
-
crashreport
Automatic GitHub crash reporting system for any Rust crate
-
tracerr
Custom compile-time captured error tracing
-
netlink-packet-generic
generic netlink packet types
-
east
Full-stack web library for island architecture
-
respan
Macros to erase scope information from tokens
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
namable_closures
Provides types and macros to create namable closure types
-
ascend
Make static strs from any string
-
advent_of_code_macro
An test generating macro for advent of code
-
cex
Checked exception simulation
-
init_with
Helper trait to initilize an array with a function
-
luhn
A Luhn validation library
-
async_fn
Collection of helper annotations and macros for concise and yet explicit
async fnsignatures -
appro-eq
Approximately equal traits and assertion
-
roopert
Another object-oriented toolkit for Rust
-
typed_macros
Adds typing to your macro's arguments, making it a lot less of a pain to deal with them
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
strided
Strided slices. This library provides two types
StridedandMutStridedas generalised forms of&[T]and&mut [T]respectively, where the elements are regularly spaced in memory… -
vet
Arbitrary type validation
-
reusable
Composable struct fields - reuse struct fields in other structs
-
boolinator
Provides the Boolinator trait, which lets you use Option and Result-style combinators with bools
-
sonic_serde_object
An enum that can contain different types of variables along with a lot of From implementations
-
dynerr
Macros for dynamic error handling
-
os-thread-local
OS-backed thread-local storage. This crate provides a
ThreadLocaltype as an alternative tostd::thread_local!that allows per-object thread-local storage, while providing a similar API… -
tamar
A super fast stream processing framework that somewhat mirrors Apache Flink's streaming primitives and is designed for simplicity
-
destruct
Destruct structs and enums for simpler combinator implementation
-
interior_mutability_pointer
A wrapper around
Rc<RefCell<T>>allowing immediate access to inner methods -
fuel-abi-types
Serializable type representation for working with the Fuel VM ABI
-
wireguard-nt
Safe idiomatic bindings to the Wireguard NT C library
-
serializable_enum
Two macros for implementing serialization / deserialization for enums containing no data variants
-
xmlwriter
A simple, streaming XML writer
-
byte_set
Efficient sets of bytes
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
adhesion
A set of macros for design by contact in Rust. The design of this library was inspired by D's contract programming facilities.
-
cereal
A simple data serialisation library
-
crossdylib
Cross-platform shared state across shared libraries/modules
-
funcmap_derive
Derivable functorial mappings for Rust
-
failchain
Ergonomic companion library for failure
-
imath-traits
Utility traits for VFX libraries to be agnostic over the math crates used
-
linreg
Calculates linear regresssions of two-dimensional data. Does not use stdlib, only depends on numeric traits.
-
word_iter
Simple Iterator over all words in a string
-
drogue-bazaar
A place to find tools for building your Rust application
-
static-cond
Macro for performing comparisons during macro expansion
-
error-utils
Some rust macros to simplify common error handling patterns
-
table
A specialized map for storing values of varying types
-
htmlescape
A library for HTML entity encoding and decoding
-
into_variant
Easily convert your types into the corresponding enum variant
-
enumx
Ad-hoc enum extension
-
easy-di
Simple dependency injection container for Rust
-
stuff
Stuffing things into pointers
-
derive_di
This crate is realized the dependency injection pattern
-
add-syntax
Attribute macros that prepend or append arbitrary syntax. Useful with
cfg_attr. -
fmt-derive
A more robust and versatile derive macro for Debug and Display
-
thinnable
Thin references to unsized types
-
shoulda_core
derive macro for test assertions
-
aspect-weave
An Aspect Toolkit for Rust
-
signrel
Trait expressing relationship between integers of different signedness
-
regexm
A Rust macro for writing regex pattern matching
-
introsort
Fast sorting compatible with #[no_std]. Also has (optional) support for efficient and robust sorting of floating point numbers. Currently, introsort only builds on nightly
-
array-lit
Macros for array and
Vecliterals with superpowers -
detach
helper type for being able to detach/reatach a member item
-
aerosol
Dependency injection with compile-time guarantees
-
check
Convenience assert!-like macros which return instead of panicking
-
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
env-var
Macros providing easier access to environment variables in rust
-
into-attr
The trait to generate dot attributes for graphviz
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
c-types
Re-exports of cross-platform types, gathered from libc and winapi
-
struple
Convert structures from and to tuples
-
coded
concrete error type with an
ErrorKindenum matching Google’s “canonical error codes” -
bitutils
Bitfield macro and utilities
-
ezing
Easing functions
-
float-derive
A crate that allows deriving Eq and Hash for types that contain floating points
-
bull-be-like-cow-mut
Cow’s non-clone-bearing counterpart with the power of mutation -
diesel_derives_traits
Traits for diesel_derives_extra
-
poison-guard
Utilities for maintaining sane state in the presence of panics and failures
-
cell-map
Many-layered 2D cellular generic map
-
rewrap
Result<Result<T, E>, F>->Result<T, F> -
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
vec-unpack
Creates a Vec containing the arguments. vecu! unpacks iterable variables marked with @.
-
axmac
Readable indexing macros for 1-4 dimensional data structures
-
const-slice
working with slices in compile-time constants
-
ex3-error
Underlying error types used over ex3 crates
-
never-say-never
The never type (the true one!) in stable Rust
-
stringreader
Provides a wrapper for strings so that they can be consumed via the std::io::Read trait
-
metastruct_macro
Abstractions for iterating and mapping over struct fields (proc macro crate)
-
activitystreams-traits
Traits for ActivityStreams 2.0 objects
-
libmw
Library for constructing a pipeline of middleware functions
-
traverse
Proof-of-concept trait for internal iterators called traversals
-
dir-assert
Assertion to compare directories recursively
-
gazebo_lint
A linter for the Gazebo Rust library
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
fn_once
This library provides a convenient derive macro for a once function
-
phantom_newtype
Lightweight newtypes without macros
-
cargo-verify
Prettier error messages for the verified crate
-
vec3
-
light_arena
A lightweight, placement based memory arena for types which are Sized + Copy. This crate requires nightly.
-
high_mem_utils
This crate provides a bunch of mem safe abstractions,some involving transmute
-
shorten
A collection of convenience functions, macros and traits to shorten repetitive code
-
tuple-fn
call functions and closures with tuple of arguments
-
surrealdb-obj-derive
a derive from surrealdb-schema-derive
-
custom-try
Macro to customize the behavior of
? -
iota-rs
A rust macro for other Go refuges who miss const blocks and iota
-
rattish
Cast between trait objects
-
chassis
Compile-time dependency injection framework
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
optfield
A macro that generates structs with optional fields
-
rewrite-impl-trait
Rewrites impl Trait as method generics
-
read-restrict
Restrict the number of bytes read from a reader
-
hypermod
Automatically build the module tree from the src/ dir
-
cw-optional-indexes
Index types for CosmWasm IndexedMaps where an item may or may not have an index
-
dyn_struct2
Construct dynamically sized types safely. Supports arbitrary unsized types, not just slices
-
postgres-mapper
Struct mapping for postgres
-
error-macro
error macro
-
squote
A clone of the quote crate that uses a String as its backing store
-
truthy
Check if a value is "truthy"
-
rustgie_types
Types for rustgie
-
bos
Flexible Borrowed, Owned or Shared (B.O.S.) smart pointers. Like std's Cow but with Rc/Arc and without the ToOwned requirement
-
omniswap
swap values between possibly-overlapping references
-
enum_variant_macros
Macros to generate From & TryFrom for enums
-
javascriptcore-rs-sys
Sys functions for the Rust bindings of the javacriptcore library
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
pytools-rs
Miscellaneous tools referenced by DSL compilers/scientific-computing toolchains
-
sid
Simple Id. Tiny crate providing strongly typed ids and an id-based vector.
-
takecell
A cell type which value can only be taken once
-
fstrings-rust
Python3 fstring interpolation in Rust
-
annotation-rs-beta
Compile-time annotation parser for rust
-
edisp
Dispatch-on-collect for Rust enums
-
byte-array-struct
Macro to create a byte-array backed struct
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
gumdrop
Option parser with custom derive support
-
macro-vis
Attribute for defining
macro_rules!macros with proper visibility and scoping -
dict
Exercise crate implementing real associative arrays, also known as dictionaries
-
aspect
An Aspect Toolkit for Rust
-
libc-stdhandle
Helper functions for retrieving stdin, stdout, stderr
-
split-optional
It split from a source
strtoOption<&'a str>per an element -
with_locals-proc_macros
TODO!
-
dyn-dyn
Flexible trait object downcasting using ptr_metadata
-
dbin
Regex-like utility for parsing and rendering binary data
-
boost-rs-macros
Boost-rs's proc macros
-
unwrap-sugar
Just a simple sugar for unwrapable expressions
-
enum_cycling
Small macro for working with enums
-
vec2
-
oneline-eyre
A fork of
simple-eyrewhich outputs errors on a single line -
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
en
The easiest numeric traits!
-
flow-control
Declarative macros for common flow-control use cases such as break, continue, and return
-
deptypes
Dependent types
-
mungos_rocket
Helper macro for generating routes with Mungos
-
left-pad
Provides left-padding for strings
-
hxdmp
A small utility to create hexdump output from byte slices
-
internship
Interned string and more
-
append_to_string
The append_to_string!() macro. Appends every occurance of a literal within a struct or on its own with a .to_string().
-
call-by
A trick to parameterize functions and traits by the calling convention of their arguments and results
-
asyncsync
Runtime-agnostic synchronization primitives for asynchronous Rust
-
derive-for
Macro for defining structs using the same derive procedural macros
-
public
A attribute macro used to mark struct/union and its fields as public
-
boulder
Like a builder, but heavier
-
named-tup
Create named tuples using the tup!() macro
-
nbytes
Rust compile-time evaluation of byte unit conversions
-
try_ops
try catc... ops macro
-
iterator-ext
An extension to Rust's Iterator
-
kinder
Kinder is a small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
oops
Lightweight error-handling. Provides
Option<T> -> std::io::Result<T>. -
endian-type
Type safe wrappers for types with a defined byte order
-
dbgonly
The dbg macro, but only when debug_assertions are set
-
kaguya_rs
Functional Programming tools and ADTs
-
chainer
A cursed crate that allows for global call chaining with access to chained function results
-
ast2str-lib
A crate for pretty-printing ASTs and other recursive data structures
-
svgmacro
Write any SVG easily from Rust!
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
entwine
Generic slice-like interface for operating on multiple slices at the same time
-
arraytools
A variety of helpful methods for working with fixed-size arrays
-
extracterr
helper type and traits for passing context through dyn Error trait objects
-
transition-table
transition table utilities for keyword parser
-
miette_helper
Crate providing helper macros for miette
-
fastperm
A dead-simple, extreme fast permission flag system for Rust with no dependencies
-
partialdebug
Derive Debug partially
-
envload
Automatically fill structs from env variables
-
ilyvion-util
Collection of utility functions and types for use in my personal projects
-
fixed_len_str
A procedural macro for create a smart pointer to str backed by a fixed size array,with the size given by the tokens
-
multi-structs
Macro for generating a merged struct from multiple sub-structs
-
disuse
The way to notify the implementation which return value is disuse
-
bstringify
stringify! that yields byte string literals instead
-
bitfields
Helpers for storing sub-byte enums in primitive types
-
parametrizer
A simple, safe crate for parsing properly-formatted math strings representing parametric functions into Rust functions
-
enum_index
Trait and macros for extracting Enum variant index
-
try-partialord
Safe failable sort, min, max, binary_search functions for PartialOrd. No need to wrap f32, f64 to sort any more.
-
prost-msg-id
prost impl message id
-
range_check
Rust library with bounds-checking and range helpers
-
enum-utils-from-str
Code generation for mapping from strings to arbitrary values
-
array_init_macro
Simple initialization macro for arrays
-
type_hash
Generate a hash for a Rust type. The primary use-case for this crate is for detecting differences in message types between versions of a crate. The
TypeHashtrait is implemented… -
struct-variant
Minimal helper macro to generate an enum out of a list of structs
-
peck-lib
A set of library and type functions
-
into_string
Helper crate to convert values into strings avoiding extra allocations
-
c_str
The old c_str functions
-
try-from-discrim
#[derive(TryFrom / From)] using enum discriminants, with fallback support
-
tuple-map
map methods for tuple
-
anyinput-core
An internal helper library of anyinput
-
casual
Simple crate for parsing user input
-
tocall
This crate tries to provide useful tool modules in a more concise API
-
ibuilder_derive
Interactive builder for Rust types
-
rovv
provide the anonymous row type (poor-man's row polymorphism) in rust
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
railroad
A library to create syntax-diagrams as Scalable Vector Graphics
-
yggdrasil-ir
Yggdrasil Language IR
-
haz
A thin abstraction over polymorphic environments
-
arcm
Provides a macro for more concise Arc<Mutex<_>> creation
-
enum_delegate_lib
Internal macro implementations for enum_delegate - use to implement your own macros
-
enum_to_enum
Derives possibly effectful conversions between enums
-
match_cfg
A convenience macro to ergonomically define an item depending on a large number of
#[cfg]parameters. Structured like match statement, the first matching branch is the item that gets emitted. -
nearly_eq
Nearly(Approximately) equal traits and assertion
-
instrs
A derive macro for (de)serializing enums into/from bytecode
-
trigram
Trigram-based string similarity for fuzzy matching
-
kv-derive-impl
Derive struct conversions from and to key-value vectors
-
fast-map
Map-like structs
-
buf-read-ext
Trait extending anything that implements BufRead with stream_until_token()
-
loop_chain
Macro for writing nested Loop expressions
-
byte-tools
Bytes related utility functions
-
macro_pub
polyfill proc-macro for visibility scoped macros
-
ohkami_macros
proc macros for ohkami
-
whiteout
Provides macros that erase the type of any value into an impl Trait for a given trait
-
derive-merge-struct
A derive macro to partially update a named struct
-
almost
A crate for comparing floating point numbers
-
wasmium_errors
Common error handling for the Wasmium crate ecosystem
-
tupletools
Utility functions for tuples
-
dfdi-macros
Macros for dfdi
-
apply_attr
A syntax extension providing higher-order attributes to Rust
-
path_semantics_std
A Rust type checked implementation of the standard dictionary of path semantics using constrained functions
-
roopert_macro_root
Another object-oriented toolkit for Rust (macro)
-
tuple_utils
A set of utilities to enable higher level operations over tuples
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
zhi_enum
derive macros to easily use enum
-
serbia
No-fuss big arrays for Serde
-
repeated
Allows you to repeat a block of code a number of times
-
ownref
Provide the smart pointer type that bundles the data with its owner
-
lazy_transducer
Lazy, parallel, indexable, generic data iterators
-
trace-error
Extensions to Rust's error system to automatically include backtraces
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
astr
A const lenght stack str
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
endianrw
Reading and writing numbers with specific endianness
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
split-iter
Allows splitting of iterators
-
brain_flak_macro
Brain-Flak macro
-
fb_cloned
Provides a clone macro
-
lifted
Higher-kinded types in Rust
-
rabbithole
JSON:API Data Structure & Query implementation
-
primitive_enum
Little utility for dealing with enums no extra data in variants
-
optargs
Easily create macros for functions with optional arguments
-
eso
Type machinery to build Cow-like containers
-
close
Trait + smart pointer for manual object destruction
-
chain_linq
An implementation of .NET's LINQ in rust as a declarative macro
-
cute
A macro for Python-esque comprehensions
-
loop-code
Code repeating macro
-
scoped-sleep
RAII sleep
-
dyn_partial_eq
PartialEq macros for trait objects
-
format-macro
Format procedural macro
-
peepmatic-souper
Converting Souper optimizations into Peepmatic DSL
-
sapio-ctv-emulator-trait
Emulator Trait for mocking out CTV with other logic, trait separate to avoid pulling in tokio to compiler
-
itermap
Iterator tools for maps (
HashMap,BTreeMap, etc.) -
cmd-macro
makes std::process::Command simple to use
-
noise_fn
Some simple noise functions and traits to allow easy integration with your own
-
static_slice
Macro for creating static slices of arbitrary types
-
asserts-rs
Asserts utilliy macros for Rust
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
rhook
Hook libc functions with an easy API
-
named_fn
Create typed functions that can be added as generics
-
rudeboy
Rlua User Data Extension Boy - Derive/attr macros and traits for easily exporting user data to RLua
-
tidy-builder
tidy-builder is a builder generator that is compile-time correct
-
fn_macro
函数宏
-
newtype-enum
Traits to convert between enums and their variant types
-
gitrevset
A domain-specific-language to select commits in a git repo. Similar to Mercurial's revset.
-
hazmat
A collection of helpers for working with hazardous materials in Rust crates
-
snaptest
Dead simple snapshot testing
-
unwrap_or
Four easy unwrap Result and Option macros that allow for any inline-scoped code for things like return, continue, and break
-
ordered_iter
Ordered iterators
-
iterator-sorted
Stable functions for checking iterator sorting
-
spidermeme
Traits to test for type equality and type inequality
-
enum_macro
Useful macro for enum
-
tulip-arrform
tulip fork of arrform
-
units
Units of Measure for Rust. Easy to use, type-safe and customizable.
-
xplm-sys
Low-level bindings for the X-Plane plugin SDK
-
error-utils-derive
Some rust proc-macros to simplify common error handling patterns
-
souper-ir
A library for manipulating Souper IR
-
conform
Macro to transform struct string fields in place
-
multi_try
Safely combine results
-
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!,include!, orconcat_idents!) -
ad-hoc-iter
Ad-hoc exact size owning iterator macro and other optional utils
-
ndless-static-vars
Rust library for storing static, program-wide parameters for Ndless
-
garfield
Garfield provides cat-egory theory abstractions
-
nes
New Error System for rust
-
assert_cfg
static assertions for crate features, with descriptive errors
-
bset
Fast and compact sets of bytes or ASCII characters
-
nommy
Type based parser
-
pluck
Extract values conveniently
-
debug-cell
A clone of the standard library’s
RefCelltype with extra debugging support in non-release builds. Whenever a borrow error happens the current locations of where known borrows were created will be printed out as well. -
buffer
Safe, write-only, generics-free buffer abstraction
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
tagged-pointer-as-enum
A set of structs, traits and macros to implement tagged pointers
-
power-assert
Power Assert in Rust. Provides better assertion message.
-
mdo
Monadic do notation for rust using macro and duck typing
-
rjson
A minimal json parser
-
rstring-builder
String builder type
-
derive_builder_macro_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
momo
A procedural macro to de-monomorphize generic methods
-
swahili-dsl
A Swahili-based DSL made for educational purposes
-
normalize_interval
Normalizing interval library
-
sortby
adds convenient sort functions for Iterators
-
derive-enum-from-into
Derive for From and TryInto for enums with single fields
-
trait_cast_impl_rs
Proc-macro implementation for the 'trait_cast_rs' crate
-
clonesure
A helper macro to create closures which will clone its environment
-
easy_stats
A simple rust package to perform basic descriptive stats on a data set
-
result-inspect
Adds the missing Result::inspect() function
-
from_iter
Initialize arrays from iterators
-
marigold-impl
Internal logic for the marigold language
-
big_s
Rust’s missing
Stringliteral -
tuple-conv
Allows converting tuples of one element to vectors
-
generic-str
Annoyed that Rust has two string types? Well it doesn't any more
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
thisisplural
#[derive(Plural)] for creating frictionless new types with a Vec, HashMap, etc
-
input-stream
IO streams similar to C++'s streams
-
tonic-error
Derive trait to allow passing of custom errors through tonic Status responses
-
standalone-proc-macro2
Fork of proc-macro2 that uses rustc-ap-proc_macro so as to remove the rustc dylib dependency
-
vec-utils
vector utilities
-
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.
-
indent
Functions for indenting multiline strings
-
project-uninit
Macros for safe references to and initialization of fields in MaybeUninit structs
-
borked
Simple and convienient error handling library for rust
-
drop_ok
.drop_oksyntax sugar forResult. It’s instead of.map(|_|()). -
from_as_file
Traits to Read and write types that implement serde Serialize and deserialize to files
-
bounded-static-derive
Macro to derive ToBoundedStatic and IntoBoundedStatic traits
-
bitmatch
A macro to allow matching, binding, and packing the individual bits of integers
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
tyname
Retrieve type names during program execution on stable Rust
-
serde_type_name
lookup name of type for any struct or enum that derives serde Serialize
-
pinned-init
Library to facilitate safe pinned initialization
-
unborrow
Macro for calling a &mut self method with transient &-borrows of self in the parameters
-
improved_slice_patterns
A tiny crate that provides macros to help matching on Vecs and iterators using the syntax of slice_patterns
-
stringly_conversions
A crate helping to convert to/from various representations of strings
-
collected
Summation, product, maximum and more special collectors for Rust iterators
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
error-chain-mini
error-chain for minimalist
-
array-fu
Construct arrays using simple syntax
-
byte-slice
Byte slice manipulation macros
-
log_err
Log error messages from Unwrap and Expect with log crate
-
qcomms
qcomms is a small library that offers a simple, zero-cost message passing trait. no async-trait
-
for_each_repeat
Iterator::for_eachthat can repeat current iteration -
join-lazy-fmt
Lazy
separator.join(iterable)method andlazy_format!for Rust -
aether_primitives
Helpers for common SDR and signal generation operations
-
assert_into
For when writing .try_into().unwrap() feels too long
-
float-lerp
Lerp and InverseLerp functions for floats
-
zkp-macros-decl
Procedural macros
-
wrapped_enum
Useful macro to wrap existing types in an enum (common use for quick error handling)
-
interruptor
Collection of functions generating Unix process signal receivers for use in the Crossbeam Channel select! macro
-
mods
Simpler module declaration
-
tooples
Array functions for tuples
-
tuple_macro
Library for determining the length of a tuple
-
abstract_integers
Defining specification-friendly bounded natural integer types
-
binhoc_core
Generate code for rust clients communicating with axum servers
-
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
bounded_types
Provides a type representing bounded integers, implemented using const generics
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
rawslice
Reimplementation of the slice iterators, with extra features. For example creation from raw pointers and start, end pointer accessors.
-
slip
A hassle-free utility to encrypt error handling strings in your public binaries to protect your business logic
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
inline-const
Inline consts implemented as a macro
-
makeit
Compile-time checked Builder pattern
derivemacro with zero-memory overhead -
once-cell-regex
This crate just gives you the
regexmacro from theonce_celldocs! -
slice-ext
Useful extensions to slices and iterable types
-
roopert_macro_common
Another object-oriented toolkit for Rust (common data)
-
read-byte-slice
An iterator over chunks of bytes as slices from an underlying reader
-
negate
Attribute macro that generates negated versions of functions that return booleans
-
targets
Some helpers to get you started with declarative programming in Rust
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
phtm
Re-exports for common uses of
PhantomData -
cargo-cargo-derive-ipc-schema-for-swift
Code-generator to IPC to Swift
-
librping
Fast Rust ping library
-
algebloat_macros
RustAlgebloat utility macros
-
validated-slice
Helper macros to implement std traits for custom validated slice types
-
timed
Macros to time function execution
-
tapir
Adding tapping functionality to rust
-
apply_method
Allows you to apply any function given as a parameter to the object
-
string_morph
string_morph is a library of string case transformations with an emphasis on accuracy and performance. The case conversions are available as functions as well as traits on String types.
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
foreignc_util
Provides utilities for error handling in foreignc
-
typesets
Enables generating subtypes and supertypes of a given type via derive macros
-
fileslice
Slices of files
-
from_as
Traits and derive macros to Read and write types that implement serde Serialize and deserialize to files
-
fmt-cmp
Traits and utilities for lexicographically comparing values in their
Displayrepresentations -
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
predicate
Use enum to predicate something, support & and | operator
-
dummy-rustwlc
A dummy version of the functions defined in rust-wlc, to be used in testing and for travis builds
-
enum_array
A small crate adding a macro that creates a constant array containing all the items of the enum
-
tyenum
Attribute macro for type enums
-
drop_some
.drop_somesyntax sugar forOption. It’s instead of.map(|_|()). -
trait-union
Stack-allocated trait objects