-
bitflags
A macro to generate structures which behave like bitflags
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
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.
-
once_cell
Single assignment cells and lazy values
-
thiserror
derive(Error)
-
windows-targets
Import libs for Windows
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
memoffset
offset_of functionality for Rust structs
-
anyhow
Flexible concrete Error type built on std::error::Error
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
scopeguard
RAII scope guard that will run a given closure when it goes out of scope, even if the code between panics (assuming unwinding panic). Defines the macros
defer!
, `defer_on_unwind… -
bytes
Types and traits for working with bytes
-
tinyvec_macros
Some macros for tiny containers
-
pin-utils
pinning
-
typenum
type-level numbers evaluated at compile time. It currently supports bits, unsigned integers, and signed integers. It also provides a type-level array of type-level numbers, but its…
-
async-trait
Type erasure for async trait methods
-
darling
A proc-macro library for reading attributes into structs when implementing custom derives
-
rustversion
Conditional compilation according to rustc compiler version
-
pin-project
safe and ergonomic pin-projection
-
zerocopy
zero-copy parsing and serialization
-
libloading
Bindings around the platform's dynamic library loading primitives with greatly improved memory safety
-
static_assertions
Compile-time assertions to ensure that invariants are met
-
powerfmt
powerfmt
is a library that provides utilities for formatting values. This crate makes it significantly easier to support filling to a minimum width with alignment, avoid heap… -
overload
macro to simplify operator overloading
-
ordered-float
Wrappers for total ordering on floats
-
foreign-types
A framework for Rust wrappers over C APIs
-
opaque-debug
Macro for opaque Debug trait implementation
-
indoc
Indented document literals
-
num-conv
num_conv
is a crate to convert between integer types without usingas
casts. This provides better certainty when refactoring, makes the exact behavior of code more explicit, and allows using turbofish syntax. -
async-stream
Asynchronous streams using async & await notation
-
lazycell
providing a lazily filled Cell struct
-
quick-error
A macro which makes error types pleasant to write
-
cexpr
A C expression parser and evaluator
-
derivative
A set of alternative
derive
attributes for Rust -
tap
Generic extensions for tapping values in Rust
-
predicates
boolean-valued predicate functions
-
inout
Custom reference types for code generic over in-place and buffer-to-buffer modes of operation
-
dyn-clone
Clone trait that is object-safe
-
funty
Trait generalization over the primitive types
-
foreign-types-shared
An internal crate used by foreign-types
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
float-cmp
Floating point approximate comparison traits
-
io-lifetimes
A low-level I/O ownership and borrowing library
-
peeking_take_while
Like
Iterator::take_while
, but calls the predicate on a peeked value. This allows you to useIterator::by_ref
andIterator::take_while
together, and still get the first value… -
arrayref
Macros to take array references of slices
-
cast
Ergonomic, checked cast functions for primitive types
-
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]
checks -
scoped-tls
standard library’s old
scoped_thread_local!
macro for providing scoped access to thread local storage (TLS) so any type can be stored into TLS -
doc-comment
Macro to generate doc comments
-
fragile
wrapper types for sending non-send values to other threads
-
downcast
Trait for downcasting trait objects back to their original types
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
async-recursion
Recursion for async functions
-
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. -
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
predicates-core
An API for boolean-valued predicate functions
-
void
The uninhabited void type for use in statically impossible cases
-
const-random
compile time random number generation
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
outref
Out reference
-
option-ext
Extends
Option
with additional operations -
approx
Approximate floating point equality comparisons and assertions
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
precomputed-hash
intending to be a base dependency to expose a precomputed hash
-
fallible-streaming-iterator
Fallible streaming iteration
-
rawpointer
Extra methods for raw pointers and
NonNull<T>
. For example.post_inc()
and.pre_dec()
(c.f.ptr++
and--ptr
),offset
andadd
forNonNull<T>
, and the functionptrdistance
. -
snafu
An ergonomic error handling library
-
psm
Portable Stack Manipulation: stack manipulation and introspection routines
-
matches
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
enumflags2
Enum-based bit flags
-
ouroboros
Easy, safe self-referential struct generation
-
typed-builder
Compile-time type-checked builder derive
-
smol_str
small-string optimized string type with O(1) clone
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
if_chain
Macro for writing nested
if let
expressions -
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
inventory
Typed distributed plugin registration
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
arrow-array
Array abstractions for Apache Arrow
-
fixed-hash
Macros to define custom fixed-size hash types
-
psl-types
Common types for the public suffix implementation crates
-
beef
More compact Cow
-
atomic
Generic Atomic<T> wrapper type
-
bit_field
bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive
-
derive_builder_macro
Rust macro to automatically implement the builder pattern for arbitrary structs
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
crossterm_winapi
WinAPI wrapper that provides some basic simple abstractions around common WinAPI calls
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
unreachable
code optimization hint in stable rust
-
shellexpand
Shell-like expansions in strings
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
validator_types
Basic type for validator and validator_derive
-
send_wrapper
implements a wrapper type called SendWrapper which allows you to move around non-Send types between threads, as long as you access the contained value only from within the original thread…
-
compiler_builtins
Compiler intrinsics used by the Rust compiler. Also available for other targets if necessary!
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
const_fn
A lightweight attribute for easy generation of const functions with conditional compilations
-
rtoolbox
functions for other crates, no backwards compatibility guarantees
-
dlib
Helper macros for handling manually loading optional system libraries
-
mac
A collection of great and ubiqutitous macros
-
enum-ordinalize
enables enums to not only obtain the ordinal values of their variants but also allows for the construction of enums from an ordinal value
-
inherent
Make trait methods callable without the trait in scope
-
educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits
-
glib
Rust bindings for the GLib library
-
error-code
Error code
-
maybe-uninit
MaybeUninit for friends of backwards compatibility
-
iri-string
IRI as string types
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
enumn
Convert number to enum
-
standback
New standard library, old compiler
-
similar-asserts
assert_eq! like macros with colorized diff output
-
valico
JSON Schema validator and JSON coercer
-
field-offset
Safe pointer-to-member implementation
-
derive-where
Deriving with custom trait bounds
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
retry
retrying operations that can fail
-
ffi_helpers
help make working with FFI easier
-
better_scoped_tls
scoped-tls, but with good error message
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
value-bag-sval2
detail for value-bag
-
maybe-owned
MaybeOwned
(andMaybeOwnedMut
) type similar to std’sCow
but it implementsFrom<T>
andFrom<&'a T>
and does not requireToOwned
-
collection_literals
macros for initializing std::collections
-
sealed
Macro for sealing traits and structures
-
bitfield
macros to generate bitfield-like struct
-
cargo_toml
Cargo.toml
struct definitions for parsing with Serde -
sptr
Strict Provenance Polyfill
-
take_mut
Take a T from a &mut T temporarily
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
macro_rules_attribute
Use declarative macros in attribute or derive position
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
inlinable_string
inlinable_string
crate provides theInlinableString
type – an owned, grow-able UTF-8 string that stores small strings inline and avoids heap-allocation – and theStringExt
trait… -
try_map
try_map
andflip
methods forOption
. These allow more ergonomic error handling when mapping functions that returnResult
overOption
. -
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
environmental
Set scope-limited values can can be accessed statically
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
ambient-authority
Ambient Authority
-
typed-builder-macro
Compile-time type-checked builder derive
-
kube-core
Kube shared types, traits and client-less behavior
-
dyn-clonable
Attribute wrapper for dyn-clone
-
bounded-collections
Bounded types and their supporting traits
-
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
constcat
concat! with support for const variables and expressions
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
encoding_index_tests
Helper macros used to test index tables for character encodings
-
thiserror-core
derive(Error)
-
destructure_traitobject
Unsafe helpers for working with raw trait objects. (Forked from traitobject)
-
writeable
A more efficient alternative to fmt::Display
-
backon
Retry with backoff without effort
-
nonempty
Correct by construction non-empty vector
-
hash-db
Trait for hash-keyed databases
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
failsafe
A circuit breaker implementation
-
ownedbytes
Expose data as static slice
-
ignore-result
Adds a
Result<_, _>.ignore()
method to ignore the return value of a function call without panicking in case of error -
thin-slice
An owned slice that packs the slice storage into a single word when possible
-
net2
Extensions to the standard library's networking types as proposed in RFC 1158
-
joinery
A small crate for generically joining iterators with a separator
-
simple-mermaid
Mermaid diagrams RustDoc integration
-
qualifier_attr
Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items
-
mutually_exclusive_features
Macros to check that only none or one of a set of features is enabled at a time, as known as mutually exclusive features
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
hex_lit
Hex macro literals without use of hex macros
-
io-extras
File/socket handle/descriptor utilities
-
virtue
A sinless derive macro helper
-
vcell
Cell
with volatile read / write operations -
frunk
developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
tt-call
Token tree calling convention
-
aws-smithy-types-convert
Conversion of types from aws-smithy-types to other libraries
-
assert_approx_eq
assert approximately equal
-
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
float-ord
A total ordering for floating-point numbers
-
ghost
Define your own PhantomData
-
auto_enums
allow multiple return types by automatically generated enum
-
orchestra
Generate an orchestra of subsystems from a single struct
-
az
Casts and checked casts
-
fatality
extension to
thiserror::Error
-
async-once-cell
Async single assignment cells and lazy values
-
io-close
An extension trait for safely dropping I/O writers such as File and BufWriter
-
devise
devising derives and other procedural macros
-
human-panic
Panic messages for humans
-
eager
macro expansion
-
drop_bomb
A runtime guard for implementing linear types
-
impl-more
Concise, declarative trait implementation macros
-
konst
Const equivalents of std functions, compile-time comparison, and parsing
-
custom_derive
(Note: superseded by
macro-attr
) This crate provides a macro that enables the use of custom derive attributes -
prctl
This package provides safe abstraction to the linux prctl() interface. Some functions may be architecture-specific.
-
kuchikiki
(口利き) HTML tree manipulation library
-
tantivy-common
common traits and utility functions used by multiple tantivy subcrates
-
gumdrop
Option parser with custom derive support
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
iter-read
A Read implementation for iterators over u8 and related types
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
conv
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
uninit
A collection of tools for a safer usage of uninitialized memory
-
separator
Formats numbers into strings with thousands separators for readability
-
unsafe-any-ors
Traits and implementations for unchecked downcasting
-
lazy_format
lazily formatting values for later
-
by_address
Wrapper for comparing and hashing pointers by address
-
cooked-waker
A safe interface for creating async Wakers
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
polars-utils
Private utils for the Polars DataFrame library
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
bencher
port of the libtest (unstable Rust) benchmark runner to Rust stable releases. Supports running benchmarks and filtering based on the name. Benchmark execution works exactly the same…
-
cascade
Dart-like cascade macro for Rust
-
atomic_refcell
Threadsafe RefCell
-
display-error-chain
Formats a standard error and its sources
-
rustler
Safe Rust wrappers for creating Erlang NIF functions
-
mint
Math interoperability standard types
-
choice
Similar to
either
but supports an unbounded number of variants -
la-arena
index-based arena without deletion
-
nonmax
Numeric types that cannot hold maximum values
-
volatile
wrapper types for raw pointers
-
arr_macro
Initialize arrays with ease!
-
enum_primitive
Macro to generate num::FromPrimitive instances for enum that works in Rust 1.0
-
metered
Fast, ergonomic metrics for Rust!
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
variant_count
Derive macro for enum which adds to it the count of variants
-
never-say-never
The never type (the true one!) in stable Rust
-
ext-trait
Annotation to easily define ad-hoc / one-shot extension traits
-
panic-message
Get a panic message from a panic payload
-
reborrow
Emulate reborrowing for user types
-
tryhard
Easily retry futures
-
unwind_safe
Readable unwind-safe code thanks to a try-finally-looking builder pattern
-
stable-pattern
Stable port of std::str::Pattern and friends
-
konst_macro_rules
detail of the konst crate
-
std_prelude
prelude that the rust stdlib should have always had
-
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!
,include!
, orconcat_idents!
) -
static_assertions_next
Compile-time assertions to ensure that invariants are met
-
binread
helping read structs from binary data using ✨macro magic✨
-
rustdoc-types
Types for rustdoc's json output
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
unsafe-any
Traits and implementations for unchecked downcasting
-
error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
bevy_reflect
Dynamically interact with rust types
-
mutate_once
Interior mutability, write-once and borrowable as plain &T
-
derive_destructure2
Destructure structs that implement Drop
-
jod-thread
std::thread which joins on drop by default
-
result
Helpers for dealing with nested Result and Option types
-
flex-error
Flexible error definitions using macros and traits
-
anymap
A safe and convenient store for one value of each type
-
moveit
safe, in-place construction of Rust (and C++!) objects
-
with_locals
Function attribute to return references to locals by using CPS
-
thiserror-no-std
derive(Error)
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
binstring
Binary strings
-
better_any
Type id and Any for non static types
-
os-thread-local
OS-backed thread-local storage. This crate provides a
ThreadLocal
type as an alternative tostd::thread_local!
that allows per-object thread-local storage, while providing a similar API… -
typify-impl
typify backend implementation
-
parity-send-wrapper
implements a wrapper type called SendWrapper which allows you to move around non-Send types between threads, as long as you access the contained value only from within the original thread…
-
rxml_validation
Plumbing crate for rxml and rxml_proc crates
-
copyless
Ways to eliminate memcpy calls when using the standard library
-
swift-bridge-build
Parse Rust files for swift-bridge modules and generate the corresponding Swift and C code for them
-
typify
JSON schema to rust type code generator
-
userfaultfd
Rust bindings for the Linux userfaultfd functionality
-
string-builder
string builder type
-
octseq
Abstractions for types representing octet sequences
-
fallible_collections
adds fallible allocation api to std collections
-
polonius-the-crab
Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust
-
never
A stable version of the unstable never type (!)
-
readonly
Struct fields that are made read-only accessible to other modules
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
auto_ops
Macros for easy operator overloading
-
unwinding
in Rust and for Rust
-
simple-error
error type backed by a string
-
enum-display
A macro to derive Display for enums
-
nougat
(lifetime) GATs on stable Rust
-
cynic-codegen
Procedural macro code generation for cynic - a code first GraphQL client for Rust
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
lending-iterator
Fully general lending iterators in stable rust: windows_mut!
-
extern-c
Convert a zero-sized closure into an
extern "C" fn(…)
pointer -
trait-set
Support for trait alias feature on stable Rust
-
concat-with
Extend the function of the
concat!
macro instd
-
codegen
generating Rust code
-
size
expressing, formatting, and interacting with file sizes
-
recursion
cache-aware stack safe recursion
-
cargo-manifest
Helper crate to parse and manipulate manifests -
Cargo.toml
files -
st-map
Runtime for a stack-alocated map
-
trait-variant
working with impl traits in Rust
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
stdext
Extensions for the Rust standard library structures
-
join-lazy-fmt
Lazy
separator.join(iterable)
method andlazy_format!
for Rust -
rbtag
A procedural macro to add build DateTime and git commit information at compile time
-
cargo-emit
Talk to Cargo easily at build time
-
aspect
Toolkit for Rust
-
option-operations
Traits and auto-implementations to improve arithmetic operations usability when dealing with
Option
s -
loupe
Profiling tool for Rust
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
traitobject
Unsafe helpers for working with raw trait objects
-
ff_ce
building and interfacing with finite fields
-
atomic_float
Floating point types which can be safely shared between threads
-
generational-arena
A safe arena allocator that supports deletion without suffering from the ABA problem by using generational indices
-
async_fn
Collection of helper annotations and macros for concise and yet explicit
async fn
signatures -
try_match
An expression macro to match a pattern and return the bound variables in
Result
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
take-until
A take_until extension for iterators
-
ra_ap_stdx
TBD
-
buildstructor
Macro to derive a builder from a constructor function
-
erasable
Type-erased thin pointers
-
boolinator
trait, which lets you use Option and Result-style combinators with bools
-
with_locals-proc_macros
TODO!
-
strck
Checked owned and borrowed strings
-
type-layout
Derivable trait to view the layout of a struct, useful for debugging
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
genawaiter-macro
Convenience macros for generators (genawaiter)
-
easy-cast
Type conversions which are expected to succeed
-
cstr-argument
A trait for converting function arguments to null terminated strings
-
str-macro
The str!() macro, similar to vec![] but for strings
-
rsb_derive
An opinionated macro implementation for Rust struct builder pattern with compile-time validation
-
ungrammar
A DSL for describing concrete syntax trees
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
dispose
wrapper for values that must be consumed on drop
-
safe-transmute
A safeguarded transmute() for Rust
-
nutype
The newtype with guarantees
-
condtype
Choose types at compile-time via boolean constants
-
ra_ap_limit
TBD
-
with_builtin_macros-proc_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!
,include!
, orconcat_idents!
) -
modifier
Fluid chaining APIs for both mutable ownership types
-
func_wrap
Helper crate for procedural macro authors that wish to duplicate some received function inside its body, so as to be able to wrap with some prologue, epilogue, cache-ing, etc
-
aide
A code-first API documentation library
-
random-number
Generate random numbers quickly
-
aspect-weave
An Aspect Toolkit for Rust
-
const-cstr
Create static C-compatible strings from Rust string literals
-
rust_info
Extracts the current rust compiler information
-
include-flate
A variant of include_bytes!/include_str! with compile-time deflation and runtime lazy inflation
-
tstr
Type-level strings
-
core_extensions
Extensions for core/std library types, and other miscelaneous features
-
piston-float
Traits for generic floats in game development
-
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
scoped-tls-hkt
more flexible version of
scoped-tls
, allowing the following additional features: Storage of references to dynamically sized types. Storage of mutable references. Storage of… -
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
metered-macro
Fast, ergonomic metrics for Rust!
-
inline-array
efficient immutable inlinable byte array
-
match_opt
A macro for turning a partial match into a full match returning an option
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
enum_index
Trait and macros for extracting Enum variant index
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
anyerror
A type of any error for transport
-
ordered_iter
Ordered iterators
-
abi_stable_shared
detail of abi_stable
-
re_tuid
128-bit Time-based Unique Identifier
-
re_error
Helpers for handling errors
-
exponential-backoff
A small and flexible backoff function
-
byteorder_slice
Byteorder like crate for &[u8]
-
as-any
provide the AsAny trait
-
futures-enum
#[derive(Future, Stream, Sink, AsyncRead, AsyncWrite, AsyncSeek, AsyncBufRead)] for enums
-
pyo3-polars
Expression plugins and PyO3 types for polars
-
const-default
A const Default trait
-
visibility
Attribute to override the visibility of items (useful in conjunction with cfg_attr)
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
pad-adapter
that provides pad adapter
-
re_query
Querying data in the re_data_store
-
nias
closure generator library
-
safer-ffi
Write safer FFI code in Rust without polluting it with unsafe code
-
c_linked_list
handling NULL-terminated C linked lists
-
merge
multiple values into one
-
static_cell
Statically allocated, initialized at runtime cell
-
fehler
error-handling syntax in Rust
-
abscissa_core
Application microframework with support for command-line option parsing, configuration, error handling, logging, and terminal interactions. This crate contains the framework's core functionality
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
indicatif-log-bridge
Bridge the log crate and indicatif to stop log lines from mixing up with progress bars
-
concat-string
macros for concatenating string slices into owned strings
-
deku
bit level serialization/deserialization proc-macro for structs
-
swift-rs
Call Swift from Rust with ease!
-
dioxus-html
HTML Element pack for Dioxus - a concurrent renderer-agnostic Virtual DOM for interactive user experiences
-
inline-c
Write and execute C code inside Rust
-
thiserror-ext
Useful extension utilities for
thiserror
-
newtype_derive
macros for deriving common traits for newtype structures
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
shrinkwraprs
Auto-derive for Rust conversion traits -- make working with newtypes a breeze
-
repr_offset
Offsets of fields for types with a stable layout
-
kinded
Generate enums with same variants, but without data
-
async-fn-stream
Lightweight implementation of
async-stream
without macros -
re_string_interner
string interning library
-
tuplex
Rust tuple extension
-
struct_iterable
providing a proc macro to make a struct iterable
-
eieio
Error Implementing
Eq + Clone
replacingstd::io::Error
-
tynm
Returns type names in shorter form
-
rutie
The tie between Ruby and Rust
-
plain_hasher
Hasher for 32-byte keys
-
defer
excecution of code, inspired by go's defer statement
-
defer-drop
Defer dropping large types to a background thread
-
libipld-macro
ipld macro
-
assertables
macros
assert…!
for better testing, quality assurance, and runtime reliability -
nutype_macros
The newtype with guarantees
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
dyn_size_of
report approximate amount of memory consumed by variables, including the memory allocated on heap
-
open-enum
An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
veil
Rust derive macro for redacting sensitive data in
std::fmt::Debug
-
scale-typegen
Type Generation for SCALE encoded Rust Types
-
speculoos
Fluent test assertions
-
partial-min-max
min
andmax
functions that work withPartialOrd
-
equator
Composable assertion library
-
result-like
Option/Result-like monad interface for your own enum
-
expunge
redact and transform struct fields declaratively
-
split-iter
Allows splitting of iterators
-
arc-interner
An interner that deallocates unused values
-
buffered-reader
A super-powered Reader
-
cfg-or-panic
Replace function bodies with
unimplemented!()
when condition is not met -
random-number-macro-impl
Generate random numbers quickly
-
iter-chunks
Extend Iterator with chunks
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
err-context
Lightweight context layers for stdandard library errors
-
garando_pos
Backport of libsyntax_pos
-
rc-box
Known unique versions of Rc and Arc
-
drop_guard
enables you to implement the Drop trait on any type. So you can run a closure on any value running out of scope
-
calendrical_calculations
Calendrical calculations in Rust
-
arrow2_convert
Convert between nested rust types and Arrow with arrow2
-
vsprintf
Rust bindings to the libc vsprintf function
-
apply
A tiny library for chaining free functions into method call chains
-
rvs_derive
A helper macros implementation for Value Classes in Rust
-
metastruct
Abstractions for iterating and mapping over struct fields
-
vtable
Helper crate to generate ffi-friendly virtual tables
-
bilge
Use bitsized types as if they were a feature of rust
-
impl-tools-lib
Helper macros: autoimpl
-
version-sync
ensuring that version numbers in README files and other files are kept in sync with the crate version
-
rawslice
Reimplementation of the slice iterators, with extra features. For example creation from raw pointers and start, end pointer accessors.
-
const-field-offset
Wrapper around field-offset crate and const-field-offset-macro
-
opaque_typedef
Supports defining opaque typedefs
-
rust-fsm
A framework for building finite state machines in Rust
-
elain
Set a type's minimum alignment with const generics
-
python-packaging
Python packaging primitives implemented in Rust
-
dot-generator
the set of macros to generate dot files
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
stringmatch
Allow the use of regular expressions or strings wherever you need string comparison
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
smartcow
a cow for smartstrings
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
slugify
Macro for flexible slug generation
-
assert_unordered
A direct replacement for
assert_eq
for unordered collections -
generic_static
Generic static variables in generic functions
-
bounded-integer
Bounded integers
-
tuple_list
macro-free variadic tuple metaprogramming
-
closure
A macro for capturing variables on a per variable basis
-
tuple_utils
A set of utilities to enable higher level operations over tuples
-
blanket
macro to derive blanket implementations for your traits
-
simple-logging
logger for the log facade
-
formatx
A macro for formatting non literal strings at runtime
-
ra_ap_hir_expand
TBD
-
ra_ap_hir_def
TBD
-
ra_ap_hir_ty
TBD
-
rustrict
profanity filter for Rust
-
conjure-object
Runtime support for generated Conjure objects
-
once_cell_serde
Single assignment cells and lazy values
-
generativity
Generation of unique invariant lifetimes
-
podio
Additional trait for Read and Write to read and write Plain Old Data
-
buffering
primarily designed for network packet buffer operations
-
libc-print
println! and eprintln! macros on libc without stdlib
-
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
arch-into
safe type conversions between pointer-sized types (usize/isize) and types with fixed size
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
enum-utils-from-str
Code generation for mapping from strings to arbitrary values
-
term_grid
formatting strings into a grid layout
-
derive_is_enum_variant
Automatically derives
is_dog
andis_cat
methods forenum Pet { Dog, Cat }
-
atom
A safe abstraction around AtomicPtr
-
spectral
Fluent test assertions
-
testresult
type for concise and precise test failures
-
assert-impl
Macro for static assert types implement a trait or not
-
inner
The inner! macro descends into an enum variant. It's more flexible than try!() and unwrap(), and it works with your enum, too!
-
k8-client
Core Kubernetes metadata traits
-
kittycad-execution-plan-traits
Types for KittyCAD execution plans
-
evcxr_repl
A REPL for Rust
-
enum_derive
macros for deriving additional functionality for enums
-
k9
rust testing library
-
dptree
An asynchronous event dispatch mechanism for Rust
-
defmac
A macro to define lambda-like macros inline
-
struct-field-names-as-array
generating the field names of named structs as constants
-
gazebo
A collection of well-tested utilities
-
bitty_write_macro
A drop-in
write!
replacement that optimizes non-formatting writes for code size -
dittolive-ditto-sys
Native bindings to Ditto library
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
hex-slice
Extends the std::fmt::*Hex traits to slices
-
bitmask
generator for enum scoped bit flags
-
almost
comparing floating point numbers
-
default-env
The
env!
macro but with a default value -
rt-format
Fully-runtime equivalent of the format! macro
-
byte_conv
conversion traits to bytes
-
impl_ops
Macros for easy operator overloading
-
index_vec
Newtype-style helpers for
Vec
andusize
-
tiny-fn
Type erased closures on stack
-
hex-display
Display impl for byte slices which provides a hexdump
-
pin-init
Safe pinned-initialization in Rust
-
takecell
A cell type which value can only be taken once
-
superstruct
Versioned data types with minimal boilerplate
-
ryu_floating_decimal
Fast floating point to floating decimal conversion. See the crate 'ryu' for more details
-
impls
Determine if a type implements a logical trait expression
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
codes-agency
This package provides a common code representing standards agencies
-
enum_to_enum
Derives possibly effectful conversions between enums
-
sugar_path
Sugar functions for manipulating paths
-
kinded_macros
Generate enums with same variants, but without data
-
jnix
High-level extensions to help with the usage of JNI in Rust code
-
lazy-init
Lazy initialization
-
meticulous
Result extension to add more meaning to unwrapping
-
version
A very simple library who's job is to return the version of your crate if you're building with Cargo
-
amplify_derive
Powerful derivation macros; part of the 'amplify' library
-
trigram
Trigram-based string similarity for fuzzy matching
-
plugin
Lazily evaluated, order-independent plugins for extensible types
-
iterator-sorted
Stable functions for checking iterator sorting
-
derive-enum-from-into
Derive for From and TryInto for enums with single fields
-
ieee-apsqrt
Square root functions for IEEE floats using rustc_apfloat
-
init_with
Helper trait to initilize an array with a function
-
accountable-refcell
A RefCell wrapper that provides actionable information for dynamic borrow failures
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
enum-assoc
Procedural macro to associate constants with enum variants
-
numeric_cast
safe cast between numbers
-
kittycad-execution-plan
A DSL for composing KittyCAD API queries
-
velcro_core
Core dependencies used by the
velcro
crate. Seevelcro
for documentation. It is not advised to depend on this crate directly; it is an internal dependency ofvelcro
and may be subject to breaking changes. -
partial-default
PartialDefault, a trait similar to Default but with fewer guarantees
-
traitful
A collection of helper macros for trait patterns
-
random_variant
To be used with all variant, contains the derive macro
-
one_err
OneErr to rule them all
-
fixed-macro-types
Macro aliases used in the
fixed-macro
crate -
rustc_errors
Reuse rustc_errors for compiler_base
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
flaky_test
atttribute macro for running a flaky test multiple times
-
pipe-trait
possible to chain regular functions
-
extism-pdk
Extism Plug-in Development Kit (PDK) for Rust
-
soa_derive
Automatic Struct of Array generation
-
manifest-dir-macros
function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
async_fn_traits
Trait synonyms for “Fn[…]”-trait bounds returning futures
-
safelog
Conditionally suppress confidential information from logs
-
rustc_span
Reuse rustc_span for compiler_base
-
take-static
Static items that provide mutable access only once
-
big_s
Rust’s missing
String
literal -
rust_hawktracer_normal_macro
helper crate for hawktracer profiling library
-
dicom-object
A high-level API for reading and manipulating DICOM objects
-
unchecked_unwrap
Adds an unchecked version of
unwrap()
andexpect()
to Option and Result -
consume_on_drop
A zero-cost abstraction that allows Drop::drop to consume self by value
-
nu-std
The standard library of Nushell
-
staged-builder
A proc macro which generates staged builders for types
-
edid-rs
An EDID parsing crate with no_std support
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
common_macros
common macros like
hash_map!
orhash_set!
(WIP) -
genmesh
A package for generating 3D meshes
-
doku
A framework for documenting Rust data structures
-
struct-path
A helper macros to build a string that represents struct fields path at compile time (such as <field-name>.<field-name>)
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the *relative* difference
-
enum_common_fields
Macro for easy access to common fields of enums
-
crevice
Create GLSL-compatible versions of structs with explicitly-initialized padding
-
require_unsafe_in_body
Make
unsafe fn
still requireunsafe
blocks in the function’s body -
transitive
derive macros for Rust
-
tokio-pg-mapper
Proc-macro library used to map a tokio-postgres row to a Rust type (struct)
-
bit
helpers to manipulate bits and bit ranges
-
rust-fsm-dsl
Macros for rust-fsm DSL
-
higher-kinded-types
"Generic generics" / higher-kinded APIs in stable Rust
-
slice-copy
Go style copying for slices
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
fortify
convenient way to bundle owned data with a borrowing type
-
termcolor_output
Interface crate for styled output to termcolor through macro
-
hkalbasi-rustc-ap-rustc_index
Automatically published version of the package
rustc_index
in the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
supercow
A generic way to accept general reference-like values without proliferating generics
-
tlua
Zero-cost high-level wrapper for Tarantool-LuaJIT
-
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
-
wasmer-wit-bindgen-gen-core
wit-bindgen-gen-c
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
format-bytes
A macro to format bytestrings
-
tor-basic-utils
General helpers used by Tor
-
hermit-sync
Synchronization primitives for kernels
-
assert-type-eq
Macro to assert types across potentially different crate versions are compatible
-
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
enum_delegate
Easily replace dynamic dispatch with an enum, for speed and serialization
-
wasmer-wit-parser
wit-bindgen-gen-c
-
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
likely_stable
likely and unlikely compiler hints in stable rust
-
k8s-controller
lightweight framework for writing kubernetes controllers
-
sugars
An useful collection of macros to make tasks easier
-
procedural-masquerade
macro_rules for making proc_macro_derive pretending to be proc_macro
-
http-request-derive
Use derive to create HTTP requests
-
extendr-api
Safe and user friendly bindings to the R programming language
-
tuple-conv
Allows converting tuples of one element to vectors
-
bswap
byte-swapping integers, pointers, and slices
-
winconsole
A wrapper for console-related functions in the Windows API
-
retry-error
An error type for an operation that can fail more than once
-
snowflaked
creating and working with snowflake ids
-
frunk_utils
working with frunk
-
ra_ap_span
TBD
-
tor-async-utils
Async/futures helpers for use with Tor
-
exitfailure
A basic newtype wrappers for use with ? in main
-
phantom-type
A
PhantomData
analog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData
-
serde_str_helpers
Helpers for using serde with strings
-
cslice
slices with a stable ABI for interfacing with C
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
prima_bridge
implement the bridge pattern
-
regex-macro
A macro to generate a lazy regex expression
-
ice_code
A macro to mark code paths as cold, allowing the common case to be inlined
-
ref_thread_local
A macro for declaring thread-local
static
s like using both oflazy_static!
andRefCell
-
retour
A cross-platform detour library written in Rust
-
macro-attr-2018
macro_attr!
macro that enables the use of custom, macro-based attributes and derivations -
pingora-error
Error types and error handling APIs for Pingora
-
futures-await-test
Async test support for Rust through a procedural macro. This crate defines the
#[async_test]
attribute to make writing tests that use async/await easier. -
error
A fancy error type for highly generic cases
-
pub-iterator-type
Abstract an iterator implementation behind a struct tuple
-
xx
A collection of useful Rust macros and small functions
-
stringly_conversions
helping to convert to/from various representations of strings
-
c-types
Re-exports of cross-platform types, gathered from libc and winapi
-
compiler_base_macros
-
ward
ward! macro which returns the contents of an Option<T> and otherwise returns early, and a guard! macro, which does the same, but with a syntax more similar to Swift's guard syntax
-
static_assert_macro
so-called
static_assert
-
fp_rust
Implement fp features for Rust
-
hxdmp
A small utility to create hexdump output from byte slices
-
bstringify
stringify! that yields byte string literals instead
-
arc-cell
Helper for a simple Cell-like object containing Arc/Weak
-
arraytools
A variety of helpful methods for working with fixed-size arrays
-
timely-container-master
Container abstractions for Timely
-
stringreader
wrapper for strings so that they can be consumed via the std::io::Read trait
-
next-gen
Safe generators on stable Rust
-
text-block-macros
Create a multiline string literal
-
oneline-eyre
A fork of
simple-eyre
which outputs errors on a single line -
aerosol
dependency injection for Rust
-
autosurgeon
working with data in automerge documents
-
ffizz-header
FFI helpers to generate a C header for your library
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
simple-xml-builder
XML builder/writer
-
take
A container utility for Rust
-
gat-lending-iterator
iterators who's items can [mutably] reference the iterator
-
axotag
share tag-parsing code between axodotdev projects
-
snapup
Abstractions for handling snapshots with streams of subsequent updates
-
socketpair
Cross-platform socketpair functionality
-
bit-struct
Define structs which have fields which are assigned to individual bits, not bytes
-
once-cell-regex
just gives you the
regex
macro from theonce_cell
docs! -
cap-std-ext
Extension APIs for cap-std
-
rental
A macro to generate safe self-referential structs, plus premade types for common use cases
-
with_drop
Nostd wrapper for using a closure as a custom drop function
-
left-pad
left-padding for strings
-
shaku
Compile Time Dependency Injection for Rust
-
try-traits
Alternatives to std lib traits that can fail
-
notosans
providing several of Google's Noto Sans true type fonts as slices of bytes
-
call-once
A type that can only be called sucessfully once
-
generic_once_cell
A bring-your-own-mutex version of once_cell
-
fileslice
Slices of files
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
exclusive_cell
A thread-safe, non-blocking, no-std cell that can only be accessed once
-
trait_enum
Easy enum wrapper that implements all traits that the wrapped objects implement
-
assert_matches2
A version of the assert_matches! macro that brings variables from the pattern into scope
-
multi_try
Safely combine results
-
lazy-static-include
lazy_static_include_bytes
andlazy_static_include_str
macros to replaceinclude_bytes
andinclude_str
macros -
raw-parts
Ergonomic wrapper around
Vec::from_raw_parts
andVec::into_raw_parts
-
dylint_linting
writing Dylint libraries
-
gen_ops
Macros for operator overloading for generic types
-
groupable
Easily aggregate groups of values from key-value Iterators
-
dyn-hash
Hash trait that is object-safe
-
generics
macros for parsing generics (with optional where clause) in
macro_rules!
-
twiddle
Bit-twiddling utility functions
-
abort_on_panic
Intercept panic! from unsafe locations and abort the process
-
read_input
Ask for user input until the data inputted is valid
-
k8s-openapi-ext
Collection of fluent builder traits for Kubernetes objects
-
validify
struct validation and modification functionality through the use of derive macros
-
columnation-master
An experimental columnar arena
-
fstrings
Python3 fstring interpolation in Rust
-
rc-borrow
Borrowed forms of Rc and Arc
-
itermap
Iterator tools for maps (
HashMap
,BTreeMap
, etc.) -
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
relevant
A small utility type to emulate must-use types
-
context-iterators
Iterators adaptors with associated read-only data
-
error-iter
Error::sources on stable Rust
-
is_empty
Easily check if the struct is empty
-
strong
Strongly typed String
-
copy_from_str
An extension trait to copy a string into another string
-
defer-lite
A lightweight high-performance implementation of Go's defer statement
-
shopify_function
write Shopify Functions in Rust
-
progress-streams
Progress callbacks for types which implement Read/Write
-
is_none_or
function for the Option type
-
eth2_ssz_types
types with unique properties required for SSZ serialization and Merklization
-
case_insensitive_string
A case insensitive string struct
-
page-turner
A generic abstraction of APIs with pagination
-
phnt
Rust bindings to the System Informer’s (formerly known as Process Hacker)
phnt
native Windows headers -
const-gen
generating (relatively) complex compile-time constants in rust
-
smallvec-wrapper
Macro and common structs to play with
smallvec
-
len-trait
Len trait for collectons
-
enum-derived
Generate random instances of your enums and structs
-
enum_delegate_lib
Internal macro implementations for enum_delegate - use to implement your own macros
-
option_trait
Helper traits for more generalized options
-
yup-hyper-mock
testing clients using hyper
-
cheap-clone
A trait which indicates that such type can be cloned cheaply
-
easy-error
error utilities
-
savvy-bindgen
Parse Rust functions, and generate C and R code
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
boow
Borrow Or oWned
smart pointer. Alternative to Cow. -
intertrait
Allow for inter-trait casting
-
nameof
macro to determine the string name of a binding, type, const, or function
-
dupe
Marker for types which are cheap to clone
-
arrow_convert
Convert between nested rust types and Arrow with arrow
-
type-safe-id
A type-safe, K-sortable, globally unique identifier
-
borrown
Borrowed or owned, simplified for no-std
-
uninitialized
Opt-in unsafe uninitialized memory
-
docsplay
A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc
-
const-assert
Assert struct for const generics
-
mem_dbg
Traits and associated procedural macros to display recursively the layout and memory usage of a value
-
beau_collector
Collect up all errors into a single error
-
try-partialord
Safe failable sort, min, max, binary_search functions for PartialOrd. No need to wrap f32, f64 to sort any more.
-
round
your floats with precision from 1 to 10
-
float-derive
that allows deriving Eq and Hash for types that contain floating points
-
stripmargin
but elegant multiline string in Rust à la Scala
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>
to simplify your code -
vector2d
The spoon of 2D vector libraries, intended for simple game development
-
static-cond
Macro for performing comparisons during macro expansion
-
TSPL
The Simplest Parser Library
-
fs_util
A package providing a few useful functions that std::fs does not
-
dyn-eq
Test equality between trait objects
-
build_id
Obtain a UUID uniquely representing the build of the current binary
-
event-listener-primitives
Low-level primitive for building Node.js-like event listeners
-
kmacros
Useful macros
-
recur-fn
that provides you a more flexible way to construct and extend the recursive function
-
vector3d
3D vector type
-
rustpython-literal
Common literal handling utilities mostly useful for unparse and repr
-
generic_error
A package containing a generic error type that can be dropped in to simplify error handling
-
nshare
Conversion between n-dimensional types in different Rust crates
-
univec
A vector that can hold elements of any single type
-
builder-pattern
A derivable macro for declaring a builder pattern
-
iter_fixed
Iterator of fixed length
-
dyn_partial_eq
PartialEq macros for trait objects
-
parameterized_test
A macro to support providing arguments to test functions
-
arrcat
Array concatenation
-
windows-syscall
Windows inline syscalls for Rust
-
structz
Anonymous struct implementation in rust
-
pre
Compile-time assistance for working with unsafe code
-
try_or_wrap_s
?
ortry!
macro, with an additional wrapping of the error in something else -
documented
Traits and derive macros for accessing your type's documentation at runtime
-
comparator
A Java-like Comparator type
-
tokio-context
Contexts for cancelling asynchronous tasks using tokio
-
partial_application
partial function application via the partial! macro
-
iter-identify_first_last
A helper iterator, flagging first and last elements
-
rustlings
Small exercises to get you used to reading and writing Rust code!
-
range_check
bounds-checking and range helpers
-
std-ext
Extend the standard library functionality
-
internship
Interned string and more
-
nonzero
Statically checked non-zero integers
-
elicit
SmartPointer-like structure for polymorphism
-
static_interner
Similar to
internment
crate, but with interface and performance tweaks -
stream_assert
Macros to simplify testing of
Stream
based APIs -
impl-enum
Macros that make using enums like trait objects more convenient
-
libc-stdhandle
Helper functions for retrieving stdin, stdout, stderr
-
rancor
Scalable and efficient error handling without type composition
-
ruva
Event Driven Message Handling
-
tokio-tasker
Lets you stop and join groups of Tokio tasks
-
doc-chunks
Clusters of doc comments and dev comments as coherent view
-
string-error
A minimal rust library to create errors out of strings
-
culpa
error-handling syntax in Rust
-
tuple-transpose
Transpose tuple of results and options to result and option of tuple
-
ang
Angular types and common helper methods
-
is-odd
Returns true if the given number is odd
-
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
defile
Proc-macro helper to ungroup macro metavariables
-
box_raw_ptr
providing safe wrappers for working with raw pointer. These raw pointers are
*const T
and*mut T
. These wrappers ensure memory safety by encapsulating the raw pointers in safe abstractions… -
typle
Generic tuple bounds and transformations
-
rsor
Reusable slice of references
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
cubob
Structured output helpers for display mode
-
sapp-jsutils
Helper functions for working with js objects in miniquad based apps
-
twitch_types
common types for Twitch
-
tryvial
Small crate for ok-wrapping and try blocks
-
as_num
Checked conversions between Rust's numeric types
-
try-lazy-init
Fallible lazy initialization
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
c-emit
Polished builder API to write C Code
-
resize-slice
Shrink slice references
-
optfield
A macro that generates structs with optional fields
-
kmacros_shim
Useful macros
-
qed
Compile-time assertions
-
zellij-tile
A small client-side library for writing Zellij plugins
-
macro-utils
Some macros to make code writing more elegant and funny
-
extended-primitives
providing primitive-like types for use
-
early_returns
Macros to make early returns easier to work with in Rust
-
ort_custom_op
writing custom operators for the onnxruntime in Rust
-
anymap3
A safe and convenient store for one value of each type
-
crony
cron runner that spawns another thread to run your cron jobs
-
nunny
the definitive non-empty slice/array/vec library for Rust
-
crevice_notan
Create GLSL-compatible versions of structs with explicitly-initialized padding
-
bounded-vector
Vec wrapper that guarantees upper and lower bounds on type level
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator
-
not_empty
Slices and vectors that are statically guaranteed to be not empty
-
threadbound
Make any value Sync but only available on its original thread
-
structural-convert
Derive conversion traits (From, Into, TryFrom, TryInto) when fields are structurally similar in enums or structs
-
c-enum
A macro to generate c-like enums
-
error-ext
Error utilities
-
panicking
std::thread::panicking
analog available in theno_std
context -
assume
Macro for stating unsafe assumptions in Rust
-
filters
Build filters/predicates with the builder pattern
-
fn_name
Macros that produce the name of the function they're invoked within
-
r-ex
Zero-bloat Rust core library extensions
-
tectonic_errors
A boxed error type for Tectonic, with supporting utilities
-
litcrypt
Let's encrypt your string statically during compile time
-
unc-stdx
contains polyfills which should really be in std, but currently aren't for one reason or another
-
compile-time-crc32
taking the crc32 of a string or byte literal at compile time
-
floating-ui-utils
Rust port of Floating UI. Utilities for Floating UI.
-
esrs
A Prima.it-opinionated library to achieve cqrs/es
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
derive
providing a minimal example of a derivable trait (via companion crate derive-derive) for testing and illustration
-
adjacent-pair-iterator
An iterator over adjacent pairs in another iterator
-
squote
A clone of the quote crate that uses a String as its backing store
-
cmp_any
Comparison for &dyn types
-
unty
Explicitly types your generics
-
ternop
A tiny macro that implements a ternary operator for Rust
-
html5ever-atoms
Static strings for html5ever
-
lazy_mut
structure that can be used to lazily initialized values as well as a macro for creating lazy variables
-
env-var
Macros providing easier access to environment variables in rust
-
static_slice
Macro for creating static slices of arbitrary types
-
bump-scope
A bump allocator with support for scopes
-
macro-attr
macro_attr!
macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derive
crate. -
dict
Exercise crate implementing real associative arrays, also known as dictionaries
-
serror
serialize anyhow errors into json format
-
trace-error
Extensions to Rust's error system to automatically include backtraces
-
display_container
implement Display
-
hetseq
Defines traits and types to work with heterogenous sequences
-
zigbee2mqtt_types_base_types
Common definitions for zigbee2mqtt vendors
-
bitfields
Helpers for storing sub-byte enums in primitive types
-
pod
Plain Old Data (POD) encoding and I/O
-
assertions
const assertions mechanism
-
slice-dst
Slice-based custom DSTs
-
quit
Exit cleanly with an exit code
-
merged_range
rangeset that can merge overlap
-
vlog
Macros to do stdout / stderr logs based on verbosity level
-
tuple-map
map methods for tuple
-
nearly_eq
Nearly(Approximately) equal traits and assertion
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
assert_into
For when writing .try_into().unwrap() feels too long
-
assert_ok
A macro that asserts a Result is Ok
-
only_every
rate-limiter macro: only_every!(Duration::from_millis(200), expensive_expression)
-
to_trait
A trait with methods similar to .into() and .try_into(), except they take type arguments
-
histo_fp
histograms with configurable floating point buckets and floating point samples
-
state_machine_future
Easily create type-safe
Future
s from state machines — without the boilerplate -
rev_slice
A newtype for operating on a reversed view of a slice
-
imgref-iter
A small crate for iterating over the rows or columns of
imgref
buffers -
enum_extract
Helper macros for extracting single enum variants of an enum
-
card-backend
Card backend trait, for use with the openpgp-card crate
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
typed-generational-arena
A safe arena allocator that supports deletion without suffering from the ABA problem by using generational indices. Now with typed indices and custom integer types for generations!
-
gitoxide-core
implementing all capabilities of the gitoxide CLI
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
macro_const
A macro for creating corresponding macro definitions for constants which evaluate to the same values
-
format
easier to work with the formatter
-
either_n
An Either enum with N variants
-
prost-unwrap-core
A procedural macro implementation for prost-unwrap library
-
tokio-async-drop
macro to enable async drop in a tokio multithreaded runtime
-
brw
builder for the broker-reader-writer pattern
-
is_not
A procedural macro much like #[cfg(...)] that can be re-exported from a library based on enabled features
-
utf8_slice
Lightweight UTF8 Slice Utilities
-
audiotags-dev-macro
macros used during the development of audiotags
-
trait-make
working with impl traits in Rust
-
structdoc
Extract structure and documentation from structs