-
bitflags
macro to generate structures which behave like bitflags
-
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
-
color-eyre
error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
ordered-float
Wrappers for total ordering on floats
-
darling
proc-macro library for reading attributes into structs when implementing custom derives
-
derive_builder
macro to automatically implement the builder pattern for arbitrary structs
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
pin-project
safe and ergonomic pin-projection
-
memoffset
offset_of functionality for Rust structs
-
lazy_static
macro for declaring lazily evaluated statics in Rust
-
thiserror
derive(Error)
-
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… -
typed-builder
Compile-time type-checked builder derive
-
human-panic
Panic messages for humans
-
shellexpand
Shell-like expansions in strings
-
dyn-clone
Clone trait that is object-safe
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
cfg-if
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.
-
approx
Approximate floating point equality comparisons and assertions
-
snafu
ergonomic error handling library
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
zerocopy
zero-copy parsing and serialization
-
beef
More compact Cow
-
ouroboros
Easy, safe self-referential struct generation
-
pin-project-lite
lightweight version of pin-project written with declarative macros
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
smol_str
small-string optimized string type with O(1) clone
-
tap
Generic extensions for tapping values in Rust
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive -
parse-display
Procedural macro to implement Display and FromStr using common settings
-
static_assertions
Compile-time assertions to ensure that invariants are met
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
macro_rules_attribute
declarative macros in attribute or derive position
-
frunk
developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
psm
Portable Stack Manipulation: stack manipulation and introspection routines
-
az
Casts and checked casts
-
bitfield
macros to generate bitfield-like struct
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
orchestra
Generate an orchestra of subsystems from a single struct
-
strfmt
strfmt: rust library for formatting dynamic strings
-
uint
Large fixed-size integer arithmetic
-
scroll
suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
pnet_macros_support
Support library for libpnet_macros
-
arrow-ipc
Support for the Arrow IPC format
-
error-stack
context-aware error-handling library that supports arbitrary attached user data
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
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
-
doc-comment
Macro to generate doc comments
-
nonempty
Correct by construction non-empty vector
-
servo_arc
fork of std::sync::Arc with some extra functionality and without weak references
-
if_chain
Macro for writing nested
if letexpressions -
joinery
small crate for generically joining iterators with a separator
-
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 -
arrow-array
Array abstractions for Apache Arrow
-
abi_stable
doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
assertables
Assertables: Rust crate of macros
assert…!for better testing, quality assurance, and runtime reliability -
rlua
High level bindings to Lua 5.x
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
capnp
runtime library for Cap'n Proto data encoding
-
fragile
wrapper types for sending non-send values to other threads
-
cascade
Dart-like cascade macro for Rust
-
speculoos
Fluent test assertions
-
konst
Const equivalents of std functions, compile-time comparison, and parsing
-
la-arena
index-based arena without deletion
-
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…
-
field-offset
Safe pointer-to-member implementation
-
thiserror-no-std
derive(Error)
-
float-cmp
Floating point approximate comparison traits
-
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…
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
environmental
Set scope-limited values can can be accessed statically
-
nutype
newtype with guarantees
-
float-ord
total ordering for floating-point numbers
-
enumflags2
Enum-based bit flags
-
arrow-select
Selection kernels for arrow arrays
-
const-gen
generating (relatively) complex compile-time constants in rust
-
k9
testing library
-
bounded-integer
Bounded integers
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
sptr
sptr: The Strict Provenance Polyfill
-
rustler
Safe Rust wrappers for creating Erlang NIF functions
-
indoc
Indented document literals
-
derivative
set of alternative
deriveattributes for Rust -
easy-cast
Type conversions which are expected to succeed
-
educe
procedural macros to help you implement Rust-built-in traits quickly
-
virtue
sinless derive macro helper
-
inventory
Typed distributed plugin registration
-
moveit
safe, in-place construction of Rust (and C++!) objects
-
volatile
wrapper types for raw pointers
-
typify
JSON schema to rust type code generator
-
rustrict
profanity filter for Rust
-
with_locals
Function attribute to return references to locals by using CPS
-
bit_field
bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
tynm
Returns type names in shorter form
-
unwinding
in Rust and for Rust
-
const-random
compile time random number generation
-
buffered-reader
super-powered Reader
-
async-once-cell
Async single assignment cells and lazy values
-
derive-where
Deriving with custom trait bounds
-
retour
cross-platform detour library written in Rust
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator -
evcxr_repl
REPL for Rust
-
opaque-debug
Macro for opaque Debug trait implementation
-
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… -
linked-hash-map
HashMap wrapper that holds key-value pairs in insertion order
-
constcat
concat! with support for const variables and expressions
-
nonmax
Numeric types that cannot hold maximum values
-
cfg_aliases
tiny utility to help save you a lot of effort with long winded
#[cfg()]checks -
k8-client
Core Kubernetes metadata traits
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
dyn-stack
Dynamic stack wrapper for unsized allocations
-
diff-struct
trait for diffing and applying diffs to types
-
rustdoc-types
Types for rustdoc's json output
-
fallible-streaming-iterator
Fallible streaming iteration
-
simple-error
error type backed by a string
-
ownedbytes
Expose data as static slice
-
thiserror-core
derive(Error)
-
konst_macro_rules
detail of the konst crate
-
lazy_format
lazily formatting values for later
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
cool_asserts
collection of useful testing assertions and utilities
-
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
gix-attributes
gitoxide project dealing .gitattributes files
-
lazy-static-include
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
noodles-csi
Coordinate-sorted index (CSI) format reader and writer
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
macro-attr-2018
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
tryhard
Easily retry futures
-
inout
Custom reference types for code generic over in-place and buffer-to-buffer modes of operation
-
one_err
OneErr to rule them all
-
tuples
many useful tools related to tuples
-
sbnf
BNF-style language for writing sublime-syntax files
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
range-set
Smallvec-backed containers of sorted integer ranges
-
void
uninhabited void type for use in statically impossible cases
-
uniffi_bindgen
multi-language bindings generator for rust (codegen and cli tooling)
-
semval
Semantic validation
-
separator
Formats numbers into strings with thousands separators for readability
-
serde_valid_literal
Literal Value type based JSON
-
as-any
provide the AsAny trait
-
pdf
reader
-
nu-std
standard library of Nushell
-
if-addrs
Return interface IP addresses on Posix and windows systems
-
lending-iterator
Fully general lending iterators in stable rust: windows_mut!
-
rust-fsm
framework for building finite state machines in Rust
-
generativity
Generation of unique invariant lifetimes
-
from_variants
macro to automatically generate conversions for newtype enums
-
result-like
Option/Result-like monad interface for your own enum
-
tree_iterators_rs
tree-iterators-rs is a library built to provide you with the iterators to easily work with tree data structures in Rust
-
dync
efficient alternative to
dyn Traitfor containerized types -
struct-field-names-as-array
generating the field names of named structs as constants
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
foreign-types
framework for Rust wrappers over C APIs
-
amplify_derive
Powerful derivation macros; part of the 'amplify' library
-
custom_debug
Derive Debug with a custom format per field
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
index_vec
Newtype-style helpers for
Vecandusize -
gazebo
collection of well-tested utilities
-
twilight-mention
working with mentions in the Twilight ecosystem
-
lender
iter feature complete(-ish) lending iterator
-
entrait
Loosely coupled Rust application design made easy
-
datasize
simplified heap memory size estimator
-
tokenlock
cell types that decouple permissions from data
-
datatest
Data-driven tests in Rust
-
uniffi_udl
udl parsing for the uniffi project
-
inline-c
Write and execute C code inside Rust
-
iter-read
Read implementation for iterators over u8 and related types
-
schematic_types
Shapes and types for defining schemas for Rust types
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
fatality
extension to
thiserror::Error -
carboxyl
functional reactive programming
-
quick-error
macro which makes error types pleasant to write
-
tinyvec_macros
Some macros for tiny containers
-
counter
package to count generic iterables
-
standback
New standard library, old compiler
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
maybe-owned
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
assert_approx_eq
assert approximately equal
-
chainerror
chaining errors easy
-
wrap-match
procedural macro to wrap a function in match statement to make error logging super easy
-
data-rw
io buffer write reader
-
wai-bindgen-gen-rust
Abstractions for generating Rust glue code for WAI
-
safelog
Conditionally suppress confidential information from logs
-
copyless
Ways to eliminate memcpy calls when using the standard library
-
buildstructor
Macro to derive a builder from a constructor function
-
sawp-flags
SAWP BitFlags Handling and Storage
-
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
snailquote
Escape and unescape strings with shell-inspired quoting
-
inline-python
Inline Python code directly in your Rust code
-
by_address
Wrapper for comparing and hashing pointers by address
-
reborrow
Emulate reborrowing for user types
-
arr_macro
Initialize arrays with ease!
-
codegen
generating Rust code
-
ambient-authority
Ambient Authority
-
map-macro
Declarative macros for statically initializing collections
-
mapper
Mapping macro to help to reduce mapping boilerplate
-
stack_dst
wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
funty
Trait generalization over the primitive types
-
stdext
Extensions for the Rust standard library structures
-
cap-std-ext
Extension APIs for cap-std
-
cargo-check-external-types
Static analysis tool to detect external types exposed in a library's public API
-
msi
Read/write Windows Installer (MSI) files
-
adv_random
Create random numbers, passwords, or strings based on rules
-
sugars
useful collection of macros to make tasks easier
-
zoet
Adds
#[zoet]macro to reduce boilerplate when implementing common traits -
more-di
support for dependency injection (DI)
-
keyvalues-parser
parser/renderer for vdf text
-
macro-machines
State machine macros with logging and graphviz DOT file generation
-
vcell
Cellwith volatile read / write operations -
try_match
expression macro to match a pattern and return the bound variables in
Result -
prima_bridge
implement the bridge pattern
-
russcip
interface for SCIP
-
ra-ap-rustc_lexer
Automatically published version of the package
rustc_lexerin the rust-lang/rust repository from commit 390e3c8b6615afb4f0b9bb2c3db3ad033ac75d78 The publishing script for this crate lives at:… -
borrow-bag
type-safe, heterogeneous collection with zero-cost add and borrow
-
gotham_restful_redoc
Private implementation detail of gotham_restful
-
cynic-codegen
Procedural macro code generation for cynic - a code first GraphQL client for Rust
-
version-sync
ensuring that version numbers in README files and other files are kept in sync with the crate version
-
anyerror
type of any error for transport
-
allow
Alias/label lints (to disable) with your intentions. Reexported from allow_prefixed, grouped under rustc::, clippy:: and rustdoc:: modules.
-
rustc_apfloat
port of C++ llvm::APFloat library
-
flex-error
Flexible error definitions using macros and traits
-
async-injector
Reactive dependency injection for Rust
-
globals
Painless global variables in Rust
-
ffi-convert
collection of utilities to ease conversion between Rust and C-compatible data structures
-
nbio
Non-Blocking I/O
-
probe
Static instrumentation probes
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
aoc-parse
little library for parsing your Advent of Code puzzle input
-
ra_ap_ide_ssr
Structural search and replace of Rust code
-
wai-bindgen-gen-wasmer
Generate WAI glue code for a Rust Wasmer host
-
rvstruct
helper macros implementation for Value Classes in Rust
-
therror
derive(Error) with a twist (based on thiserror)
-
bool_ext
defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
prima_datadog
opinionated library to share code and approach to Datadog logging in prima.it
-
type_reflect
Extensible runtime reflection through a Derive macro
-
fs-tree
Filesystem path Trie with an API focused on filesystem operations
-
dilib
dependency injection library for Rust
-
rust2fun
functional programming in Rust
-
retry-error
error type for an operation that can fail more than once
-
deluxe
Procedural macro attribute parser
-
ion
*.ion file parser
-
frunk_laws
contains laws for algebras declared in Frunk
-
fp_rust
Implement fp features for Rust
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
lazy-bytes-cast
Lazy casts from & to byte arrays
-
from-pest
Convert from a pest grammar to a typed AST
-
open-enum
attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
iter-chunks
Extend Iterator with chunks
-
sealed
Macro for sealing traits and structures
-
nougat
(lifetime) GATs on stable Rust
-
capture-it
Modern c++-ish capture syntax for rust
-
calendrical_calculations
Calendrical calculations in Rust
-
rustpython-ast
AST definitions for RustPython
-
chassis
Compile-time dependency injection framework
-
spl
Stack Pogramming Language: A simple, concise scripting language
-
sawp-ffi
FFI helper macros and traits
-
components-arena
creating complex domain-specific self-referential data structures
-
concat-with
Extend the function of the
concat!macro instd -
gen_ops
Macros for operator overloading for generic types
-
pi_null
define trait is named Null. u8,u32,u64,Option...is implements Null
-
proto-mapper
Macro library for easier mapping between custom models and proto generated code
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
deltoid
calculate and apply deltas to structs and enums
-
intuple
Convert structs and enums into tuples (of refs) and back - recursive, ignore fields
-
overload
macro to simplify operator overloading
-
conv
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
itf
consuming Apalache ITF traces
-
mydi
MyDI. Dependency Injection library
-
generics
macros for parsing generics (with optional where clause) in
macro_rules! -
condtype
Choose types at compile-time via boolean constants
-
distrs
PDF, CDF, and percent-point/quantile functions for the normal and Student’s t distributions
-
structsy
single file structs database
-
random-number
Generate random numbers quickly
-
objid
Generate a random object identifier
-
rtree_rs
R-tree for Rust
-
andex
Safe, strongly typed array indexes and wrappers for rust with zero dependencies
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
funcmap
Derivable functorial mappings for Rust
-
grit-data-prison
providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element
-
structmap
Procedural macro library for converting between Rust structs and associative containers
-
cfg-iif
macro for defining
#[cfg]if-elsefunctions -
enum-display
macro to derive Display for enums
-
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… -
cowstr
Copy-on-Write shared strings
-
leptos-mview
concise view macro for Leptos
-
croaring-sys
Raw bindings to CRoaring
-
mirror-mirror
Reflection library for Rust
-
safe-transmute
safeguarded transmute() for Rust
-
error-code
Error code
-
multihash-derive
Proc macro for deriving custom multihash tables
-
cexpr
C expression parser and evaluator
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_partsandVec::into_raw_parts -
coi
Dependency Injection library
-
downcast
Trait for downcasting trait objects back to their original types
-
syrette
convenient dependency injection framework
-
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
-
assert_matches2
version of the assert_matches! macro that brings variables from the pattern into scope
-
re_string_interner
string interning library
-
pared
Projected reference counted pointers
-
devela
Development extensions for the Rust Standard Library
-
genrc
refcounted pointer type that allows subobject pointers
-
matrix-pickle
binary encoding format used in the Matrix world
-
cosmian_ffi_utils
Cosmian FFI tools library
-
ct-python
Execute Python code at compile time to generate Rust code
-
hkalbasi-rustc-ap-rustc_abi
Automatically published version of the package
rustc_abiin the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
thisctx
Easily create error with contexts
-
auto_enums
allow multiple return types by automatically generated enum
-
nade
Adding named and default arguments to Rust functions
-
kitten
light bdd framework for Rust and for those who don't like cucumber - cats don't like cucumbers, kittens are light cats
-
mownstr
Maybe Owned String
-
include-flate
variant of include_bytes!/include_str! with compile-time deflation and runtime lazy inflation
-
fixnum
Fixed-point numbers with explicit rounding
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
bio-types
collection of common biomedical types for use in rust-bio and rust-htslib
-
singleton-manager
programatical singleton manager
-
error-iter
Error::sources on stable Rust
-
vercel_runtime
Vercel Rust Function Runtime
-
munge
Macro for custom destructuring
-
variant_access_traits
set of traits and for defining a common api for Rust enums based on the std::variant api in the C++ standard library
-
anyinput
macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
ownable
Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more
-
makepad-micro-proc-macro
Makepad micro proc macro util lib
-
aidl-parser
Parse AIDL files, crate AST and diagnostics
-
shoulda
derive macro for test assertions
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
candidate
fast chess move generator. It has a very good set of documentation, so you should take advantage of that. It (now) generates all lookup tables with a build.rs file, which means that…
-
mantra
trace requirements down to implementation and tests
-
nameof
macro to determine the string name of a binding, type, const, or function
-
neweden
system inforamtion, wayfinding and range queries in Eve Online
-
regex_mutator
Nautilus regex_mutator
-
function_name
macro that expands to the name of the annotated function
-
deploy-temp-fringe
safe, lightweight userland context switches
-
arcow
Atomically Reference-counted Copy-On-Write shared pointer
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
outref
Out reference
-
as_num
Checked conversions between Rust's numeric types
-
custom-format
Custom formatting for Rust
-
getfn
generating function pairs to refer to functions via custom expressions
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
validus
string validation library
-
every_variant
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…
-
radiation
Convert Rust type into raw bytes and vice versa
-
chik-bls
BLS signature, verification and aggregation funcions for the Chik blockchain
-
azalea-brigadier
port of Mojang's Brigadier command parsing and dispatching library
-
btreemultimap
multimap implementation with range support
-
tc-error
TinyChain's generic error struct
-
ra_ap_hir
TBD
-
sqlx-type
Typed sql macros for sqlx
-
typed_index_collection
Manage collection of objects
-
socketpair
Cross-platform socketpair functionality
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
capnp_conv
capnp write/read traits to convert from structs to readers/builders
-
implementation
The implementation crate
-
tinyrand
Lightweight RNG specification and several ultrafast implementations in Rust
-
tough-ssm
Implements AWS SSM as a key source for TUF signing keys
-
dynarg
mechanism for dynamic robust argument handling
-
parsel
Zero-code parser generation by using AST node types as the grammar
-
byte-strings
byte strings manipulation, for a better and safer C FFI
-
nova
Macro to derive newtypes with support for serde and sqlx
-
nolife
open a scope and then freeze it in time for future access
-
is-odd
Returns true if the given number is odd
-
checked-float
making invariant-enforcing floating point wrappers
-
kinded
Generate enums with same variants, but without data
-
fmodel-rust
Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust
-
pariter
Parallel iterator processing
-
optional-field
Alternative data type to Option for representing values that can have 3 states: present, missing or null
-
framing_sv2
Sv2 frames
-
algorithmify
Create specifications for algorithms defined using Rust code
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
tagu
Write SVG / HTML / XML programmatically
-
zbus-lockstep
Keep types in lockstep with DBus XML definitions
-
strontium
register-based bytecode machine for statically and dynamically typed programming languages
-
reactivate
Thread Safe Reactive Data Structure. Made with ❤️ for 🦀
-
first-err
Find the first Err in Iterator<Result<T, E>> and allow iterating continuously
-
tuple
Element-wise operations on tuples
-
sod-actix-web
Service Oriented Design - Actix Web
-
devise
devising derives and other procedural macros
-
unwrap_or
Four easy unwrap Result and Option macros that allow for any inline-scoped code for things like return, continue, and break
-
soa_derive
Automatic Struct of Array generation
-
rush_expr_engine
rules engine is based on the rete algorithm
-
format-bytes
macro to format bytestrings
-
sweep-bptree
In memory locality aware b+ tree, faster for ordered access
-
opaque_typedef
Supports defining opaque typedefs
-
tan
language
-
cond
macro to use a match-like syntax as an elegant alternative to nesting if-else statements
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
actix-web-utils
Just some useful addons for actix web
-
kobold_qr
QR code component for Kobold
-
derive_destructure2
Destructure structs that implement Drop
-
rustcomp
Adds vector, map, set, and iterator comprehensions to Rust
-
methods-enum
Two macros for easy implementation of 'state' design pattern and other dynamic polymorphism using enum instead of dyn Trait
-
regalloc2
Backtracking register allocator inspired from IonMonkey
-
dispose
wrapper for values that must be consumed on drop
-
anthill-di
di containers system
-
fxprof-processed-profile
Create profiles in the Firefox Profiler's processed profile JSON format
-
route_verification_ir
Parse RPSL in the IRR to verify observed BGP routes
-
tectonic_errors
boxed error type for Tectonic, with supporting utilities
-
libipld-macro
ipld macro
-
tls-listener
wrap incoming Stream of connections in TLS
-
auto_ops
Macros for easy operator overloading
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
with_drop
Nostd wrapper for using a closure as a custom drop function
-
php-literal-parser
parser for php literals
-
microtype
simplify the creation of microtypes
-
later_operator
Parsable, storable, printable comparison operators, w/ optional serde support
-
arch-into
safe type conversions between pointer-sized types (usize/isize) and types with fixed size
-
merge
multiple values into one
-
failed-result
small crate for converting various failed value to result with corresponding error type
-
list_comprehension
macro for Haskell-like list comprehensions in Rust
-
arma-rs
Arma 3 Extensions in Rust
-
typestate
proc macro DSL for typestates
-
iceyee_random
Random
-
option-ext
Extends
Optionwith additional operations -
expect-exit
Result.expected(): display an error message and exit without a panic
-
pinned-init
facilitate safe pinned initialization
-
tuplex
tuple extension
-
problem
Error handling for command line applications or prototypes
-
ceres-solver
Safe Rust bindings for the Ceres Solver
-
tld
Top Level domain static hash map, tld list is obtained from of iana.org
-
ssi-zcap-ld
ZCAP-LD for the ssi library
-
fringe
safe, lightweight userland context switches
-
intuicio-essentials
Essentials module for Intuicio scripting platform
-
asm_block
Translate tokens to string for Rust inline assembly
-
descriptive_toml_derive
Procedural derive macro for serializing a struct into a TOML template with field descriptions that is easily edited and deserialized
-
o2o
Object to Object mapper for Rust
-
polonius-the-crab
Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
flatty
Flat message buffers
-
rust_info
Extracts the current rust compiler information
-
mode
behavioral state machine library written in Rust
-
overloaded_literals
Overloaded Literals to construct your datatypes without boilerplate and with compile-time validation
-
validated
cumulative sibling of
ResultandEither -
assert_hex
display assert panics in hexadecimal {:#x?} format
-
autofolder
Single-element folding wrapper
-
libc-print
println! and eprintln! macros on libc without stdlib
-
oomfi
minimal Bloom Filter implementation in Rust
-
shuttle-poise
Service implementation to run a poise discord bot on shuttle
-
structx
Simulating anonymous struct and named arguments in Rust
-
dims_macro
Macros for Generating Systems of Units
-
x12-types
Bindings for the ASC X12 EDI definitions
-
ruwren
bindings to Wren programming language
-
bytify
macro that can write given const-expr values into a continuous byte array
-
ara_reporting
Reporting library for for Ara Programming Language 📃
-
resolver
Expression evaluator
-
maybe-single
singleton. Maybe.
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
colorized
output
-
async-session
Async session support with pluggable middleware
-
dyn-eq
Test equality between trait objects
-
engineer
master builder!
-
shaku
Compile Time Dependency Injection for Rust
-
pepegsitter
Collection of Tree-Sitter parsers
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
culpa
error-handling syntax in Rust
-
qualifier_attr
Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items
-
read_input
Ask for user input until the data inputted is valid
-
iterchunks
iterator adapter to adapter that yields N elements of the iterator at a time
-
cstr-argument
trait for converting function arguments to null terminated strings
-
aerosol
dependency injection for Rust
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
tibco_ems
high level API for the Tibco EMS
-
linux-errnos
list of error numbers
-
dioxus-class
Dioxus class
-
enumeration
extension to rust enum
-
closure_attr
attribute macro to simplify closure captures
-
loupe
Profiling tool for Rust
-
range-ext
Range intersection
-
case_insensitive_string
case insensitive string struct
-
intertrait
Allow for inter-trait casting
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
palindronum
Number palindromes
-
proc-bitfield
expressively declare bitfield-like structs
-
typesafe-builders
Infallible compile-time checked builders for your structs
-
cooked-waker
safe interface for creating async Wakers
-
enum-assoc
Procedural macro to associate constants with enum variants
-
auto-delegate
Auto delegate allows you that automatic impl of traits and delegate their handling to child members
-
see-through
traits to provide access to internal fields of generic structs
-
safecast
Traits to define safe casting between types
-
renege
Tracking cache validity using fast concurrent invalidation propogation
-
arrow-arith
Arrow arithmetic kernels
-
option-operations
Traits and auto-implementations to improve arithmetic operations usability when dealing with
Options -
cqdb
Constant Quark Database (CQDB)
-
benri
Convenient macros wrapping the standard library
-
peak-result
trait that extends the standard Result enum to allow you to run some code in case of error or success
-
take-until
take_until extension for iterators
-
remit
generators implemented through async/await syntax
-
janetrs
High level binding for Janet programming language
-
stilo
small library for stylizing terminal text with ANSI color codes
-
upgrayedd
Ergonomic function interposition in Rust
-
oofs
Error handling library that generates and injects context for you
-
userfaultfd
bindings for the Linux userfaultfd functionality
-
erasable
Type-erased thin pointers
-
runestr
User-perceived characters related types and data structures
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
psl-types
Common types for the public suffix implementation crates
-
macro_lisp
Lisp-like DSL for Rust language
-
assert_unordered
direct replacement for
assert_eqfor unordered collections -
orion_cfmt
Format output without Rust code segment in binary to reduce the ultimate binary size
-
not-so-fast
data validation with derive macro
-
flatc
Vendored executable of flatbuffer’s
flatc -
enum2egui
derive macro that creates a set of egui ui databindings from arbitrary data structures
-
procedural-masquerade
macro_rules for making proc_macro_derive pretending to be proc_macro
-
naan
fast, easy, and tasty functional programming prelude
-
throwing
Create explicit errors easily with a handy macro
-
light-curve-dmdt
dm-dt maps generator library
-
dsntk-feel-number
DSNTK | FEEL number
-
stylish-ansi
stylishhelpers for writing styles as ANSI escape codes -
ra_ap_ide
TBD
-
refl
reflencoding which you can use to provide a proof witness that one type is equivalent (identical) to another type. You can use this to encode a subset of what GADTs allow you to in Haskell -
maplit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
ra-ap-rustc_abi
Automatically published version of the package
rustc_abiin the rust-lang/rust repository from commit 390e3c8b6615afb4f0b9bb2c3db3ad033ac75d78 The publishing script for this crate lives at:… -
malachite-bigint
drop-in num-bigint replacement based on malachite
-
encdec
binary object encoding / decoding helpers
-
minedmap-resource
Data describing Minecraft biomes and block types
-
hb_error
Useful macros and traits for creating and handling errors
-
assume
Macro for stating unsafe assumptions in Rust
-
try-unwrap
revolutionary new crate that allows you to unwrap() without making your stupid software panic
-
byte-tools
Bytes related utility functions
-
read_buffer
ReadBuffer, a wrapper to safely read into a buffer from a Read
-
fileslice
Slices of files
-
zngur-def
Data types that define the structure of a zng file
-
iprint
debugging utility that prints indented text based on function call depth
-
partial-borrow
Partially borrow a struct
-
lichen
Scripting DSL (for Dialogue Graphs, et al)
-
type_description
Machine-readable type descriptions
-
oint
('optional int') provides total operations on arithmetic
-
cardseed
Pseudo-random numbers derived from playing cards using PBKDF2
-
rs-utilities
Some utilities
-
irox-enums
Traits for better Enumerated Types
-
goof
reusable, composable, aggregate and
no_std-friendly error library -
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
-
extended-primitives
providing primitive-like types for use
-
closure
macro for capturing variables on a per variable basis
-
illicit
implicit thread-local environment which is indexed by type
-
variadics
Variadic generics on stable Rust using tuple lists
-
tartan-bitfield
Define structures with accessors for particular bits or bit ranges
-
aws-types
Cross-service types for the AWS SDK
-
self-reference
Helper
-
const-chunks
Extension trait to chunk iterators into const-length arrays
-
ruru
Native Ruby extensions in Rust
-
quack
Duck typing traits
-
vectora
vector computation library
-
meza
in-memory data table written in Rust
-
lyneate
beautiful code underlining and error reporting
-
hlist2
Compile-time heterogeneous list implementation
-
econf
Load environment variables into your struct members in one shot
-
const_typed_builder
Compile-time type-checked builder derive using const generics
-
spl_frontend
Compiler-Frontend for SPL
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
stack-queue
Heapless auto-batching queue
-
rs_envflag
easy way to define flags by environment variables
-
piccolo
Stackless Lua VM implemented in pure Rust
-
vcd_io
VCD IO utils
-
macroland
macro shorthands of various types in Rust
-
easy-error
error utilities
-
dmntk-feel-number
DMNTK | FEEL number
-
dropbox-sdk
bindings to the Dropbox API, generated by Stone from the official spec
-
crate-inspector
inspect the public APIs of Rust crates
-
tuplify
Generic hlist/tuple library
-
cmp_any
Comparison for &dyn types
-
lazy-init
Lazy initialization
-
algar
Algebraic structures, higher-kinded types and other category theory bad ideas
-
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
-
concat-string
macros for concatenating string slices into owned strings
-
near-seed-phrase
Convert NEAR seed phrase to secret key
-
caffe2op-lstm
xxx
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
to-syn-value
Defines a derive macro to implement a trait converting values to instances of syn::ToDeriveInput
-
office-hours
only execute code within office hours
-
term_grid
formatting strings into a grid layout
-
qiniu-objects-manager
Qiniu Objects Manager for Rust
-
ringstack
very simple circular buffered stack implementation
-
scsys-gen
-
selfref
Semi-pain-free self-referential pinned types
-
pretty-error-debug
Write out the
Errormessage and chain -
dyn-any
Any trait that works for arbitrary lifetimes
-
aggregate
attributes of structs for runtime
-
type-fn
Allows for simpler coding of type-level logic, e.g. for type-number systems.
-
front-line
declarative, zero-copy HTTP router
-
hs-bindgen
Handy macro to generate C-FFI bindings to Rust for Haskell
-
smol-symbol
compile-time globally unique, 25-character, 128-bit symbols similar to the Symbol type in Crystal Lang
-
portaldi
ergonomic lightweight compile-time depencency injection library
-
c-types
Re-exports of cross-platform types, gathered from libc and winapi
-
consume_on_drop
zero-cost abstraction that allows Drop::drop to consume self by value
-
clone_cell
Cell that works with a restrictive form of Clone
-
cryo
Extend the lifetime of a reference. Safely.
-
never
stable version of the unstable never type (!)
-
maybe-uninit
MaybeUninit for friends of backwards compatibility
-
klvm-traits
Traits for encoding and decoding KLVM objects
-
menv
Pulling in arguments from environment variables
-
awint_macro_internals
Internal macro utilities for the
awintsystem of crates -
drop-tracker
check when a variable gets dropped. Useful for testing wrappers and containers that use unsafe memory management.
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
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. -
display-error-chain
Formats a standard error and its sources
-
propositional_logic
generate truth tables for compound propositions
-
advancedresearch-path_iter
cocategory enumeration library based on path semantics
-
progress-streams
Progress callbacks for types which implement Read/Write
-
dyn-context
mechanism for lifetimes erasing
-
typemap-meta
compile-time macro to create type-to-value maps
-
aprox_eq
determining aproximate equality between floating point types and deriving this capability to struct comprised of floating point numbers
-
elor
Base generic implementation of an Either type
-
value-enum
Macro for generating enums associated with values
-
formatify
formatify: A rust library specializing in dynamic runtime string formatting, ideal for applications requiring adaptable text representation
-
integer_or_float
data type holding an ‘integer or float’ (a data type in the Unified Font Object specification, among others)
-
derive_builder_fork_arti
macro to automatically implement the builder pattern for arbitrary structs
-
crustal
generating C/C++ code
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
ddd-rs
Domain-Driven Design (DDD) building blocks, for Rust applications
-
mini-config
Minimalistic Dynamic Configuration Library for Rust
-
moore-svlog-syntax
SystemVerilog parser implementation of the moore compiler framework
-
orfail
Error handling library for portable unrecoverable errors
-
enumn
Convert number to enum
-
rust_book_code
code of rust book
-
rustlex
Lexical analysers generator for Rust, written in Rust
-
unroll_range
Repeats a block of code for each number in a specified range
-
fenris-paradis
Parallel processing of disjoint indices for the fenris library
-
partially
Partial trait, and an optional macro to mirror a struct, wrapping each field in an Option
-
defile
Proc-macro helper to ungroup macro metavariables
-
mstr
2-word, immutable Cow<str>
-
influxdb2-structmap
Procedural macro library for converting between Rust structs and associative containers
-
tiberius-mappers
Row mappers for Tiberius
-
unwinder
Call stack spoofing for Rust
-
mightrix
treat continous memory as a matrix
-
simple-logging
logger for the log facade
-
re_log_types
different types that make up the rerun log format
-
steel-core
Core compiler and VM implementation for steel
-
woah
Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
sample-arrow2
Samplers for arrow2 for use with sample-test
-
certain-map
typed map which can make sure item exist
-
logisheets_base
some basic definitions for LogiSheets
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
pointer-identity
Wrapper type to treat the pointer address of types as identity rather than the value
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
inout_port-rs
inb/outb port in freestanding Rust
-
typename
Stable alternative to Rust's type_name intrinsic
-
key-path
Key path for Rust
-
always_equal
wrapper for types that can't implement Eq
-
mozilla/megazord
Firefox Application Services
-
tcl
bindings for Tcl language
-
code-path
code path macro
-
smurf
SMall Useful Rust Functions
-
firedbg-lib
FireDBG Support Library
-
interpolate_idents
Useable macro identifier concatenation plugin
-
stable-inline-python
Stable Variant of inline-python
-
round
your floats with precision from 1 to 10
-
cli_input
Various functions for gathering user input in the terminal
-
zero_v
implementing iterators over function outputs for collections of types implementing a common trait, without using vtables/ dynamic polymorphism
-
rustc-ap-rustc_errors
Automatically published version of the package
rustc_errorsin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
podio
Additional trait for Read and Write to read and write Plain Old Data
-
metastruct
Abstractions for iterating and mapping over struct fields
-
partial_derive2
makes all the properties of a struct type an optional property
-
svi
function to interpolate variables in a hashmap into a format string
-
type-handle
Regular and reference-counted type handles
-
type_cell
Attach values statically to a type using static get/set methods
-
noodles-fasta
FASTA format reader and writer
-
simple_scan
Iterator extensions for simple scan operation
-
io-streams
Unbuffered and unlocked I/O streams
-
random_variant
be used with all variant, contains the derive macro
-
smartcow
cow for smartstrings
-
jealousy
wrapper arount the envy crate, providing an easily implementable trait
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
imstr
Cheaply clonable and slicable immutable strings
-
range_checker
derive-macro crate aimed to provide declarative bounds checking and filtering for structure
-
hado
Monadic do notation using a macro
-
cronjob
scheduling your methods
-
resonata
music theory library for Rust
-
impl-converter-helper
declarative macro library to help you implement the
FromorTryFromtrait for your type -
error-info
Centralized error information ready for internationalization
-
pipe-trait
possible to chain regular functions
-
org-rust-exporter
exporter for org mode documents parsed with
org-rust-parser -
tiny-fn
Type erased closures on stack
-
powerfmt
powerfmtis a library that provides utilities for formatting values. This crate makes it significantly easier to support filling to a minimum width with alignment, avoid heap… -
guessing_utils
Various guessing utilities for working with guesses in (0..101) number range
-
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
otter-base
Otter game system; WASM/hostside common code crate
-
match-commutative
Match on patterns commutatively, reducing the use of duplicated patterns. ↔️
-
filey
collection of utilities to make file operations more convenient
-
nshare
Conversion between n-dimensional types in different Rust crates
-
stringlit
macro to convert from str to String
-
prctl
package provides safe abstraction to the linux prctl() interface. Some functions may be architecture-specific.
-
const-size-flatten
Flatten and FlatMap with constant inner iterator size
-
frozenset
frozenset(), for Rust
-
unreachable
code optimization hint in stable rust
-
iceyee_convert
类型转换, Conversion, 已被弃用, 参考iceyee_encoder
-
multer-derive
derive for constructign type from multer Multipart
-
dyn_problem
Problemtype to represent dynamic problems, with problem types identified by uri -
ungrammar
DSL for describing concrete syntax trees
-
enum_common_fields
Macro for easy access to common fields of enums
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
type-toppings
Opinionated extensions to standard types
-
stylish-html
stylishhelpers for writing styles as HTML elements -
merge-hashmap
Merge multiple values into one
-
kvtree
Heterogenous in memory key value tree storage
-
explicit-endian
Transparent traits to explicitely declare in-memory endianness for a virable or struct record
-
width_counters
Atomic counters with variable bit widths and customizable atomic ordering
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
compact_strings
cache-friendly but limited representation of a list of strings or bytestrings
-
qed
Compile-time assertions
-
ocaml-build
OCaml code generation
-
derive_environment
modifying structs via environment variables
-
fallthrough
Pattern match with fallthrough, in the style of C switch
-
curerr
easy error handling
-
try_default
trait to optionally get the Default if present, or None if there is no Default
-
syllogism
allow for some specialization using stable Rust
-
name-it
Give a name to async fn return types
-
cast_checks
procedural macro to check for invalid casts
-
chronos-parser-rs
CROND parser
-
aliri_braid_examples
Examples demonstrating usage of the
aliri_braidcrate -
pkcs11-sys
Generated bindings for pkcs11.h. Useful for building PKCS#11 modules in rust.
-
iter_view
Create iterator from readonly reference
-
ra_ap_mbe
TBD
-
ra_ap_la-arena
index-based arena without deletion
-
haskell_bits
implementations of various Haskell typeclasses and functions
-
rsciter_ext
rsciter build actions implementation
-
phtm
Re-exports for common uses of
PhantomData -
paris-log
that allows you to use paris's formatting with the log crate
-
hereditary
Procedural macros for emulating OOP Inheritance in Rust
-
caffe2op-reciprocal
xxx
-
axos-primitives
Primitives for the axos derivation pipeline
-
borrowme
missing compound borrowing for Rust
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
currying
anything implementing FnOnce. Arguments can be passed one at a time, yielding a new something implementing FnOnce (and possibly FnMut and Fn) which can be called with one less argument.
-
shindanmaker-rs
Shindanmaker in Rust
-
custom_derive
(Note: superseded by
macro-attr) This crate provides a macro that enables the use of custom derive attributes -
rust2fun_laws
Laws for rust2fun
-
version
very simple library who's job is to return the version of your crate if you're building with Cargo
-
scientisto
light-weight Rust implementation of the github/scientist library used for careful refactoring of critical code paths
-
fnichol-cime
demonstration of a Rust CI build/test/release workflow supporting multi-platform testing, binary builds, Docker image building, and Crates.io publishing
-
nonn
Integer types that are known not to equal any single N
-
get-field-by-type
Get a value of field, based on the type of a field
-
branch_hints
that provides likely and unlikely branch hint functions in stable Rust
-
lending-stream
lending version of Stream
-
mpst-seq
macro for mpstthree
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
mixbox
Pigment-Based Color Mixing
-
strck
Checked owned and borrowed strings
-
hex_lit
Hex macro literals without use of hex macros
-
html5ever_macros
High-performance browser-grade HTML5 parser − compiler plugins
-
marine-it-interfaces
Fluence Marine interface types helper crate
-
brainfuck_plus-core
core components of bfp language
-
ra_ap_hir_ty
TBD
-
named-tup
Create named tuples using the tup!() macro
-
human-errors
error library focused on providing your users with relevant advice for any problem
-
derive_destructure2_examples
Examples for crate derive_destructure2
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
sql_reverse_error
sql reverse error
-
nz
Collection of 100% safe macros for creating core::num::NonZero{Integer} types more easily
-
derive-name
Derive macro to get the name of a struct, enum or enum variant
-
dialogue-macro
dialoguer derive macro
-
type-weave
Helpers for joining custom data types
-
model_macro
traits collection
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
fmap
Functors in Rust
-
scoped-arena
Arena allocator with optional scopes
-
partial_application
partial function application via the partial! macro
-
code-spells
Aliases some common (and less common) code snippets to macros named after thematically appropriate spells from Harry Potter, so that instead of calling drop(x), you can cast obliviate!(x)
-
gha_main
Convenience macros for writing GitHub Actions in Rust
-
event-listener-primitives
Low-level primitive for building Node.js-like event listeners
-
steamkit-kv
designed to be a bunch of tools for interacting with the Steam API
-
gerber-types
Types and code generation for Gerber files (RS-274X)
-
summavy_codecs
Fast field codecs used by tantivy
-
malloc-array
libc heap array allocator
-
dirtytype
marker of types being dirty for Rust
-
coercible_errors
Zero-cost error handling for generic traits
-
macro-bits
performing macro-based bit manipulation
-
cfgenius
Conditional compilation with macro support in Rust
-
detour3
cross-platform detour library written in Rust
-
swapbytes
swapping the endianess of structures
-
blackboxmc_general
Helper functions for BlackboxMC
-
study-example
study example
-
namewise-common
Derived trivial name-wise conversions for Rust types
-
wherr
Enhance Rust errors with file and line details using the
#[wherr]macro for clearer debugging -
alternating-iter
Provide an iterator adaptor which alternate between two iterators
-
dupe
Marker for types which are cheap to clone
-
num-runtime-fmt
Format numbers according to a format spec determined at runtime
-
lset
Data types describing linear sets
-
hooks
Compile-time, async hooks
-
destruct-drop
Macro for dropping the fields of a struct or enum without dropping the container
-
construe
Compile-Time Growable Array: Vec & String for const!
-
idata
Small tools to reduce mutability
-
pluto-sdr
HAL for ADALM-Pluto SDR
-
impls
Determine if a type implements a logical trait expression
-
dpc-pariter
Parallel iterator processing
-
rs-sandbox
Sandbox
-
fullypeek
Peek forward in an iterator as far as you'd like, memory allowing!
-
print_typewriter
easy way to print strings on character at a time
-
vec_vec
When dealing with
Vec<Vec<T>>is unavoidable -
global_var
macro for declaring a global variable
-
simulate-promise
simulate promise implementation for rust
-
domain_changer
that helps you change the domain of the link to another domain
-
nopanick
No panic library for add, sub, mul, div operators in Rust
-
light_enum
provide a derive keyword to generate a light enum
-
byondapi
Idiomatic Rust bindings for BYONDAPI
-
apparat
lightweight event-driven behavioral state machine
-
scalar_map
mapfor scalar types -
inline_default
Macro for inline Default implementation
-
head-tail-iter
iterator that repeatedly splits head & tail
-
anda
Andaman Build toolchain
-
enum-derived
Generate random instances of your enums and structs
-
unwrap_let
macro for quickly unwrapping a refutable pattern
-
yansongda-utils
中一些关于我自己的常用工具
-
gtmpl_value
Internal value format for gtmpl-rust
-
to_method
micro-crate for using Into more ergonomically
-
direction
Representations of directions
-
filters
Build filters/predicates with the builder pattern
-
line_of_sight
finding the line of sight on a 2D grid
-
eager
macro expansion
-
str-macro
str!() macro, similar to vec![] but for strings
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
iter-comprehensions
iterator comprehensions
-
shadow-clone
macro to clone variables into the current scope shadowing old ones
-
enum-derive-2018
macros for deriving additional functionality for enums
-
log-instrument
Offers an attribute procedural macro that adds
log::trace!events at the start and end of attributed functions -
blanket
macro to derive blanket implementations for your traits
-
binexp
struct that represents power of two numbers
-
localization
t! macro, the easiest way
-
lifterr
small set of adapters extending Rust's error-handling capabilities
-
frust
Functional Programming in Rust
-
table_enum
convenient rust macro to create enums with associated constant data (note: this is different from normal rust enums which are really tagged unions)
-
thiserror-ext
Extensions to
thiserror -
tailsome
Blanket traits providing
.into_ok(),.into_err(), and.into_some()for happier method chaining -
structmapper
help you generate code that mapped one struct to another
-
rcrefcell
Wrapper type for Rc<RefCell<A>>
-
easy-ext
attribute macro for easily writing extension trait pattern
-
tao-of-rust
《Rust编程之道》随书源码
-
for-loop-iterator
Iterators like traditional for loops
-
threaded-map
Encode bytes as ANSI background colors
-
flatcc
Build-time convenience utilities for flatbuffers
-
peekable_next
extension for Rust iterators to peek at the next element without advancing
-
padded-iterator
iterator that can be padded to a specified length
-
iterwindows
iterator adapter to iterate over all contiguous windows of length N
-
pin-cell
pin-safe cell
-
gur
undo-redo framework
-
stubit
stupid bit library
-
postgres_macros
set of support macros for rust-postgres
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
env-convert
Conversion of environment variables with default values
-
handlevec
Small abstraction over index-style iteration over a vector, with deletion, insertion, and other operations on the vector while iterating
-
number-types
typenum clone I made for fun with some positive changes but much fewer features
-
include_assets
include compressed assets in a Rust executable
-
hermit-sync
Synchronization primitives for kernels
-
silent-headers-core
typed HTTP headers core trait
-
ghost-lite
custom PhantomData types
-
query_interface
Dynamically query a type-erased object for any trait implementation
-
unordered-pair
tuple struct representing an unordered pair
-
fstr
stack-allocated fixed-length string type
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
marine-it-generator
Fluence Marine interface types generator
-
notzero
macro for constructing
std::num::NonZero*from constants -
dialog-expect
Display a dialog box with the message when calling
.expector panicing -
ex3-node-error
Underlying error types used over ex3 crates
-
dispair
(Disp-Err) is a zero-dependency (other than
std) library that provides a simple wrapper struct that implementsErrorfor any type that implements bothDebugandDisplay -
nostd-cursor
that implements std::io::cursor in a nostd-environment
-
farid
Extensible Unique Id Generation for Rust
-
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
-
dissect
Logstash inspired dissect extractor
-
ad-hoc-iterator
Create an ad hoc iterator
-
enum-tools
Automatically derive functions and trait implementations for enums
-
external_mixin_umbrella
Backing library for
rust_mixinandexternal_mixinto keep them DRY -
better-num
Better numeric types in rust
-
siwe-recap
EIP-5573: Mechanism on top of Sign-In with Ethereum for informed consent to delegate capabilities with an extensible scope mechanism
-
failchain
Ergonomic companion library for failure
-
audiotags-dev-macro
macros used during the development of audiotags
-
rc-box
Known unique versions of Rc and Arc
-
indextreemap
BTreeMap implementation that allows for key and or positional insertion and retreival
-
macro-asm-builder
macro-assemblers
-
displaythis
derive(Display)
-
ref_wrapper
Wrapper of dynamically borrowed data
-
cell
replacement of std::cell::RefCell adding advanced support for mapping borrows
-
dyn-ptr
box that stores types like pointers, forgetting everything besides
Self: Unsize<dyn Trait> -
dynamic-dispatch
Allows compiling generic functions that do not have generic parameters inside a library, specifying all the possible specializations for each generic type
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
incomplete
incomplete!(), a compile-time checked version of unimplemented!()
-
itsy
Strongly typed scripting language with a rusty syntax and nice Rust integration
-
asserteq_pretty
assert_eq macro that prints more helpful diffs on mismatch
-
jast
minimalist backend framework to practice
-
as-result
Traits for converting types which may be interpreted as or into a result
-
thiserror_core2
derive(Error) (no_std-enabled using core2)
-
oi
📍 Location-annotated io::Errors
-
cron_macro
cron macro
-
type-operators
macro system for creating type operators in Rust and writing type-level logic
-
tokio-go
golang like macro: go! (closure) backed by tokio. Supports threadpool dedication.
-
specialize-call
macro to invoke a function with type-arguments substituted according to a runtime value
-
dioxus-daisyui
Dioxus daisyui
-
type-path
Get the string array representation of a Rust type path
-
eventually
using Event Sourcing in Rust applications
-
thread-scoped-ref
that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
tupleops
work with tuples
-
volo_macro
volo helper macro for any error
-
int-enum
derive macro for conversion between integer and enum types
-
scope-exit
util to call procedure when exit current scope. scope exit. like defer in go.
-
enum-unitary
Trait and macro for unitary enums
-
introspectable
Basic introspection via the Introspectable trait
-
simple-mermaid
Mermaid diagrams RustDoc integration
-
dyn_ord
Equality and ordering for trait objects
-
traitsequence
Traits to abstract over sequences
-
fl-wasm-rs
Runtime library for FunLess functions
-
lcov-parser
LCOV report parser for Rust
-
fnrs
some useful functions i like
-
sisyphos
retry-library integrated with the native std::error::Error type
-
defmac
macro to define lambda-like macros inline
-
rwtypes
Adds methods to read/write binary numbers to the Read and Write traits
-
sod
Service Oriented Design
-
tree-splicer
grammar-based test case generator (black-box fuzzer)
-
generic-global-variables
tools for implement generic global variables
-
stream_assert
Macros to simplify testing of
Streambased APIs -
diva
Opinionated convenience wrappers for
std::process::Commandand friends -
protofish
decoder focused on decoding arbitrary protocol buffer messages with error recovery
-
named-block
Macro implementing early-exit-from-any-block
-
ord_by
Conveniently attach a custom compare function to any type
-
null-terminated
slices and UTF-8-encoded strings with thin references
-
checked_clamp
Clamp alternative that returns a result instead of panicking
-
overflower
compiler plugin to easily select overflow behavior for all integer operations of an item
-
beaver
setting up Rust objects inspired by factory_bot
-
caffe2op-scope
xxx
-
anyhow_ext
Extension of anynow
-
pathbuf
macro to conveniently build PathBufs
-
clonelet
macro to capture by clone in closures
-
rubber_duck
Enables building functions that can be called with named arg syntax
-
defer-lite
lightweight high-performance implementation of Go's defer statement
-
roopert
object-oriented toolkit for Rust
-
beetle-iter
collection of basic iterators
-
erl_pp
Erlang source code preprocessor
-
hotswap
Easy code swapping in running executables
-
nuit
Declarative, cross-platform UI library for Rust that uses native controls
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
default-option-arr
Macros for simple default initialization of arrays of option types
-
min-max
max! and min! macros
-
destruct
structs and enums for simpler combinator implementation
-
range-action-map
range tree, offering interval operation in kernel memory management, and deliver ACTION to actual VmArea。一个区间树结构，用于提供 mmap / munmap / mprotect 时对内核中区间的操作；
-
scale_std
datastructures and algorithms to be run on the SCALE engine
-
mice
messing with dice
-
tlbf
Type level bitflags
-
flagger
Enum flag generator
-
mapro
tiny macro library for creating std::collections
-
ebacktrace
error wrapper which captures a backtrace and can carry an optional textual description
-
batch_oper
some batch operation macro for some operations
-
reduxr
Redux store with middleware support
-
newstr
macros for declaring String-base new types
-
slice-dst
Slice-based custom DSTs
-
literally
Macro literals for members of std::collections
-
as-raw-xcb-connection
Trait to facilitate interoperatibility with libxcb C API
-
cyclic_list
doubly-linked list with owned nodes, implemented as a cyclic list
-
r-ex
Zero-bloat Rust core library extensions
-
checked_decimal_macro
fixed-point numeric library targeting blockchain development. Originally created and used as a part of the Invariant Protocol. The current version leverages macros, traits and generics…
-
matches2
macro to evaluate, as a boolean, whether an expression matches a pattern
-
pin-init
Safe pinned-initialization in Rust
-
arrayinit
Robust and simple API to initialize arrays
-
smarterr
Smart error handling library
-
ergol_core
core for ergol cli, an async ORM for Rust
-
overwrite
trait that defines how to overwrite a type by another types. Mainly useful to create an app configuration from different sources
-
morphism
structure for suspended closure composition in Rust
-
bellpepper-core
Core elements for a SNARK Circuit library
-
coded
concrete error type with an
ErrorKindenum matching Google’s “canonical error codes” -
lazy_thread_local
Lazily initialised per-object thread-local storage
-
as-is
abstraction over ownership
-
macros-rs
Useful macros
-
check_keyword
trait for String-like types to check if it is a reserved keyword and convert it to a safe non-keyword if so
-
structview
Viewing binary data as high-level data structures, safely
-
unsafe-any
Traits and implementations for unchecked downcasting
-
smart-ptr
Alternative smart pointers for Rust
-
mixed_array
Construct arrays of mixed types
-
ref_thread_local
macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
partial_function
clean way to define function as a set of subfunctions where each has defined start and end bounds
-
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
exun
Handle unexpected errors
-
jcers
jce in rust
-
enum_cycling
Small macro for working with enums
-
sidex
format- and language-agnostic data structure and API definition language
-
lcrt
help writing leetcode solutions in rust
-
memtable
Inmemory tables for use in Rust
-
ever
Print the build information of your program with minimal boilerplate
-
some-to-err
set of traits for converting
OptiontoResult, providing methods to transformSomevalues toErrwhile handlingNonevalues asOk, either directly or using a closure to generate the Ok result -
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…
-
partialdebug
Derive Debug partially
-
assert-eq-float
assert_eq_float!macros that support floats -
backtrace-error
wrap errors with automatic backtrace capture and print-on-result-unwrap
-
struct_iterable
providing a proc macro to make a struct iterable
-
finite-state-machine
type and trait based finite state machine macro
-
defunctionalize
Defunctionalization as a proc-macro over modules
-
epoxy_streams
Base streams implementation for the
epoxy_frplibrary. Please use epoxy_frp instead. -
recur-fn
that provides you a more flexible way to construct and extend the recursive function
-
yui
attribute reader generator for Rust
-
derive-attribute
set of macros to automatically deserialize standard attributes
-
radiowave
emitting signals across the entire program
-
spacetimedb-primitives
Primitives such as TableId and ColumnIndexAttribute
-
truthy
Check if a value is "truthy"
-
ink-quill
transcript library
-
lazy-attribute
convenient attribute macro for lazy function execution
-
portrait
Fills an
implwith the associated items required by the trait -
generic_singleton
allowing for generic singleton patterns
-
fixed-sqrt
Square root for fixed-point numbers
-
docima
Generate images at build time & embed them in the Rust documentation
-
propmaster
Properties and configurations for rust
-
reflex
minimal flex-like lexer
-
once
assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
tracerr
Custom compile-time captured error tracing
-
edisp
Dispatch-on-collect for Rust enums
-
fb_cloned
clone macro
-
measures
unit-of-measure and electrical calculations library
-
hex-slice
Extends the std::fmt::*Hex traits to slices
-
consio
console input
-
rxml_validation
Plumbing crate for rxml and rxml_proc crates
-
atruct
macros for anonymous structs in Rust
-
cereal
data serialisation library
-
documented
Trait and derive macro for accessing your type's documentation at runtime
-
extract-variant
Destructure expressions into, and return assignments from, a single pattern
-
stereokit-sys
Low-Level Rust bindings around the StereoKitC library for XR
-
try_buf
no-panic API for bytes::Buf
-
wasm_sync
Synchronization primitives for both web and native
-
upget
Super simple trait that patterns the value "updae" and "get"
-
deptypes
Dependent types
-
sc2-macro
Procedural macros for rust-sc2 API
-
mdtable
creating markdown tables that are well formatted
-
plain_enum
Mimicing Java's enum::values() and EnumMap
-
tindex
Vec, slice and bitset with custom index types -
wrapping_macros
macro for wrapping arithmetic
-
windows_macros
Windows
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
treereduce
Fast, syntax-aware, multi-language program reducer based on delta debugging
-
fluent-assertions
testing library that enhances readability and expressiveness by enabling natural language-like syntax for test assertions
-
charx
replacement for char::is_ascii*
-
adhesion
set of macros for design by contact in Rust. The design of this library was inspired by D's contract programming facilities.
-
copstr
COpy STRing module
-
builder-pattern
derivable macro for declaring a builder pattern
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
loop_chain
Macro for writing nested Loop expressions
-
asset-derive
asset handling derive macro for enums, and a proc-macro learning resource!
-
bounce-iterator
Bouncing iterator for concisely mutably revisiting an array of pointers
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
ethers-uint-rs
Large fixed-size integer arithmetic
-
range_map_vec
range map data structure backed by a Vec
-
cstr8
string types that are both valid UTF-8 and nul-terminated
-
varisat-formula
Basic formula data types used by the Varisat SAT solver
-
twsearch-ffi
Twizzle Search FFI — C FFI bindings for twsearch
-
rustacuda_core
Minimal kernel-support crate for Rustacuda
-
try-drop
Batteries included error handling mechanisms for drops which can fail
-
messages
Runtime-agnostic actor library
-
kodama
Agglomerative hierarchical clustering
-
iter_all
Iterate all enum vases
-
decimal-percentage
Percentage type with rust_decimal
-
fltrs
Filter for querying lists
-
flow-control
Declarative macros for common flow-control use cases such as break, continue, and return
-
thin_cstr
experimental crate which provides a truly thin std::ffi::CStr
-
brillig
bytecode ACIR uses for non-determinism
-
enum_variant_macros
Macros to generate From & TryFrom for enums
-
graphql_query_builder
GraphQL query builder
-
tardar
Extensions for diagnostic error handling with
miette -
shared_library
Easily bind to and load shared libraries
-
permeable
permission-demand trait. Decouples the permission-demander from the permission / auth provider.
-
ffi_reflect_csharp
C# code generator for the
ffi_reflectpackage -
arguments
package provides a parser for command-line arguments
-
value_unit
every unit imaginable. Also contains a handy macro
-
access-json
serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
libcontract
Safe wrapper around libcontract(3lib)
-
chemistru-macro-api
API for chemistru macros, generating element constants and maps
-
market
Infrastructure for producers and consumers
-
ip-in-subnet
Checking that subnet contains an IP address
-
lexa-prompt
Utilitaires lié aux entrées utilisateur, IO
-
en
easiest numeric traits!
-
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
bounded-registers
high-assurance memory-mapped register interaction library
-
linkk
creating channels and crossing them to facilitate communication between different parts of a program
-
magic_static
Global singletons initialized at program start, an alternative to lazy initialization
-
chainer
cursed crate that allows for global call chaining with access to chained function results
-
bevy_cell
Attach Bevy's Handles/Entities statically to Types
-
similar-structs-macros
Quality-of-life macros for more concise struct/enum definitions
-
lib_battleship
battleship implementations
-
git-ref-format
Everything you never knew you wanted for handling git ref names
-
big_mac
metamacro toolkit for writing complex macros
-
battlesnake-game-types
game types for play.battlesnake.com
-
lifelink
Erase covariant lifetime parameters from anything, with generic associated types
-
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction -
jrpc
types for the jsonrpc specification, ultra lightweight
-
you-can
#[you_can::turn_off_the_borrow_checker]
-
ez-err
error handling library with support for ergonomic and fast error handling
-
except
only one
Error -
ducc
bindings for Duktape, the embedded JavaScript engine
-
cartesian_array_product
Arrays of the cartesian product of a set of items
-
disuse
way to notify the implementation which return value is disuse
-
ringmaster
async FIFO / LIFO with superpowers - 'A ringmaster or ringmistress, or sometimes a ringleader, is a significant performer in many circuses' (Wikipedia)
-
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. -
cprint
Cargo-like print
-
dc-ock
reverse polish notation desk calculator library
-
tarantool-module
Tarantool C API bindings
-
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
trans-gen-kotlin
Generating Kotlin trans code
-
functor_derive
derive macro to derive a functor for a type
-
memdump
Handy unsafe no_std memory dumper utility library written in Rust
-
lit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
read-restrict
Restrict the number of bytes read from a reader
-
savage
primitive computer algebra system (REPL)
-
pattern_code
Given a path patterm matched source code
-
phantom-enum
macro library for creating phantom enums
-
activitystreams-traits
Traits for ActivityStreams 2.0 objects
-
u16cstr
macro for creating c-style u16 wide strings at compile time
-
visibility
Attribute to override the visibility of items (useful in conjunction with cfg_attr)
-
range_check
bounds-checking and range helpers
-
tagname
get the name of a variant in your enum as a string
-
kmacros
Useful macros
-
html-builder
Flexible and convenient HTML generation
-
openssl-errors
Custom error library support for the openssl crate
-
partial-default
PartialDefault, a trait similar to Default but with fewer guarantees
-
matr
metaprogramming library for Rust
-
flat_vec
macro to flatten nested Vecs. Particularly useful when you want to write a rules of egg which contains rules both => and <=>.
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
svgmacro
Write any SVG easily from Rust!
-
web_common
Web functions for common operations
-
teloc
compile-time DI framework for Rust
-
btrfsutil-sys
Raw bindings to libbtrfsutil
-
irox-structs
Traits for Struct Types - linearly serialized big endian bytes
-
iter-identify_first_last
helper iterator, flagging first and last elements
-
set_slice
macro for assigning values to slices
-
jsonit
Parse Json Items using iterators
-
gtk_widget_macro
derive macro helps you handle Gtk widgets
-
cex
Checked exception simulation
-
beehave
defining and evaluating a hierarchical state machine (behaviour tree)
-
vnum
Create enums with a constant value associated to every variant
-
stacking-iterator
Iterator utilities for manipulating stacks
-
univec
vector that can hold elements of any single type
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
try-guard
guard! macro inspired by the guard Alternative function from Haskell
-
fancy-ip
Fanciest way to initialize IP addresses
-
pretty-type-name
shorter version of std::any::type_name
-
sqlx-sqlhelper
基于sqlx和过程宏实现的sqlhelper
-
rbuwu
macros but in uwu
-
symbol
globally interned strings
-
sycamore-state-core
sycamore-state core types and trait definitions
-
char-device
Character Device I/O
-
tlist
Type-level linked lists (of types) and type-level 'functions' to manipulate them. Because TList is implemented using GATs, usage is very ergonomic.
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
nyse-holiday-cal
NYSE holiday calendar library
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
mio-signals
handling signals with Mio
-
signrel
Trait expressing relationship between integers of different signedness
-
rvs-c-api
C-API for Rvs - A library for defining and evaluating random variables using a simple DSL
-
specs-task
Fork-join multitasking for SPECS ECS
-
brain_flak_macro
Brain-Flak macro
-
py-comp
macro implementing a Python-like generator expression
-
retry-policy
Retry Policy
-
detach
helper type for being able to detach/reatach a member item
-
peek-poke
mechanism for serializing and deserializing data into/from byte buffers, for use in WebRender
-
push_mut
Push a value to the back of the vector, and return a mutable reference to it
-
target
Get information on compilation target
-
make_option
turns any type into an option, only if it is not already one
-
f64ad
Easy to use, efficient, and highly flexible automatic differentiation in Rust
-
leaf-spread
iterate indefinitely over well spread points, similar to some leaf arrangement pattern in nature
-
call-once
type that can only be called sucessfully once
-
multi_stream
Aggregate multiple streams of different types in a single stream with an item type that is a tuple of the incoming stream items
-
doc-type
small Rust crate for generating documents from your types
-
abi_stable_shared
detail of abi_stable
-
ghost
Define your own PhantomData
-
generational_token_list
doubly-linked list backed by generational-arena
-
cpp_to_rust_generator
Automatic generator of C++ library wrappers
-
dynerr
Macros for dynamic error handling
-
linear_type
Linear types for rust
-
thin-slice
owned slice that packs the slice storage into a single word when possible
-
gull
type generation
-
calculi
used to apply calculus functions on equations in string form
-
smecs
Dependency free ECS
-
cantor
general toolkit for working with types that have a small number of values
-
easy-conv
Cut down on trivial
impl From<A> for Bboilerplate code -
elain
Set a type's minimum alignment with const generics
-
set_field
Set fields on structs by string
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
dense
encoder/decoder to/from dense files
-
shoogah
Add some syntactic 'shoogah' to Rust
-
iota-rs
macro for other Go refuges who miss const blocks and iota
-
error-ex
designed for those who desire clear, explicit, and easy-to-use error creation and handling
-
common_macros
common macros like
hash_map!orhash_set!(WIP) -
github-webhook-type-generator
GitHub webhook payload type generator for Rust
-
global_placeholders
magic placeholders
-
hs-bindgen-traits
traits behind hs-bindgen ergonomics
-
quick-error2
macro which makes error types pleasant to write
-
approx_eq
macro for comparing equality of two values up to an arbitrary error in the *relative* difference
-
rutenspitz
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
new_type
Experimental implementation of newtypes by type level logic
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
is_send_sync
Macro to tell if a type is Send/Sync
-
hadean-std
Hadean stdlib. Requires Hadean Rust.
-
tenacious
[RETIRED: Will not work with MIR] A plugin to prevent certain types from being moved
-
easing
Leveraging Rust's powerful iterators for easing
-
marine-core
Core of Marine, the Fluence Wasm Runtime
-
dry-mods
Macros to make your module management DRY
-
drop-bin
Defer running expensive destructors until later
-
modus-lib
language for building container images
-
control-flow
hack to control control-flow outside closures
-
cpclib-tokens
cpclib libraries related to assembly tokens. Only structures are provided there. Intelligence is within cpclib-asm
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
efmt_core
Core library for efmt crate
-
build-deps
build-script dependencies generator for data/IDL files
-
heterob
conversion between bytes/bits and heterogeneous lists (tuples)
-
cell-project
Safe interface for cell projection
-
pdx-syntax
Paradox script/localization syntax parser
-
llir
LLVM IR Binding
-
rustils
Utilities for rust
-
include-bytes-plus
Improved include_bytes! allowing to reinterpret input differently
-
iter_fixed
Iterator of fixed length
-
annotation-rs-beta
Compile-time annotation parser for rust
-
reax
reactivity system for Rust that infers dependencies between functions
-
escher
Self-referencial structs using the async/await transformation
-
specs-visitor
visiting entities in an ECS that is using the specs library
-
wrapped-list
Macro for wrapping elements of a list with an object, function, or another macro at compile time
-
projecture
Easy arbitrary type projections without proc macros
-
fdb_tuple
convert between FoundationDB Tuple Layer tuples and Rust tuples
-
bytes-cast
Safely re-interpreting &[u8] bytes as custom structs without copying, for efficiently reading structured binary data
-
identity_verification
Verification data types and functionality for identity.rs
-
lens-rs
lens implemented in rust
-
adaptive_backoff
intelligently backing off rate limited or fallible resources
-
mdo
Monadic do notation for rust using macro and duck typing
-
enumflags
Bitflags
-
miniserde-miku
Data structure serialization library with several opposite design goals from Serde
-
moddef
Macros for convenient nested module structure declaration
-
retour-utils
creating hooks with
retour -
rbtag
procedural macro to add build DateTime and git commit information at compile time
-
rexpr
Json Object access Runtime
-
discard-while
Get the first non-matching element, and the amount of discarded elements
-
maybe-owned-trait
Either an owned or borrowed value, with type known at compile time
-
high_mem_utils
bunch of mem safe abstractions,some involving transmute
-
algebloat_macros
RustAlgebloat utility macros
-
namedarg
main package
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
mvcc_cell
Software-transactional memory for Rust
-
function_string_builder
string builder that takes a user-provided function
-
generic-bytes
derivable trait for conversion to and from an array of bytes with a type-level size
-
prost-uuid
ProstUuid new-type wrapper around uuid::Uuid with prost::Message implemented for it
-
reproto-semver
Rethinking Protocol Generators Semantic Versioning Parts
-
cassandra_macro
Create Cassandra tables and CRUD CQL prepared statements from Rust structs. (custom derive: cassandra_macro_derive)
-
borked
convienient error handling library for rust
-
laxcow
Clone-on-write smart pointer with relaxed trait constraints
-
symtern
Fast general-purpose interners for every use case
-
bitslice
transpose bits into and out of bitslice format, and perform various operations on bitsliced data
-
valkyrie-types
Shard types for valkyrie language
-
kinder
small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
scalar_types
module that wraps scalar types in an endian safe type
-
core_io
copy of libstd::io with all the parts that don't work in core removed. Most importantly, it provides the Read and Write traits. This crate is (mostly) automatically generated from the rust git source…
-
adjacent-pair-iterator
iterator over adjacent pairs in another iterator
-
mop-blocks
Foundation blocks for MOP
-
typesum
Utilties for enums, targeted at sum types
-
zerror
error interface for context-aware error-reporting
-
execute-command
package that wraps
Commandto simplify the execution of programs -
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
tuple_join
joining tuples at the type level
-
numeric_constant_traits
Traits for generic numeric constants
-
skyline
helping patch and modify Nintendo Switch games
-
type-uuid
Safe, stable IDs for Rust types
-
constrained_type
On the fly value objects in Rust
-
variant_counter
Rust's Enum variant counter
-
dyn-clonable
Attribute wrapper for dyn-clone
-
bracer
Macros to help write ARM assembly
-
gamo
Range like struct for user defined types
-
hpl-macros
HPL macro for defining an platform-gate
-
internship
Interned string and more
-
fmt-derive
more robust and versatile derive macro for Debug and Display
-
alemat
type-safe building of MathML
-
lispify
Pretty print lisp
-
serde_extra
Various de/serialization methods
-
tuple_list
macro-free variadic tuple metaprogramming
-
phantom-type
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
enum_primitive
Macro to generate num::FromPrimitive instances for enum that works in Rust 1.0
-
temporary_enum_delegate_0_3_0
trait delegation functionality for enums and structs
-
fallible
operations
-
hiredis
package provides an interface to Hiredis
-
parameterized_test
macro to support providing arguments to test functions
-
forward_ref_generic
Generically forward references for operations on Copy types
-
macro_state
set of macros allowing storing and loading global state at compile-time within proc macros
-
to_that
Declarative compile safe explict type conversion. Useful for chaining.
-
components-arena-traits
Does not intend for direct use
-
bhtmp
package to read .bhtmp files
-
is_none_or
function for the Option type
-
set_derive
Using macro to implement the derivation of imitating python language in rust
-
precomputed-hash
intending to be a base dependency to expose a precomputed hash
-
pad-adapter
that provides pad adapter
-
const_fn
attribute for easy generation of const functions with conditional compilations
-
slots-slice
manipulating slices of optional values
-
static-include-bytes
Like the built-in
include_bytes!macro but produces a static array definition -
easy_rand
Small Rust wrapper library for calling POSIX's srand() and rand() functions
-
turbo-crates
set of useful crates (WIP)
-
iterator-sorted
Stable functions for checking iterator sorting
-
impl_ops
Macros for easy operator overloading
-
iterator-endiate
Extension method for (exact size) iterators which yields tuple containing whether item is last in iterator
-
match_cfg
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. -
general-iter
enum of iterators to avoid Box<&dyn Iterator>
-
codegen-rs
generating Rust code
-
iterpipes
Compositional, pipes-style stream processing
-
lockjaw
Compile time dependency injection framework inspired by dagger
-
postfix-macros
Postfix macros on stable Rust, today
-
grouping_by
allows the user to group an iterator by various ways
-
variadic_generics
first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
throw
Efficiently add statically-calculated stack traces to errors
-
sentry-error-chain
Sentry integration that allows capturing error-chain errors
-
easy-min-max
Easy to use macros for min, max and clamp. Works with no_std
-
namedarg_rustc_macro
namedarg main package
-
evcxr_runtime
Runtime core for the evcxr crate
-
bty
Streamlined definition and usage of branded types in Rust
-
polymorphic-constant
macro to define a numerical constant in multiple types at once
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
iterator-ext
extension to Rust's Iterator
-
easy_switch
macro for traditional C-style switch statements
-
omniswap
swap values between possibly-overlapping references
-
extent
replacement for std::ops::{Range,RangeInclusive}
-
proc-macro2-impersonated
substitute implementation of the compiler’s
proc_macroAPI -
fantasy-util
Jelipo custom utils
-
zkp-macros-decl
Procedural macros
-
nagios-range
types to parse and operate on Nagios ranges
-
statenum
enabling enums in state-pattern logic
-
useful_macros
My useful macros
-
rovv
provide the anonymous row type (poor-man's row polymorphism) in rust
-
slip
hassle-free utility to encrypt error handling strings in your public binaries to protect your business logic
-
tyenum
Attribute macro for type enums
-
memory-size-type
data type for dealing with memory sizes
-
exit
Custom exit status codes with ? in main
-
tapir
Adding tapping functionality to rust
-
chromiumoxide_types
Contains the essential types necessary for using chromiumoxide
-
cast_trait_object
Cast between trait objects using only safe Rust
-
pipe-chain
Combinators & parser library
-
lucene_query_builder
procmacro derive crate to generate lucene query builder for Rust structs :
-
assert-parse
util to assert macro parsing
-
lup
custom indexed loop macro library for Rust
-
constant
evaluation tools for Rust
-
mini-macro-magic
Export tokens to other crates. Now with 100% less proc macros!
-
utils-results
easiest and most intuitive error handling solution
-
must_destroy
forced explcit destructors
-
proclock
cross-process locking API
-
the-newtype
Newtype trait
-
init_with
Helper trait to initilize an array with a function
-
default_macro
My default!() macro
-
haz
thin abstraction over polymorphic environments
-
pi_print_any
print any value without trait bounds using specialization (Rust nightly channel)
-
match_any
declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
numeric-enum-macro
declarative macro for type-safe enum-to-numbers conversion
-
almost
comparing floating point numbers
-
rhai-memflow
Rhai package for memflow
-
axmac
Readable indexing macros for 1-4 dimensional data structures
-
ninja-files-data
Core data structures for ninja files
-
hel-fs
FS helper
-
string-join
python-like way to join items in an iterator with a separator
-
codespan-derive
derive(IntoDiagnostic) for easy codespan integration
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
detour2
cross-platform detour library written in Rust
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
define_into_enum
Defines Into<T> on an enum where all variants wrap T
-
mathie
math type library
-
mapper-api
Api of the
mappercrate -
phantasm
Small lib that helps with variance
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
const-anonymous-functions
macro to create const anonymous functions
-
unwind_safe
Readable unwind-safe code thanks to a try-finally-looking builder pattern
-
vm_lang
interpreted language written in Rust
-
infix_macro
macro that generates the neccesary boilerplate to use "*operator*" infix functions
-
nonminmax
Primitives types which cannot be their minimum/maximum value
-
jast_lib
minimalist backend framework to practice
-
dyn-hash
Hash trait that is object-safe
-
spectral
Fluent test assertions
-
maybe_static
Initialize a lazy static with params, create Meyer's singleton
-
numeric_cast
safe cast between numbers
-
win9x-sync
Windows 9x compatible synchronisation primitives for Rust
-
yadi
dependency injection framework for writing applications with the Rust programming language
-
veccell
variant of Vec with interior mutability
-
audi
Generic listener abstraction
-
repeated
Allows you to repeat a block of code a number of times
-
dbg_mac
Handy debug only macros
-
fractran_macros
compiler plugin that converts Fractran code into Rust at compile time, letting your Fractran programs be optimised by LLVM to super-fast native code
-
rs_envflag_macros
easy way to define flags by environment variables
-
zkp-mmap-vec
Replacement for
Vecthat uses file-backed storage -
resources_package
Macro that allows you to package files inside your libraries or executables
-
expression
Implements expression terms and conditions
-
xkcd_unreachable
macro xkcd_unreachable!() inspired by https://xkcd.com/2200/
-
rust_hawktracer_normal_macro
helper crate for hawktracer profiling library
-
rustico
programming, in Spanish
-
regexm
macro for writing regex pattern matching
-
near-safe-cell
more ergonomic 'UnsafeCell' wrapper/replacement
-
buffer
Safe, write-only, generics-free buffer abstraction
-
match_to_str
match pattern to str
-
md_match
macro to support md-match syntax
-
tonic-error
Derive trait to allow passing of custom errors through tonic Status responses
-
emplacable
Return unsized values from functions
-
stringy
tiny Rust crate for generating byte-sized enums that represent a fixed, ordered set of &str data
-
mintaka-utils
Mintaka Utils
-
btl
shell scripting in rust. Github Repo: https://github.com/znx3p0/btlsh
-
thinnable
Thin references to unsized types
-
whisper-rs-2
bindings for whisper.cpp
-
pnet_macros_support_bandwhich_fork
Support library for libpnet_macros
-
binhoc
Generate code for rust clients communicating with axum servers
-
into_variant
Easily convert your types into the corresponding enum variant
-
take-static
Static items that provide mutable access only once
-
dev_bestia_url_utf8
url utf8 encode/decode
-
units
Measure for Rust. Easy to use, type-safe and customizable.
-
demo-duang
Demo of duang
-
type-variance
Marker traits for subtype variance
-
dtd-rs
DTD file parser
-
eric
creating
std::io::Errorstructs -
predicates
boolean-valued predicate functions
-
urlqstring
URL query string for rust
-
web_local_storage
Web functions for local storage
-
cor_iter
Correlate of two iterators
-
rax
wrapper for the ANSI C Radix Tree "rax" https://github.com/antirez/rax implementation used in Redis
-
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
-
zipped
recursively unzipping tuples, Options of tuples and Results of tuples
-
collapse
Trim and collapse consecutive whitespace to a single space
-
trustme
Tell the compiler that you can be trusted to write unsafe code!
-
primitive-from-enum
macros for get primitive enum from complex
-
xmpp-addr
XMPP Address format (Jabber ID) defined in RFC 7622
-
bls_ckd
BLS child key derivation
-
fmterr
Sane error reporting that just works
-
enum_macro
Useful macro for enum
-
mutable-constant
Mutable access to a constant value
-
bagel
Compile-time evaluation and other tools
-
casual
parsing user input
-
with-api
macro for shrinking scope
-
ngram_iter
iterator of arbitrary N-grams of rust Copy types
-
string_iter
overly designed &str iterator made with zero-copy parsing in mind
-
apply_attr
syntax extension providing higher-order attributes to Rust
-
hlua-badtouch
badtouch specific fork of hlua
-
crossdylib
Cross-platform shared state across shared libraries/modules
-
cbrzn_msgpack
WRAP msgpack encoding standard
-
wrapping-macro
wrapping macro
-
cute
macro for Python-esque comprehensions
-
if_empty
Replace if/else checks for emptyness with a simple method call
-
talos_common_utils
Common utilities used in Talos
-
xcss
Package to Convert the Xpath selectors to CSS selector
-
strong
Strongly typed String
-
gregtatum_symbol_table
fast and efficient symbol table for making it easy to work cheaply with strings
-
iterator_item
generator syntax experiment
-
fstrings-rust
Python3 fstring interpolation in Rust
-
try-lazy-init
Fallible lazy initialization
-
grit-junk-drawer
Collection of small utilities, types, traits, helpers, etc
-
big_s
Rust’s missing
Stringliteral -
knife
iterator that divides things evenly
-
nucleobases
low-level brick crate for managing nucleobases as data in code
-
shawshank
efficient, generic internment structure
-
option-cell
OptionCell: OnceCell but derivable from Option
-
cart_prod
Cartesian product of iterators
-
object-safe
Implement object-unsafe traits for trait objects
-
interruptor
Collection of functions generating Unix process signal receivers for use in the Crossbeam Channel select! macro
-
async_t
zero-cost async-traits
-
json_extract
macro reduces boilerplate when using serde_json::Value variants when trying to get into a nested property
-
max_values
Struct and iterator extension trait for getting max values out of given
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
ra_ap_ide_assists
TBD
-
nofmt
nofmt::pls, a macro that does its best at preventing a code block from being mangled -
ironplc-dsl
Domain-specific language objects for IEC 61131 language elements
-
cli-failure
Failure(String)implementingstd::error::Error. Includes convenience macros making it perfect for usage withwrap-matchin CLIs. -
ioc
Inversion-of-Control library in Rust
-
aspect-weave
Aspect Toolkit for Rust
-
concat_strs
Macro for quickly building a String from components
-
struct-metadata
Macros for attaching metadata to structs
-
cflp
context-free-language parser generated by procedural macros
-
ryu_floating_decimal
Fast floating point to floating decimal conversion. See the crate 'ryu' for more details
-
compost
Adds a macro to decompose tuples into tuples containing a subset of their values
-
cooplan-amqp-api-shared
Shared code for the Cooplan API providers & consumers
-
sod-tungstenite
Service Oriented Design - Tungstenite
-
specs_declaration
macro to effectively create SPECS systems
-
find_all
(nearly) identical alternative for
Iterator::findwhich returns anOption<Vec<usize>>containing all elements which meet a given predicate (instead of just the first) -
unidok-repr
AST and IR for the unidok-parser crate
-
rate-limit-core
companion crate to
rate-limit-macrowith primary purpose to provide tests -
combination
lib to do math jobs like permutate and combinate data from vec
-
goofy_standardlib
goofy ahh standard library
-
percentage-rs
Get the percentage of any number
-
data_models
used to lookup the sizes of various C-types of historical data models
-
rust-fp-categories
Functional Programming Library in Rust, Category
-
sconcat
String concatenation
-
unchained
Iteration
-
maybe-uninit-ext
Extended maybe-uninit types
-
clap-handler
command handler works with
clap-deriveto generating subcommand handlers -
clap-action-command
command-map pattern layered on Clap subcommands
-
caffe2-init
xxx
-
gen-iter
temporary util for creating iterators using generators
-
lurk-ipld-macro
lurk-ipld macro
-
revolt-result
Revolt Backend: Result and Error types
-
cartesian
QOL macro that creates the cartesian product of multiple iterators
-
cocaine
Framework Rust
-
ninja-files-kubectl
Ninja file functions to kubectl
-
validaten
Common validators for cryptocurrency, creditcards, domain, url, etc that can be used across projects
-
clonesure
helper macro to create closures which will clone its environment
-
wasmium_errors
Common error handling for the Wasmium crate ecosystem
-
libnotify
bindings to libnotify
-
stack-bitset
Stack-allocated generic-sized bitset implementation. WIP
-
size
expressing, formatting, and interacting with file sizes
-
jsandbox
JavaScript sandbox using deno runtime
-
blobber
Create an arbitrary length of string
-
linspace
Traits for numpy linspace equivalent functions, into both vectors and arrays, the latter of which can be executed at compile-time
-
fmt-cmp
Traits and utilities for lexicographically comparing values in their
Displayrepresentations -
tangram_finite
Tangram makes it easy for programmers to train, deploy, and monitor machine learning models
-
pathsep
small macro to enable easy path construction in other macro calls
-
char_combinator
iterator to create all combination of a given char range
-
dbgprint
set of macros that output the STDOUT and STDERR of the program only in debug mode
-
rich-phantoms
Phantom types with control over variance and sync/sync inheritance
-
rust_c
Write C code inline in your rust code (hacky fork of rust-cpp / cpp crate)
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
proc-macro2-fallback
Only the non-libproc_macro-based codepath of the proc-macro2 crate
-
col_proc_macros
bunch of procedural macros for declare collections of various kinds from their contents as fast as possible
-
classes
Dependency-free macro that simplifies the process of building class strings for DOM elements
-
ratelimit_rs
ratelimit package provides an efficient token bucket implementation
-
lox_utils
General helpers used by Lox
-
is_chinese
detect whether a string is all Chinese
-
another-visitor
Lets you derive visitor pattern implementations
-
fhirbolt-element
Internal element model library of the fhirbolt project
-
rollercoaster
Extra iterators for grouping, sorting, arithmetic, and more
-
slablit
Literal for slab creation
-
tiptoe
easy-to-support intrusively reference-counting smart pointer
-
fsize
fsizeis aliased to the floating-point type of pointer size -
smptera-format-identifiers-rust
Constants for Format Identifiers defined by the SMPTE Registration Authority
-
kmacros_shim
Useful macros
-
nom-fields
single function-like macro that removes some boilerplate from a common pattern when using nom
-
higher-order-closure
Allow function lifetime elision and explicit
for<'a>annotations on closures -
handlers
macro for generating systems of event handlers
-
fix_me
very simple macro that lets you write temporary code that WILL NOT build in release mode
-
persian_str_rs
functions for working with Persian strings in Rust
-
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
entry_put_ext
Map entry extension for put operations
-
poison-guard
maintaining sane state in the presence of panics and failures
-
variant_count
Derive macro for enum which adds to it the count of variants
-
recursive_reference
way to walk on recursive structures easily and safely
-
fastperm
dead-simple, extreme fast permission flag system for Rust with no dependencies
-
ethers_primitives
Primitive types for ethereum, including Rlp/ABI encode/decode support
-
lazy-seq
constructing lazily evaluated sequences
-
resultit
Iterator adapters for iterators over results
-
hax-frontend-exporter
hax frontend exporter helper crate
-
macro-dep-test
testing version resolution for associated macros
-
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
trie
ordered map and set based on a trie
-
log_err
Log error messages from Unwrap and Expect with log crate
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
lubeck
Functional programming framework written in cutting edge rust
-
egui_graphs
Interactive graph visualization widget for rust powered by egui
-
mmapio
Cross-platform Rust API for memory-mapped file IO
-
then
bool::then functions but named properly
-
id-pool
Create and recycle integer ids using a ranged pool
-
convertable-errors
defines an ergonomic macro for deriving From<Foreign> conversions for variants of Rust enums
-
unty
Explicitly types your generics
-
regex-macro
macro to generate a lazy regex expression
-
nonzero
Statically checked non-zero integers
-
proto-mapper-core
Internal helper library for proto-mapper
-
mango-egui
My egui widgets
-
label
functions and iterate over them
-
multindex
Index slices with multiple const indices/ranges
-
emoji-commit-type
different commit types used in the emoji committer
-
either_n
Either enum with N variants
-
appendlist
append-only list that preserves references to its elements
-
nanopre
zero-dependency, no-unsafe implementation of a minimal C-style text preprocessor
-
smart_access
minimalistic "lazy bidirectional pointer" framework
-
timpl-decl
timpl declarative macros. Not meant to be used directly. Use timpl instead.
-
wurm
Non-fatal, strongly typed errors
-
panic-message
Get a panic message from a panic payload
-
erroneous
Minimalistic helper for using errors
-
lelet-defer
lelet defer
-
bidirectional_enum
Automatically generates conversions between an enum type and any other type
-
dsl
miniapp
-
noodles-core
Shared utilities when working with noodles
-
rev_slice
newtype for operating on a reversed view of a slice
-
targets
Some helpers to get you started with declarative programming in Rust
-
fstrings
Python3 fstring interpolation in Rust
-
tor-basic-utils
General helpers used by Tor
-
collect_into_rc_slice
that let’s you collect an
Iterator<Item=T>into anRc<[T]>orArc<[T]>without needing to make 2 heap allocations -
bulletproofs-plus
Bulletproofs+ implementation
-
envor
Get env vars to types with default
-
retry_macro
set of declarative macros which retries executing a function upon failure
-
mcurry
Macros for creating curried functions
-
nclosure
composable, nameable closure types with separated states and functionality for use in APIs where anonymous types are unavailable
-
arr_ty
Macros for smart array initialization (best for trait object element types)
-
love_rust
so I don't have to re-write the same thing everytime
-
hex-display
Display impl for byte slices which provides a hexdump
-
piston_meta_search
search API for piston_meta
-
msiz_rustc-ap-rustc_errors
Automatically published version of the package
rustc_errorsin the rust-lang/rust repository from commit 74d5c70b174f06843049af2d764ff57ddc81c81c The publishing script for this crate lives at: https://github… -
bigfactorial
Precalculated compile-time factorial macro for numbers upto 99
-
have
Let any type have some fun
-
extendable_vm
that simplifies implementation of stack VMs
-
input-macro
No-nonsense input!(...) macro for Rust
-
simple-dmenu
macro to call dmenu
-
outcome
Success/Failure type for rust
-
zhi_enum
derive macros to easily use enum
-
string-eyre
Convenience traits for dealing with errors that don't want to eyre
-
rayon-join-macro
convenience n-nary macro around
rayon::join() -
optarg2chain
Converts optional arguments to chaining style
-
cismute
Safely transmute type to itself in generic contexts
-
singlemap
single map
-
langen
create programming languages
-
annotation-rs
Compile-time annotation parser for rust
-
blackbox_di
dependency injection library
-
display_container
implement Display
-
gtld-data
gTLD data retrieved via the IANA, updated daily
-
sensulator
sensor simulator, provides noisy readings of ideal measurements
-
tryvial
Small crate for ok-wrapping and try blocks
-
ta-common
Common traits and models for technical indicators
-
birds
Combinators using Rust macros
-
struct-convert
Auto Convert between structs
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
job-dispatcher
execute jobs in an async way
-
eliza_error
“Times are bad. Children no longer obey their parents, and everyone is writing an error handling library.” — Cicero
-
timed_set
timed set in Rust to store elements for a given time period
-
breakable-block
shim library for a stable implementation of what is proposed in RFC 2046
-
tyname
Retrieve type names during program execution on stable Rust
-
const_sort_rs
Sort slices in const items
-
moveslice
one-function crate to move chunks in a slice around
-
wasm-bus-types
WebAssembly Bus Macros
-
nested-ref
References to data contained in one or more nested RefCells
-
hypermod
Automatically build the module tree from the src/ dir
-
kaguya_rs
Functional Programming tools and ADTs
-
rust-2018
Macro to use Rust 2018 from all editions
-
makero
macro_rules!macro to aid in the creation of complexmacro_rules!macros -
source-chain
Formats StdError with it's source chain
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
iter2
Iterator
chaining,cmping and more as free functions taking twoIntoIterators -
curmacro
usefull macros like struct getters and setters creation macros
-
bointer
Assorted pointer-related utilities
-
size_hint
very simple library to provide a size_hint for an iterator which does not provide it's own
-
guid-partition-types
small crate designed to work with parition types and their GUIDs
-
r4
compact macro that generates iterators using for comprehensions and natural Rust syntax
-
conventus
Traits for assembling and disassembling items
-
bdecode
Bencode decoder in Rust which uses the same algorithm as libtorrent
-
cynic-introspection
GraphQL API introspection for cynic
-
todo_using
super small crate only exporting a single macro to "use" parameters
-
stylish-plain
stylishhelpers for discarding styles -
default-test
default trait that can be used in tests
-
ataraxy
Discord slash commands framework for Serenity
-
newtype-derive-2018
macros for deriving common traits for newtype structures
-
plugin
Lazily evaluated, order-independent plugins for extensible types
-
event-observer
observer pattern by rust
-
sicd-rs
interact with SICD files
-
common-strings
Macro for storing common strings as enum variants
-
helper
provided some useful proc macros for Rust
-
enum_str
Creates a unitary enum and conversions from enum variants to string and vice versa
-
enum_to_enum
Derives possibly effectful conversions between enums
-
enumx
Ad-hoc enum extension
-
slip10
SLIP-0010 : Universal private key derivation from master private key
-
iwlib_sys
Bindings to iwlib for which can be used to manipulate wireless extension for Linux
-
array_iter_tools
Modify simple arrays
-
rusty-html
allows for Jsx html inline like syntax in rust
-
dynamic-cast
fifth pillar of OOP: dynamic casting
-
winresult-types
windows result types
-
shoggoth
Generic and type-level programming for Rust
-
ra_ap_ide_completion
TBD
-
iterify
Turn any type into an iterator with closures!
-
rearrange
Alternative API for sorting by multiple properties
-
any_ref
capture and move things that are NOT 'static with memory safety
-
fxp
Fixed-point numbers in Rust using const generics
-
inner
inner! macro descends into an enum variant. It's more flexible than try!() and unwrap(), and it works with your enum, too!
-
durs-common-tools
Common rust tools for DURS project
-
type-detector
Data type detector from String value
-
pfn
Provide fn_trait’s
call,call_mut, andcall_onceon Stable Rust -
left-pad
left-padding for strings
-
pipeline
macro collection to pipe |> your functions calls, like in F# or Elixir
-
typestring
String constants lifted into types. This is a stopgap until const generics support strings.
-
thistermination
add the Termination trait to error enums inspired by thiserror
-
reinterpret
Low level utility functions to reinterpret arrays of data
-
maparr
macro to build a static
Mapbased on const array -
tested-trait
Associate tests with traits
-
impl-enum
Macros that make using enums like trait objects more convenient
-
ident
wrapping types with an immutable identifier and storing/accessing such types in collections
-
extern-existential
extern existential types prototype
-
mononym
Type-level named values with partial dependent type support in Rust
-
printd
Debug expressions and print debug labels. An enhanced version of
dbg!(). -
luao3
Lua bindings for Rust, oriented around macros. Lossly inspired by pyo3, but based on mlua.
-
zipWith
iterator for zipping with a combination function
-
bidule
Ultra simple Functional Reactive Programming, made with stuff, things, device, thingumajig, etc
-
rustc_version_runtime
querying the version of the rustc compiler used in runtime
-
frunk_utils
working with frunk
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
map-trait
Generic Map trait
-
aligned-vec
Aligned vector and box containers
-
bounded_types
type representing bounded integers, implemented using const generics
-
rx_gtk
rx utils for gtk-rs
-
typebitset
Type-level bitset implementation
-
sugar
syntax sugar collections
-
binstring
Binary strings
-
compile-time-crc32
taking the crc32 of a string or byte literal at compile time
-
imgref-iter
small crate for iterating over the rows or columns of
imgrefbuffers -
prost-msg-id
prost impl message id
-
iter-opt-filter
Adds an optional filter to iterators
-
arraybox
box with fixed capacity, backed by a byte array (it can be stored on the stack too). Implements fixed capacity
ArrayBox. -
inew
Macroses for constructor generation
-
compiler_error
Triggerable compiler error
-
foot-gun
Friendly aliases for your unsafe code
-
qol
Quality Of Life functions and macros
-
codes-common
Support capabilities for codes-* packages
-
mint
Math interoperability standard types
-
letr
macro for the lazy
-
borrowck_sacrifices
Necessary sacrifices to keep the Borrow Checker happy and developers sane
-
bytekey
lexicographic sort-order preserving binary encoding
-
abhtest
Tests in cargo packaging
-
rustspec
BDD style test library
-
unsafe-storage
Maintain invariants in macros without modules
-
type-id
-
vecc
macro to create a vector of vector
-
ordered_iter
Ordered iterators
-
onhtml
dsl for writing html. This is not an html template! Not complete but easily extensible.
-
macro-while-mut
Macro that allows create while-cycle with mutable condition state
-
iterware
middleware for iterators
-
rustility
collection of utilities I often find myself using in Rust
-
ordinal-type
Ordinal type for Rust
-
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
fix_fn
Macro to create recursive closures (similar to the Y combinator)
-
macaroni
missing macro std library for Rust
-
bsatoollib
working with BSA files
-
scoped-sleep
RAII sleep
-
ssexp
powerful parser for s-expressions
-
num_bound
Add bounds fn to anything implementing
Ordthat bounds a number to a range -
ref-ops
escape hatch for implementing
opstraits for references to newtypes -
argst
one-macro crate for generating StructOpt boilerplate and binding args
-
project-uninit
Macros for safe references to and initialization of fields in MaybeUninit structs
-
with-id
trait providing method for getting string id from struct
-
director_core
Director is a simple, versatile, ergonomic state machine in Rust-lang
-
simple-timer
timer macro
-
increment
all types of integers if it is still possible
-
flag-mast
Ergonomic Rust bit flags
-
to_any
Auto derive ToAny trait for any structure
-
sh-inline
Macros to run inline shell (bash) script
-
py-sr25519-bindings
Python bindings for sr25519 library
-
json-event-parser
JSON event parser and serializer
-
error-chain-mini
error-chain for minimalist
-
vizz
creating GraphViz/DOT visualizations of Rust data structures
-
hex-literal
Macro for converting hexadecimal string to a byte array at compile time
-
singleton-stepanov
isn't meant to be used by itself, but as template for your our types. Attempt to do Efficient Programming with Components: Lecture 2 Part 1, Efficient Programming with Components:…
-
hashmap-entry-ownable
Variation of HashMap::entry() that accepts borrowed forms of keys
-
cmd_error
print an error message and exit while unwrapping Options and Results
-
agar
bindings for Rust
-
typid
(Typ)ed Unique (Id)entifiers
-
html5ever-atoms
Static strings for html5ever
-
text-block-macros
Create a multiline string literal
-
zkp-criterion-utils
Criterion helpers to benchmark over size and number of processors
-
envvar
tiny crate provides the
var()function which is the same asstd::env::var()but theNotPresentvariant ofVarErrorprovides the name of the missing environment variable -
optifier
macros for deriving optional types
-
surf-pool
modules and functions useful to interact with the pot framework
-
binary_ok
help you convert from binary to decimal and from decimal to binary, you can pass as reference &f64 and &u128 numbers
-
RustyEmitter
RustyEmitter is a basic implementation of a simple emitter. The module expose a Events trait with the on, off and emit methods, and a default implementation of that trait, called Emitter.
-
yolo
Rusts .yolo()
-
tugger-rpm
RPM packaging primitives
-
dyn_struct
Construct dynamically sized types safely
-
boh
holder of many things
-
libc-stdhandle
Helper functions for retrieving stdin, stdout, stderr
-
list_builder
Python-like list comprehensions in Rust
-
enum_from_str
Enable deriving FromStr for enums
-
string-utility
substring implementation (with the RangeBound trait), keep string before or after a specified string, etc
-
nestle
Encode/decode arbitrary nested tree-structured data with a single integer
-
trans-gen-javascript
Generating JavaScript trans code
-
oops
Lightweight error-handling. Provides
Option<T> -> std::io::Result<T>. -
gmssl-errors
Custom error library support for the gmssl crate
-
std_prelude
prelude that the rust stdlib should have always had
-
float
Lightweight wrappers around primitive floating point types
-
latch_iter
latching iterator adapter
-
smart
dynamically-dispatched smart pointers
-
ad-hoc-iter
Ad-hoc exact size owning iterator macro and other optional utils
-
chained
lazily chaining functions
-
composing
Tools to compose functions
-
verifier
Macros that provide common software verifier primitives
-
fugue-bytes
binary analysis framework written in Rust
-
buildable
trait definition and utilities helpful in build lifecycles
-
libax
Helper functions for cbax projects
-
bitmatch
macro to allow matching, binding, and packing the individual bits of integers
-
data-query-lexical
lexical support library for the Data Query
-
enum_variants
Deriving traits for C-like enums using macro 1.1
-
ld_preload_helpers
Macros to run code at load time and override C functions
-
llvm-sys-wrapper
Shallow wrapper for llvm-sys
-
failsafe
circuit breaker implementation
-
progressive
showing progress of iterators and loops
-
u-plus
Pretty Unicode code point literals: U+12345 instead of '\u{12345}'
-
type-store
lightweight library for storing values in a map by type, aka a type map
-
fn_ops
Temporary traits for function operator overloading, pending the stabilization of
Fn,FnMut, andFnOnce -
bevy-add-events-macro
macro to add multiple events to a bevy app easily
-
trait_cast_rs
Get your own Any with support for casting to trait objects
-
delegatemethod
Delegate method calls to a field
-
buffed
Traits & implementation of parsing buffered IO
-
common_failures
Helpers for 'failure', including io::Error wrappers with paths, quick_main!, display_causes_and_backtrace
-
refraction
general-purpose lens library for Rust
-
newtype-enum
Traits to convert between enums and their variant types
-
macro-utils
Some macros to make code writing more elegant and funny
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
rlua-builders
Derive helpers for struct/enum for rlua
-
lgl
Small directed graph library https://github.com/lwander/lgl
-
unreachable_checked
unreachable!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won't panic.
-
sid
Id. Tiny crate providing strongly typed ids and an id-based vector.
-
indirect-once
One-time resolvable runtime indirection in the style of glibc's ifunc
-
factory_steel
fixture replacement greatly inspired by factory_bot and factory_boy
-
cyclic_data_types
Cyclic data types are series of structs, enums, types and functions to create a series of fast data types
-
cargo-verify
Prettier error messages for the verified crate
-
kaboom
Intuitive library for Next-Gen application exiting
-
fn_grad
trait for functions that have a gradient
-
specialize
Type specialization macros and helpers
-
bounding-space
N-dimensional bounding space
-
brain_rust
BF transpiler to rust written as a rust declarative macro
-
mashin_primitives
Primitives for mashin resources
-
range-map
Maps and sets implemented using ranges
-
fluid-macro
Write long method chains as a series of steps instead, and more!
-
squote
clone of the quote crate that uses a String as its backing store
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
throws
macro for easy creation per-function errors
-
impl_inheritance
experimental & work in progress
-
mods
Simpler module declaration
-
matrixgraph
graph implementation based on dense adjacency matrices
-
rust_study0
First study project of RUST
-
common_regex_rs
Set of common regex for Rust
-
vet
Arbitrary type validation
-
cosmian_ffi
Tools to build Foreign Function Interfaces at Cosmian
-
hash-that-set
Implements hashing for sets and maps themselves. Enables a map of maps to values, or a map of sets to values.
-
minidom_ext
Extension traits for minidom::Element
-
trace2
proc macro for tracing the execution of functions, similar to trace crate, but thread safe and use log
-
squeak
providing types allowing execution of callbacks in response to values being broadcast or mutated
-
hatch_result
result-like struct that returns on Ok, instead of on Err when ? operator is used
-
simple-counter
Macro for generating thread-local static counters. Useful for basic ID generation.
-
netcon
collections of tools and helper functions developed for and by NetCon Unternehmensberatung GmbH
-
visita
Elegant implementation of the Visitor Pattern
-
vector3d
3D vector type
-
tiny_fail
Fail type
-
redpen-shim
proc-macro attribute provider that allows crates to annotate their code with redpen lints without breaking their build
-
aivm_train
training AIVM code
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
num_alias
macros to declare 'type checked' aliases for integers and floats
-
flaggy-values
Types for representing parsed command-line flag values
-
stringly_conversions
helping to convert to/from various representations of strings
-
ifmt
Inline expression interpolation for Rust
-
ra_ap_hir_def
TBD
-
future-union
future::Either with
impl Future -
from_int
package to easily add a from_int method to enums with #[derive(FromInt)]
-
rustkell
haskell like functions in rust
-
iterext
Padding and separation extensions to iterators
-
eternal_iterator
Trait implementation to promise that the iterator iterates forever
-
srcpos_get
triat for srcpos, Calculate Loc / Pos
-
error-context
Methods and types that help with adding additional context information to error types
-
replisdk-proc
Procedural macros crate for replisdk
-
target_info
Get text strings of attributes concernign the build target
-
sqlink-derive
postgres builder derive to work with postgres
-
event-driven-library
Event Driven Message Handling
-
diff-ba-rs
macros to get the difference of variables caused by a procedure
-
close
Trait + smart pointer for manual object destruction
-
overflow-error
Common overflow error types
-
apply
tiny library for chaining free functions into method call chains
-
sashay
Type-erased and lifetime-erased references and slices
-
warned
struct Warned<T, W> { value: T, warnings: Vec<W> }, which represents a value with warnings
-
derive-alias
Alias multiple derives as one
-
new_flattened
Macro to flatten nested calls of
news -
cheque
Convenient checked math
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
assert-cmp
Convenient assertion macros that print the failed expressions and their evaluated values
-
transitive_from
Helper macros for creating hierarchies of transitive
Fromimplementations -
displaydoc-lite
Implement the Display trait using your standard doc comments
-
cxx-symbols
detail of the
cxxcrate -
shrinkwraprs
Auto-derive for Rust conversion traits -- make working with newtypes a breeze
-
transition-table
transition table utilities for keyword parser
-
consume-iterator
Consume any iterator fully
-
c314-utils
Small Rust utilities
-
ov
collection of traits that allow you to chain off of anything
-
hicollections
C-liked Collections
-
strings
String utilities, including an unbalanced Rope
-
refinement
Convenient creation of type-safe refinement types
-
result-inspect
Adds the missing Result::inspect() function
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
tylar
Type-Level Arithmetic in Rust
-
assert_exists
Useful macro to assert that a certain symbol exists in the source code. This is useful to strictly couple otherwise loosely coupled functions and symbols that depend on each other.
-
try_utils
try! macro descends into an enum variant. It's more flexible than ? and unwrap(), and it works with your enum, too!
-
fast-rustc-ap-rustc_errors
Automatically published version of the package
rustc_errorsin the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
prgrs
progress bar for rust, that aims to work like the python package tqdm
-
ra_ap_ide_diagnostics
TBD
-
base-coroutine
fast and safe implementation of stackful coroutines with scheduler which supports preemptive scheduling
-
wcgi-host
implementing WCGI (Webassembly Common Gateway Interface) support in hosts
-
match_opt
macro for turning a partial match into a full match returning an option
-
arbintrary
Proof of concept for arbitrary integer sizes using generic const
-
try_or_wrap_s
?ortry!macro, with an additional wrapping of the error in something else -
rusty_state
state machine for rust
-
colmac
Macros to work with
std::collections -
cfor
macro that gives Rust a C-style for loop, with initialisation, condition and step. This correctly handles control-flow like continue and break.
-
byte_array
that supports Java-like series processing with byteorder
-
retain_mut
Provide retain_mut method that has the same functionality as retain but gives mutable borrow to the predicate
-
result
Helpers for dealing with nested Result and Option types
-
proc_use
Semi-dynamic mod and use
-
fenris-traits
Core traits used by fenris
-
mutslices
ability to create many mutable slices of a vector
-
aidanhs-tmp-parse-generics-shim
stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
rw-exact-ext
Extension of std::io to read and write data types with exact amounts of bytes
-
yield-return
Implement a coroutine like C#‘s
yield returnusing Rust’sasync,await -
as_base
Cast trait objects to some base class
-
davenport
Ergonomic thread-local workspaces for intermediate data
-
many_op
do an operation on many variables
-
stuff
Stuffing things into pointers
-
adrop
fast dedicated thread drop
-
from_iter
Initialize arrays from iterators
-
arraytools
variety of helpful methods for working with fixed-size arrays
-
fmt2io
bridge between std::io::Write and std::fmt::Write
-
with-thread-local
micro crate that simplifies a bit the use of the std macro
thread_local! -
hamlet
Html token definitions for stream processing
-
scoped_reference
Runtime-checked borrow lifetimes
-
sike
convenience trait for easy negation
-
cfg-or-panic
Replace function bodies with
unimplemented!()when condition is not met -
singleton-cell
more powerful Ghost Cell allowing the use of any singleton as the key
-
shared_singleton
trait provides singleton pattern state management with shared container
-
roopert_macro_common
object-oriented toolkit for Rust (common data)
-
dict
Exercise crate implementing real associative arrays, also known as dictionaries
-
enum_pipeline
way to use enums to describe and execute ordered data pipelines
-
try-blocks
macro to emulate the upcoming
tryblock feature on stable -
tinytest
Write more compact unit tests with a small macro
-
hkt
Simulated higher-kinded types for Rust
-
serde_type_name
lookup name of type for any struct or enum that derives serde Serialize
-
mtrs
matrices in Rust
-
fastfloat
Fast-math wrapper and convenient numeric functions for approximate floating point operations in Rust
-
hs-bindgen-types
types behind hs-bindgen ergonomics
-
ortho_vec_derive
Derive orthogonal vector structure for better CPU cache usage
-
macro-attr
macro_attr!macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derivecrate. -
manifest-dir-macros
function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
cum
Cumulative operation helper functions
-
optargs
Easily create macros for functions with optional arguments
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
sorted
compile time guarantees for sorted sequences
-
stringly_typed
updating values and indexing into Rust types at runtime
-
docgen
made for dynamically documenting Rust items created by a macro
-
default-port
trait DefaultPort
-
simple_env_load
.env loader without any deps
-
unwrap-sugar
Just a simple sugar for unwrapable expressions
-
rustc-std-workspace-std
Workaround for rustbuild
-
larc
Lazy Arc/Weak pointers
-
maller
that calls closures depending on the input data
-
slicefields
Allows for data structures whose members are sub byte aligned (e.g. a one bit alignment)
-
syn-test-suite
Test suite of the syn crate
-
stack-trait
Stack trait with entry API for the LIFO element
-
no_error
error library for no_std
-
futility
Functional Utility types, macros, and functions for common tasks or needs in Rust
-
enum_index_repr
EnumIndexRepr provides a small macro which allows getting the index on an enum
-
com-wrapper
interface for types which are a wrapper around a
wio::com::ComPtr -
advancedresearch-nano_ecs
bare-bones macro-based Entity-Component-System
-
quantified
Specify the universe: None, Some, Excluding, and All
-
nonicle
Tools for type-safe, canonical data representations
-
revord
Reversed ordering crate for rust
-
expression-num
Numerical expression implementation based on expression-rs
-
koption_macros
Some macros that are useful for working with
Options -
tinyrand-std
Extensions for using tinyrand with std
-
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
-
srce
Self-Ref Cell Environments
-
cfg_matrix
Procedural macro to generate permutations of supertraits based on cfg flags
-
try-ref
AsRef/AsMut version of TryFrom
-
xplane_plugin
types and a macro for creating X-Plane plugins
-
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
-
formy
derive macro to turn structs into html forms
-
rancor
Scalable and efficient error handling without type composition
-
shorten
collection of convenience functions, macros and traits to shorten repetitive code
-
mexset
Implementing a set with MEX support
-
static_assert_macro
so-called
static_assert -
stringx
Traits for often used functionality when generating or modifying strings
-
error
fancy error type for highly generic cases
-
gpt-macro
Macros leveraging GPT
-
coda
Limitation Game
-
degeneric-macros
Hides struct generics into trait associated types
-
enum_index
Trait and macros for extracting Enum variant index
-
whiteout
macros that erase the type of any value into an impl Trait for a given trait
-
on_drop
on drop
-
hash-trie
Hash Array Mapped Trie (HAMT) Immutable Set Implementation
-
fixed-macro-types
Macro aliases used in the
fixed-macrocrate -
select_indices
Iterators for taking multiple shared/exclusive references from a slice
-
context_bind
M:N threading library. Should support Linux, MacOS, Free/OpenBSD, and Windows for x86/64, and aarch32/64
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
harled
Helper traits for developing derive macros similar to darling
-
vec3
-
lifted
Higher-kinded types in Rust
-
fn_block
defining macros for calling blocks or expressions in a closure
-
rustc_utils
working with the Rust compiler
-
arcerror
thin wrappers around Arc<T> and Rc<T> where T: Error. Impls Error for both of these types. No unsafe, no dependencies.
-
consume_ptr
attempt to generalize unwrapping behavior for pointer types, also to provide better way of transferring ownership of unsized types
-
stupiderators
Iterators for Indeedee, mostly
-
ptr_iter
Iterators to simplify working with pointers
-
byteorder_slice
Byteorder like crate for &[u8]
-
bit_fiddler
Macros for common bit operations with multiple convenient patterns
-
unify
Trait-based equality constraint for Rust
-
assert-graph-iso
Test utility for checking if two graphs are isomorphic
-
power-assert
Power Assert in Rust. Provides better assertion message.
-
set-error
very simple trait that overwrites errors
-
modifier
Fluid chaining APIs for both mutable ownership types
-
nestxml
Tools to easily nest XML or HTML elements
-
ret_ty_attr
Specify the return type depending on configuration conditional checks
-
cw-dsl
Resolve tag weights of cyber waifu
-
envload
Automatically fill structs from env variables
-
traverse
Proof-of-concept trait for internal iterators called traversals
-
fake-enum
creating FFI safe "fake" enum types
-
batbox-tuple-macros
Macro for calling your macro for all tuple sizes
-
deferred-reference
deferred reference is not an actual reference, it is merely a smart pointer tied to the lifetime of the location it points to
-
retryable
Automatic function retry macro
-
empty-library
Just an empty library
-
protected_integer
that protects some variables from being modified by memory tampering tools
-
rc-borrow
Borrowed forms of Rc and Arc
-
sum_type
convenience macro for creating a wrapper enum which may be one of several distinct types
-
spans
Split an iterator into contiguous spans
-
dbg_hex
display dbg result in hexadecimal {:#x?} format
-
pstr
Global String Intern Pool
-
propane
generator syntax experiment
-
anon_enum
Enum types with fully-generic variants
-
user-panic
Error messages
-
cc4
Very simple implementation of the four_cc/fourcc algorithm as a const fn
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
read-byte-slice
iterator over chunks of bytes as slices from an underlying reader
-
metered
Fast, ergonomic metrics for Rust!
-
enum_properties
macro for declaring static properties on enum variants
-
nbytes
compile-time evaluation of byte unit conversions
-
srmw
Asynchronous single-reader, multi-writer
-
rvs
defining and evaluating random variables using a simple DSL
-
compound-error
Compound errors with flat hierarchy
-
prop_tune
simplify work with Propositional Statements
-
byte_sha
Performs SHA256 on a Vec<u8> and returns a Vec<u8> as the result. Useful for cryto curencies and purhapse other things.
-
xmlparser-derive
proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
amper
Pack of macros for web-programming in Rust
-
crashreport
Automatic GitHub crash reporting system for any Rust crate
-
spidermeme
Traits to test for type equality and type inequality
-
io-arrays
Random-access I/O
-
fuzzypath
Quick & dirty fuzzy path comparison
-
schwifty
IBAN validation library inspired by Python's schwifty
-
ferrum-plugin
Lazily evaluated, order-independent plugins for extensible types
-
not_empty
Slices and vectors that are statically guaranteed to be not empty
-
disown
Drop ownership via a method
-
readonly
Struct fields that are made read-only accessible to other modules
-
enum-tags
Derive-Macro library that generates a companion tag-enum for any enum so that variants can be referred to without specifying fields
-
collections_macros
collection of macros to make making collections easier
-
repc
APIs to calculate the layout of C types
-
fold-license
Folding licenses from multiple dirs with
cargo/Cargo.toml andyarn/package.json -
groupable
Easily aggregate groups of values from key-value Iterators
-
hex_literals
Macro that converts hex strings to byte strings
-
unwrap_or_do
Unwrap the Result or do an expression followed by returning the result
-
to_unit
ToUnit; Any type to () syntax sugar
-
swahili-dsl
Swahili-based DSL made for educational purposes
-
string_mac
lazy man's String macro
-
zst
Zero-sized generic type with the associated type exposing the type parameter
-
boolinator
trait, which lets you use Option and Result-style combinators with bools
-
katexit-example-nightly
Rendered example of katexit with nightly rustc
-
dyn_struct2
Construct dynamically sized types safely. Supports arbitrary unsized types, not just slices
-
ein-ffi
FFI library for Ein programming language
-
dyn_partial_eq
PartialEq macros for trait objects
-
xpr
general purpose generic expression template library
-
ama
Quasi-quotation system for designing procedural macros mixed with Rust code
-
some_crate
If you just need a crate that's guaranteed(*) to do practically nothing
-
pure_ref
making immutable references only
-
phf_mac
Compiler plugin for perfect hash function data structures
-
rsbt
description
-
minipre
Minimal C-preprocessor in Rust
-
profile_time
2 simple macros to separate debug code and release code
-
trie_map
trie with good iterator support backed by a hashmap
-
ipfs-cid
Generate IPFS CIDs (Content Identifiers) from a slice of bytes
-
wonderbox
minimalistic IoC library
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
strerror
string-based error type. No longer developed. Recommended replacement: Anyhow and Thiserror crates.
-
netcdf3
pure Rust library for reading and writing NetCDF-3 files
-
guest_cell
Storage space for externally-owned private data
-
ipcs-apidefs
API type definitions for IPCS HTTP api
-
spawn_timeout
Call a subroutine after a constant time interval