-
bitflags
A macro to generate structures which behave like bitflags
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
thiserror
derive(Error)
-
anyhow
Flexible concrete Error type built on std::error::Error
-
derive_more
Adds #[derive(x)] macros for more traits
-
once_cell
Single assignment cells and lazy values
-
predicates
boolean-valued predicate functions
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
ordered-float
Wrappers for total ordering on floats
-
darling
A proc-macro library for reading attributes into structs when implementing custom derives
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
async-stream
Asynchronous streams using async & await notation
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
bytes
Types and traits for working with bytes
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive -
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
human-panic
Panic messages for humans
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
typed-builder
Compile-time type-checked builder derive
-
dyn-clone
Clone trait that is object-safe
-
approx
Approximate floating point equality comparisons and assertions
-
similar-asserts
assert_eq! like macros with colorized diff output
-
smol_str
small-string optimized string type with O(1) clone
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
rustlings
Small exercises to get you used to reading and writing Rust code!
-
memoffset
offset_of functionality for Rust structs
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
static_assertions
Compile-time assertions to ensure that invariants are met
-
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… -
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
snafu
An ergonomic error handling library
-
ouroboros
Easy, safe self-referential struct generation
-
compiler_builtins
Compiler intrinsics used by the Rust compiler. Also available for other targets if necessary!
-
macro_rules_attribute
Use declarative macros in attribute or derive position
-
tap
Generic extensions for tapping values in Rust
-
cfg-if
A macro to ergonomically define an item depending on a large number of #[cfg] parameters. Structured like an if-else chain, the first matching branch is the item that gets emitted.
-
bitfield
macros to generate bitfield-like struct
-
pin-project
safe and ergonomic pin-projection
-
arrayref
Macros to take array references of slices
-
backon
Make retry like a built-in feature provided by Rust
-
frunk
developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
beef
More compact Cow
-
bon
Generate builders for everything!
-
float-cmp
Floating point approximate comparison traits
-
error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
extendr-api
Safe and user friendly bindings to the R programming language
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
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…
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
inventory
Typed distributed plugin registration
-
az
Casts and checked casts
-
if_chain
Macro for writing nested
if letexpressions -
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]checks -
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
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
-
safer-ffi
Write safer FFI code in Rust without polluting it with unsafe code
-
orchestra
Generate an orchestra of subsystems from a single struct
-
nutype
The newtype with guarantees
-
rustdoc-types
Types for rustdoc's json output
-
pact_consumer
Pact-Rust module that provides support for writing consumer pact tests
-
opaque-debug
Macro for opaque Debug trait implementation
-
index_vec
Newtype-style helpers for
Vecandusize -
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
konst
Const equivalents of std functions, compile-time comparison, and parsing
-
float-ord
A total ordering for floating-point numbers
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
inlinable_string
inlinable_stringcrate provides theInlinableStringtype – an owned, grow-able UTF-8 string that stores small strings inline and avoids heap-allocation – and theStringExttrait… -
sptr
Strict Provenance Polyfill
-
dlib
Helper macros for handling manually loading optional system libraries
-
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 -
constcat
concat! with support for const variables and expressions
-
stdext
Extensions for the Rust standard library structures
-
unwinding
in Rust and for Rust
-
derive-where
Deriving with custom trait bounds
-
assertables
assert macros for better testing, debugging, quality assurance, and runtime reliability
-
polonius-the-crab
Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
volatile
wrapper types for raw pointers
-
fallible-iterator
Fallible iterator traits
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
nonempty
Correct by construction non-empty vector
-
extism-pdk
Extism Plug-in Development Kit (PDK) for Rust
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
async-trait
Type erasure for async trait methods
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
by_address
Wrapper for comparing and hashing pointers by address
-
buffered-reader
A super-powered Reader
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
lazy_format
lazily formatting values for later
-
aws-smithy-types-convert
Conversion of types from aws-smithy-types to other libraries
-
writeable
A more efficient alternative to fmt::Display
-
recursion
cache-aware stack safe recursion
-
testresult
type for concise and precise test failures
-
async-once-cell
Async single assignment cells and lazy values
-
bounded-integer
Bounded integers
-
iter-read
A Read implementation for iterators over u8 and related types
-
educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits
-
retry
retrying operations that can fail
-
virtue
A sinless derive macro helper
-
field-offset
Safe pointer-to-member implementation
-
fatality
extension to
thiserror::Error -
rustler
Safe Rust wrappers for creating Erlang NIF functions
-
inout
Custom reference types for code generic over in-place and buffer-to-buffer modes of operation
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
tynm
Returns type names in shorter form
-
cascade
Dart-like cascade macro for Rust
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator -
fallible_collections
adds fallible allocation api to std collections
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
bounded-collections
Bounded types and their supporting traits
-
iri-string
IRI as string types
-
retour
A cross-platform detour library written in Rust
-
error-code
Error code
-
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… -
const-gen
generating (relatively) complex compile-time constants in rust
-
indoc
Indented document literals
-
chalk-ir
Chalk's internal representation of types, goals, and clauses
-
thiserror-no-std
derive(Error)
-
maybe-owned
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
pyo3-polars
Expression plugins and PyO3 types for polars
-
psm
Portable Stack Manipulation: stack manipulation and introspection routines
-
shaku
Compile Time Dependency Injection for Rust
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
flex-error
Flexible error definitions using macros and traits
-
pinned-init
facilitate safe pinned initialization
-
safe-transmute
A safeguarded transmute() for Rust
-
st-map
Runtime for a stack-alocated map
-
log-once
Collection of helper macros for logging some events only once
-
thiserror-core
derive(Error)
-
fragile
wrapper types for sending non-send values to other threads
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
tuples
many useful tools related to tuples
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
nshare
Conversion between n-dimensional types in different Rust crates
-
lazycell
providing a lazily filled Cell struct
-
tuplex
Rust tuple extension
-
autosurgeon
working with data in automerge documents
-
lender
A lending-iterator trait based on higher-rank trait bounds, with full std::iter::Iterator functionality
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
rustrict
profanity filter for Rust
-
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…
-
elain
Set a type's minimum alignment with const generics
-
derivative
A set of alternative
deriveattributes for Rust -
arr_macro
Initialize arrays with ease!
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
shopify_function
write Shopify Functions in Rust
-
k8-client
Core Kubernetes metadata traits
-
moveit
safe, in-place construction of Rust (and C++!) objects
-
joinery
A small crate for generically joining iterators with a separator
-
socketpair
Cross-platform socketpair functionality
-
rdftk_names
set of modules that contain the
IRIs andQNamestrings for commonly used vocabularies. It also provides macro support for defining new namespaces in the same style as this library. -
conjure-object
Runtime support for generated Conjure objects
-
parsel
Zero-code parser generation by using AST node types as the grammar
-
culpa
error-handling syntax in Rust
-
tstr
Type-level strings
-
display-error-chain
Formats a standard error and its sources
-
ltpp-output
An atomic output library based on Rust that supports output functionalities through functions, builders, and other methods. It allows customization of text and background colors.
-
validify
struct validation and modification functionality through the use of derive macros
-
overload
macro to simplify operator overloading
-
aoc-parse
A little library for parsing your Advent of Code puzzle input
-
tryhard
Easily retry futures
-
cl-format
Use Common Lisp format in Rust
-
myutil
Rust Util Collections
-
mirror-mirror
Reflection library for Rust
-
with_locals
Function attribute to return references to locals by using CPS
-
error_set
An error set macro that simplifies error management by providing a streamlined method for defining errors and easily converting between them. Inspired by Zig's error set type.
-
calendrical_calculations
Calendrical calculations in Rust
-
o2o
Object to Object mapper for Rust. Derive '(Try)From' and '(Try)Into' traits.
-
as-any
provide the AsAny trait
-
documented
Derive and attribute macros for accessing your type's documentation at runtime
-
sealed
Macro for sealing traits and structures
-
better_scoped_tls
scoped-tls, but with good error message
-
savvy
R extension interface
-
ra_ap_mbe
Handling of
macro_rulesmacros for rust-analyzer -
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
dync
An efficient alternative to
dyn Traitfor containerized types -
safelog
Conditionally suppress confidential information from logs
-
refined_type
imbuing rules into types and elevating them to more robust types
-
lazy_errors
Effortlessly create, group, and nest arbitrary errors, and defer error handling ergonomically
-
formatx
A macro for formatting non literal strings at runtime
-
bit_field
bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
libc-print
println! and eprintln! macros on libc without stdlib
-
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… -
fluent-comparisons
Boost readability by writing multicomparison expressions like
if any_of!({a,b,c}>=5) {...}while keeping the benefits of hand-written code -
concat-with
Extend the function of the
concat!macro instd -
andex
Safe, strongly typed array indexes and wrappers for rust with zero dependencies
-
qualifier_attr
Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items
-
copyless
Ways to eliminate memcpy calls when using the standard library
-
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
-
generics
macros for parsing generics (with optional where clause) in
macro_rules! -
raw-parts
Ergonomic wrapper around
Vec::from_raw_partsandVec::into_raw_parts -
rustversion
Conditional compilation according to rustc compiler version
-
random-number
Generate random numbers quickly
-
fn_vm
A lightweight frame based virtual machine, meant as the base for rigz_vm
-
data-rw
io buffer write reader
-
funty
Trait generalization over the primitive types
-
advent-of-code
Solutions to Advent of Code
-
void
The uninhabited void type for use in statically impossible cases
-
fixed-hash
Macros to define custom fixed-size hash types
-
buildstructor
Macro to derive a builder from a constructor function
-
semval
Semantic validation
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
octseq
Abstractions for types representing octet sequences
-
version-sync
ensuring that version numbers in README files and other files are kept in sync with the crate version
-
bool_ext
defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
cap-std-ext
Extension APIs for cap-std
-
miden-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
try_match
Fallible pattern matching with a function-like syntax
-
devise
devising derives and other procedural macros
-
conflate
Merge multiple values into one
-
rust_info
Extracts the current rust compiler information
-
doku
A framework for documenting Rust data structures
-
condtype
Choose types at compile-time via boolean constants
-
terrors
ergonomic and precise error handling built atop type-level set arithmetic
-
autofolder
Single-element folding wrapper
-
atc-router
Versatile DSL based rule matching engine used by the Kong API Gateway
-
reborrow
Emulate reborrowing for user types
-
try-specialize
Zero-cost specialization in generic context on stable Rust
-
ungrammar
A DSL for describing concrete syntax trees
-
open-enum
An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
resiter
Helper crate for handling iterators over result
-
nar_dev_utils
用于NARS相关项目开发的实用工具包
-
nunny
the definitive non-empty slice/array/vec library for Rust
-
zoet
Adds
#[zoet]macro to reduce boilerplate when implementing common traits -
TSPL
The Simplest Parser Library
-
macon
builder macro-based generator with its own idioms
-
unsafe-fields
unsafe to access or modify fields with safety invariants
-
heterob
conversion between bytes/bits and heterogeneous lists (tuples)
-
blanket
macro to derive blanket implementations for your traits
-
entrait
Loosely coupled Rust application design made easy
-
const-field-offset
Wrapper around field-offset crate and const-field-offset-macro
-
more-di
support for dependency injection (DI)
-
trybuild-internals-api
A fork of trybuild with the internals exposed as a public API
-
doc-comment
Macro to generate doc comments
-
copy_from_str
An extension trait to copy a string into another string
-
easy-cast
Type conversions which are expected to succeed
-
proc-bitfield
expressively declare bitfield-like structs
-
munge
Macro for custom destructuring
-
jni-toolbox
tools to make writing JNI native functions less tiresome
-
psl-types
Common types for the public suffix implementation crates
-
swipl
A high-level library for building SWI-Prolog extensions and embedding SWI-Prolog in rust applications
-
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
i_float
This fixed float math library provides an efficient and deterministic solution for arithmetic and geometric operations
-
one_err
OneErr to rule them all
-
macro-attr-2018
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
node_tree
An extendable scene graph made up of autonomous execution services known as nodes organized in a tree of processes. Inspired by Godot!
-
enum-display
A macro to derive Display for enums
-
sugars
An useful collection of macros to make tasks easier
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
allow
Alias/label lints (to disable) with your intentions. Reexported from allow_prefixed, grouped under rustc::, clippy:: and rustdoc:: modules.
-
defer
excecution of code, inspired by go's defer statement
-
strck
Checked owned and borrowed strings
-
wiwi
Stuff™
-
macro-asm-builder
macro-assemblers
-
vitasdk-sys
Raw bindings to vitasdk
-
globals
Painless global variables in Rust
-
generativity
Generation of unique invariant lifetimes
-
scale-typegen
Type Generation for SCALE encoded Rust Types
-
a1
A package for converting to and from A1 spreadsheet notation
-
aerosol
dependency injection for Rust
-
metastruct
Abstractions for iterating and mapping over struct fields
-
cexpr
A C expression parser and evaluator
-
fallible-streaming-iterator
Fallible streaming iteration
-
cowstr
Copy-on-Write shared strings
-
fauxgen
write your own generators in stable rust
-
funcmap
Derivable functorial mappings for Rust
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
iced_anim
creating animations in Iced
-
enum-ptr
Ergonomic tagged pointer
-
fmt-cmp
Traits and utilities for lexicographically comparing values in their
Displayrepresentations -
hermit-sync
Synchronization primitives for kernels
-
conv2
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
soa-rs
A Vec-like structure-of-arrays container
-
indicator
Abstractions for stream aggregation, we call them
Indicators -
downcast
Trait for downcasting trait objects back to their original types
-
exhaust
Trait and derive macro for working with all possible values of a type (exhaustive enumeration)
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
collate
Traits and a data structure to support collation and bisection
-
components-arena
creating complex domain-specific self-referential data structures
-
kind
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
const-type-layout
Derivable const trait to view and compare the layout of a struct, union, or enum
-
rudi
out-of-the-box dependency injection framework for Rust
-
fieldx
Procedural macro for constructing structs with lazily initialized fields, builder pattern, and serde support with a focus on declarative syntax
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
smarterr
Smart error handling library
-
lazy-static-include
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
tupletools
functions for tuples
-
checked-rs
encoding validation semantics into the type system
-
drcp-format
Parse and write DRCP and literal definition files
-
tisel
Effective type-based pseudodynamic dispatch to impls, enums and typeid
-
auto_enums
allow multiple return types by automatically generated enum
-
sosecrets-rs
Secretwrapper type that reveals the secret at mostMEC: typenum::Unsignedtimes with compile time guarantees -
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
radiation
Convert Rust type into raw bytes and vice versa
-
par
Session types, as an implementation of linear logic with MIX
-
fomat-macros
Alternative syntax for print/write/format-like macros with a small templating language
-
byondapi
Idiomatic Rust bindings for BYONDAPI
-
vtable
Helper crate to generate ffi-friendly virtual tables
-
event-driven-library
Event Driven Message Handling
-
expect-exit
Result.expected(): display an error message and exit without a panic
-
scaffolding-core
A software development kit that provides the scaffolding for building applications and services using OOP
-
logkit
Super fast, structured, scalable logging library for Rust
-
direction
Representations of directions
-
jnix
High-level extensions to help with the usage of JNI in Rust code
-
model-mapper
Derive macro to map between different types
-
ownable
Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more
-
crustal
generating C/C++ code
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
orx-closure
An explicit closure with absolute seperation of the captured data from the function
-
mownstr
Maybe Owned String
-
self-rust-tokenize
Turns instances of Rust structures into a token stream that creates the instance
-
ffi_helpers
help make working with FFI easier
-
coi
Dependency Injection library
-
sparkles
Capture execution flow of your Rust application with CPU cycle precision!
-
ice_code
A macro to mark code paths as cold, allowing the common case to be inlined
-
xx
A collection of useful Rust macros and small functions
-
windows-targets
Import libs for Windows
-
text-block-macros
Create a multiline string literal
-
bash-builtins
implement loadable builtins for bash
-
io-streams
Unbuffered and unlocked I/O streams
-
result-like
Option/Result-like monad interface for your own enum
-
certain-map
A typed map which can make sure item exist
-
ext-trait
Annotation to easily define ad-hoc / one-shot extension traits
-
oxrdf
providing basic data structures related to RDF
-
ghost
Define your own PhantomData
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
drop_bomb
A runtime guard for implementing linear types
-
intern-arc
An interner that deallocates unused values
-
cbor-data
using CBOR as in-memory representation for working with dynamically shaped data
-
fmt-interspersed
write an iterator's items, interspersed with a separator, to a destination
-
bilge
Use bitsized types as if they were a feature of rust
-
reweb3-num
Arbitrary precision, fixed-size signed and unsigned integer types for ethereum, this a fork of bnum crate
-
strong-type
Procedural macros for naming and strong-typing pritimives and strings
-
openapi_type
OpenAPI type information for Rust structs and enums
-
auto_ops
Macros for easy operator overloading
-
static_file_util
generating and managing static files in Rust applications
-
derive_destructure2
Destructure structs that implement Drop
-
columnation
Unsafe columnar containers for native Rust types
-
bool_vec
A crates that exposes a vector called BoolVec which allows you to store a boolean in a single bit
-
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
leptos-mview
A concise view macro for Leptos
-
async-iterator
An async version of iterator
-
fn-traits
function traits like the standard library ones, but can be used in stable Rust
-
borrowme
The missing compound borrowing for Rust
-
devela
A development foundation
-
light_ranged_integers
Ranged integers for stable Rust compiler, zero-dependencies and no unsafe code
-
indices
macros and methods for safely retrieving multiple mutable elements from a mutable slice, addressing scenarios where slice elements would typically require
RefCellorCell(interior mutability approach) -
tokenlock
cell types that decouple permissions from data
-
fp_rust
Implement fp features for Rust
-
dylint_linting
writing Dylint libraries
-
tor-basic-utils
General helpers used by Tor
-
wrap-match
A procedural macro to wrap a function in match statement to make error logging super easy
-
tc-error
TinyChain's generic error struct
-
static-keys
Reimplement Linux kernel static keys for Rust userland applications
-
redb_model
Redb model derive macro and DTO type conversion
-
linked_list_r4l
Linked lists that supports arbitrary removal in constant time
-
dogma
Dogma.rs
-
mapper
Mapping macro to help to reduce mapping boilerplate
-
clamp_to
Clamp integer and float values to the values that fit within both the original number type and the receiving type
-
safe_math
Math without overflow, creates an enum and a macro to help mitigate any overflow while multiplying and adding
-
nonany
Integer types with customizable niche values
-
selfie
Experimental, macro-free and allocation-free self-referential structs
-
tinyvec_macros
Some macros for tiny containers
-
pyo3_special_method_derive
Automatically derive Python dunder methods for your Rust code
-
corlib
A various ideas library
-
non-empty-string
type for non empty Strings, similar to NonZeroUsize and friends
-
uniplate
boilerplate-free operations on tree-shaped data types
-
rxml_validation
Plumbing crate for rxml and rxml_proc crates
-
sigmut
a state management framework designed to be used as a foundation for UI frameworks
-
functor_derive
A derive macro to derive a functor for a type
-
quick-builder
compile-time checked builder generator with run-time invariant enforcement
-
supply-chain-trust-example-crate-000055
Flexible concrete Error type built on std::error::Error
-
linear_type
Linear types for rust
-
loupe
Profiling tool for Rust
-
deptypes
Dependent types
-
visibility
Attribute to override the visibility of items (useful in conjunction with cfg_attr)
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
untrusted_value
aim to provide a type-safe way to handle and sanitize potentially untrusted values like user input
-
padder
Highly efficient data and string formatting library for Rust
-
core_extensions
Extensions for core/std library types, and other miscelaneous features
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
alternating-iter
Provide an iterator adaptor which alternate between two iterators
-
capnp_conv
capnp write/read traits to convert from structs to readers/builders
-
unarray
working with uninitialized arrays
-
iterstats
Statistics for rust iterators
-
indexed_valued_enums
Create enums resolving into values, and get their variants back through their values or their discriminant, inspired by Java
-
nameof
macro to determine the string name of a binding, type, const, or function
-
nolife
open a scope and then freeze it in time for future access
-
iter-comprehensions
iterator comprehensions
-
evcxr_repl
A REPL for Rust
-
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
-
bellframe
Fast and idiomatic primitives for Change Ringing
-
outref
Out reference
-
mut_set
A safe implementation for HashSet with iter_mut and get_mut
-
structx
Simulating anonymous struct and named arguments in Rust
-
panicking
std::thread::panickinganalog available in theno_stdcontext -
oxc-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
quick-error
A macro which makes error types pleasant to write
-
inline-c
Write and execute C code inside Rust
-
sitrep
Frontend-agnostic progress reporting
-
ex_em_ell
Provide macros for serializing and deserializing XML
-
event_iterator
Asynchronous lending iterator
-
small_len
A small library for storing the length in the smallest internal type
-
kinded
Generate enums with same variants, but without data
-
dialogue-macro
An extension to dialoguer that simplifies command-line interaction interfaces
-
abcgen
A procedural macro to generate boilerplate code for objects implementing the 'Actor' pattern
-
pike
A macro collection to pipe |> your functions calls, like in functional languages such as F#, Elixir and OCamel
-
numtest
Unit testing for numerical methods
-
impls
Determine if a type implements a logical trait expression
-
teleparse
-
vcell
Cellwith volatile read / write operations -
termite-dmg
Termite Data Model Generator is a crate meant to generate boiler plate code for data models
-
sod
Service Oriented Design
-
cortex-ai
An asynchronous flow-based processing framework for building flexible data pipelines with conditional branching and error handling
-
vector-traits
Rust traits for 2D and 3D vector types
-
miden-thiserror
derive(Error) with no-std support
-
dynamodel
derive macro to implement conversions between your object and
HashMap<String, AttributeValue> -
supply
Provider API for arbitrary number of lifetimes
-
unwind-context
Macro to add colored panic context to your functions
-
portaldi
An ergonomic lightweight compile-time depencency injection library
-
hlist2
Compile-time heterogeneous list implementation
-
hax-lib
Hax-specific helpers for Rust programs
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
ssi-di-sd-primitives
Selective Disclosure primitive for Data-Integrity suites
-
phnt
Rust bindings to the System Informer’s (formerly known as Process Hacker)
phntnative Windows headers -
slice-diff-patch
providing utility functions for diff and patch of slices
-
enum_cycling
Small macro for working with enums
-
dprint-swc-ext
Functionality to make swc easier to work with
-
opentalk-kustos-prefix
Derive macro for defining kustos prefix
-
oco_ref
A smart pointer for storing immutable values with relatively-cheap cloning. (Like a
Cowmeets anRc!) -
rs_envflag
An easy way to define flags by environment variables
-
sdml-errors
Domain Modeling Language (SDML) errors and diagnostics
-
maybe-single
A singleton. Maybe.
-
yerevan
Small Rust crate that brings computation expressions idea from F# for help you to work easier with functors and monads
-
rngstr
A cli tool for generating random strings of characters with customization options and a small domain specific language
-
safecast
Traits to define safe casting between types
-
ecksport-core
Defs for frame types, traits, topics, error codes, etc
-
value-box
Allows developers to pass Rust-allocated structures over ffi
-
random_variant
To be used with all variant, contains the derive macro
-
hex_lit
Hex macro literals without use of hex macros
-
const-default
A const Default trait
-
egui_struct
EguiStruct is a rust derive macro that creates egui UI's from arbitrary structs and enums
-
nu-std
The standard library of Nushell
-
procmeta
integration procmeta-core and procmeta-proc
-
elicit
SmartPointer-like structure for polymorphism
-
size-of-trait
determine the size of a future or trait impl at compile time
-
cove
Casts Of Varying Elegance (COVE): extension traits for casting numerical types
-
hax-bounded-integers
Newtypes for working with bounded integers with hax
-
implementation
The implementation crate
-
rp-postgrest-error
strongly typed errors for PostgREST
-
simple-logging
logger for the log facade
-
simple-error
error type backed by a string
-
hs-bindgen
Handy macro to generate C-FFI bindings to Rust for Haskell
-
traitsequence
Traits to abstract over sequences
-
merge
multiple values into one
-
wallee
Flexible concrete Error type built on std::error::Error with caller location tracking
-
nade
Adding named and default arguments to Rust functions
-
soa_derive
Automatic Struct of Array generation
-
prange2
Parse numeric ranges for indexing
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
never
A stable version of the unstable never type (!)
-
anybytes
A small library abstracting over bytes owning types in an extensible way
-
lexi-matic
A Lexer Library
-
game_inventory
An inventory system independant of item data
-
shorter-bounds
Write shorter bounds with a trait alias macro
-
string_more
Extension traits for
Stringand&strtypes -
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
file-guard
A cross-platform library for simple advisory file locking
-
defer-heavy
A versatile and easy to use defer statement for Rust. Similar to Go's or Zig's defer.
-
tri_ton
A Macro for Handling Exceptions
-
nanokit
A collection of tiny, reusable utility methods that reduce code size and improve performance
-
tighterror
A minimalistic error representation framework
-
re_tuid
128-bit Time-based Unique Identifier
-
awint_macro_internals
Internal macro utilities for the
awintsystem of crates -
quoth
scannerless (no-lexing), developer-friendly parsing library for implementing DSLs and syntax parsers in Rust
-
derive-ctor
Adds
#[derive(ctor)]which allows for the auto-generation of struct, enum, and union constructors -
cloudformatious
Extension traits for rusoto_cloudformation
-
glam-traits
Traits for the vectors in glam
-
binread
helping read structs from binary data using ✨macro magic✨
-
copstr
COpy STRing module
-
test_help-rs
Test helpers for Rust
-
convert_traits
Define your own conversion traits to solve the problem of converting two external types without using new types
-
tevec
provide quantitative analysis functions for vec | ndarray | polars backend
-
pgde
A macro library for consuming PostgreSQL row data into structs
-
crevice_notan
Create GLSL-compatible versions of structs with explicitly-initialized padding
-
gen_ops
Macros for operator overloading for generic types
-
ref_wrapper
Wrapper of dynamically borrowed data
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
deep_safe_drop
Safe dropping of deep trees that otherwise could cause stack overflow
-
captur
Macro to capture whole structs from disjoint fields in a closure
-
egui-probe
Trait and derive macro for exposing value editing in egui
-
assert_approx_eq
assert approximately equal
-
tagged-id
A zero-cost wrapper adding type-safety to resource identifiers
-
crony
cron runner that spawns another thread to run your cron jobs
-
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)
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
with_drop
Nostd wrapper for using a closure as a custom drop function
-
as-is
An abstraction over ownership
-
libabort
A abort function that doesn't require the standard library
-
ferrunix
A lightweight run-time dependency injection framework for Rust
-
static_assertions_next
Compile-time assertions to ensure that invariants are met
-
cast
Ergonomic, checked cast functions for primitive types
-
htmlm
html macro with no dependencies
-
rc-box
Known unique versions of Rc and Arc
-
not-found-error
Convert Option to Result using convenient functions
-
swift-bridge-build
Parse Rust files for swift-bridge modules and generate the corresponding Swift and C code for them
-
overloaded_literals
Overloaded Literals to construct your datatypes without boilerplate and with compile-time validation
-
iterator-sorted
Stable functions for checking iterator sorting
-
capture-it
Modern c++-ish capture syntax for rust
-
table_enum
A convenient rust macro to create enums with associated constant data (note: this is different from normal rust enums which are really tagged unions)
-
confi
confidence intervals and significance levels for statistical computation
-
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
sodium
FRP (Functional Reactive Programming)
-
enum_handler
A macro to generate a handler trait for enums variants
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
benri
Convenient macros wrapping the standard library
-
dilib
A dependency injection library for Rust
-
enumerable
helping you to enumerate all possible values of a type
-
anyrust
any rust
-
compare_version
comparing semantic versioning strings and checking version compatibility
-
transient
Reimplementation of
std::any::Anywith support for non-'statictypes -
stupid_utils
that provides some simple and maybe stupid or useful tools
-
case_insensitive_string
A case insensitive string struct
-
pipe-trait
possible to chain regular functions
-
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
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. -
type_cell
Attach values statically to a type using static get/set methods
-
native_api_1c
Main library for Native API 1C
-
inline-python
Inline Python code directly in your Rust code
-
scout-parser
A web crawling programming language
-
code-path
A code path macro
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
dyn_std
Dynamic (object-safe) version of std traits
-
rempl
creating html components directly in your source
-
default-constructor
Macros for creating pseudo-dsls that constructs structs through default construction and field conversion
-
lazy_link
proc macro for dynamic runtime lookup of external functions, supporting custom resolvers, caching and no_std environments
-
procc-ll
processor of tokens for rust
-
applying
Apply functions in method-position
-
focusable
A trait for types that can be focused
-
uints
Unsigned Integer Properties
-
packetize
encode and decode your packet with stream channel
-
cubob
Structured output helpers for display mode
-
simple_parse
A declarative converter for Rust type to and from binary
-
surrealdb-extras
additional functionality for working with SurrealDB
-
univec
A vector that can hold elements of any single type
-
io-arrays
Random-access I/O
-
ra_ap_hir_expand
Macro expansion for rust-analyzer
-
gazebo
A collection of well-tested utilities
-
log_limit
A rate limiting logging crate
-
assert_matches2
A version of the assert_matches! macro that brings variables from the pattern into scope
-
custom_derive
(Note: superseded by
macro-attr) This crate provides a macro that enables the use of custom derive attributes -
cprint
Cargo-like print
-
plectrum
An easy way to represent lookup tables in a db as rust enums
-
deltoid
calculate and apply deltas to structs and enums
-
traitreg
Create a registry of implementations of a trait
-
quick-error2
A macro which makes error types pleasant to write
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
sod-crossbeam
Service Oriented Design - Crossbeam
-
install-dirs
handling gnu install directories in rust
-
heap-array
variable length array, with its main benefit over
Vecis taking up less space -
take-until
A take_until extension for iterators
-
c8str
String types that are both utf-8 and null terminated
-
iter-chunks
Extend Iterator with chunks
-
backtrace-error
wrap errors with automatic backtrace capture and print-on-result-unwrap
-
copyvec
A contiguous growable array type, with a fixed, stack-alllocated capacity that implements Copy
-
sddl
parse and analyse SDDL Strings
-
okapi-response-mac
A macro for creating response code based on responses structs rather than typing and implementing OkapiRocketResponseInner manually
-
typeables
type aliases. By SixArm.com.
-
plain_hasher
Hasher for 32-byte keys
-
cplex-rs
Binding of IBM Cplex library
-
fiberplane-pdk
Fiberplane Provider Development Kit
-
separator
Formats numbers into strings with thousands separators for readability
-
class_list
A reactive helper that ensures normalized class list strings in frontend frameworks like Leptos
-
transitive
derive macros for Rust
-
rustdoc-prettier
Format
//!and///comments with prettier -
chainerror
Make chaining errors easy
-
safe-discriminant
A minimalistic,
no_stdcompatible trait and procedural macro for extracting discriminants from enums at zero cost -
intertrait
Allow for inter-trait casting
-
aquamarine-demo-crate
A demo crate for aquamarine -- the mermaid.js integration for rustdoc
-
assert-eq-float
assert_eq_float!macros that support floats -
intfloat
Fast and simple hashable float alternative using ints
-
cve-rs
Blazingly fast memory vulnerabilities, written in 100% safe Rust
-
processmanager
manage process lifecycles, graceful shutdown and process faults
-
mode
A behavioral state machine library written in Rust
-
scoped_thread_local
Highly flexible Scoped thread local with HKT builtin
-
enum_ext
procedural macro that enhances enums with additional methods and conversions
-
enum_downcast
Safe downcasting for enums
-
prima_bridge
implement the bridge pattern
-
error_mapper
standardized Results and Errors handling accross all your projects
-
iced_af
The iced application framework project
-
precomputed-hash
intending to be a base dependency to expose a precomputed hash
-
rtoolbox
functions for other crates, no backwards compatibility guarantees
-
set_derive
Using Macros to Implement List comprehension Similar to Python Language
-
pin-macros
primarly used to simplify the proccess of working with self-referencial structures
-
soapy
Structure-of-arrays derive macro
-
cast_checks
A procedural macro to check for invalid casts
-
sqler
way for writing SQL queries using some of Rust syntax
-
map-macro
Declarative macros for statically initializing collections
-
surreal_devl
Contains core logic of surreal derive
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
safe_cache
A key-value cache library in Rust featuring dynamic typing with support for multiple data types, automatic expiration, and thread-safe operations using Arc and RwLock
-
ux2
Non-standard integer types like
u7,u9,u10,u63,i7,i9etc -
anyerror
A type of any error for transport
-
ruut-functions
parse math functions from string (1D,2D,3D,ND) and perform symbolic derivation, gradient, hessian
-
cooked-waker
A safe interface for creating async Wakers
-
steepen
Create multiple iterators from a single iterator by separating elements
-
structural-convert
Derive conversion traits (From, Into, TryFrom, TryInto) when fields are structurally similar in enums or structs
-
rustrix
Supports macro and basic operations for matrix
-
more-itertools
python more-itertools
-
panic-message
Get a panic message from a panic payload
-
pyo3-error
Unified error causality chains across Rust and Python
-
advancedresearch-path_iter
A cocategory enumeration library based on path semantics
-
test_eq
assert_eq!-like macros that return a Result instead
-
labview-interop
Types and wrappers for interperating with LabVIEW when called as a library
-
checked-float
making invariant-enforcing floating point wrappers
-
inline_dyn
A container type for storing dynamically-sized types inline
-
ref-ops
An escape hatch for implementing
opstraits for references to newtypes -
stackstack
A singly linked list intended to be chained along stack frames
-
carykh-macro-rust
macro for finding strings that contain self-referential numbers. Inspired by carykh. This description contains twenty-seven words, fifty-four vowels, and ninety-nine consonants.
-
tuple_utils
A set of utilities to enable higher level operations over tuples
-
combin-iterator
Some usefull facilities for combining iterators
-
dynarg
mechanism for dynamic robust argument handling
-
unwrap_todo
Option::todo and Result::todo methods
-
token-ref-cell
Interior mutability cell using an external token to synchronize accesses
-
destructure_traitobject
Unsafe helpers for working with raw trait objects. (Forked from traitobject)
-
conv
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
structify
A procedural macro to transform functions into structs with state and execution dependencies
-
portrait
Fills an
implwith the associated items required by the trait -
sbpf-asm-macros
Ergonomic macros for low-level sBPF ASM functionality
-
nil
Noxmore's Ixperimental Lutilities
-
chasa
A parser combinator with
manytaking iterator, conditional branching, and method chain -
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
-
micro_errors
deal with errors without taking the derive macro approach
-
ez_jni
Macros and functions that make using Java in rust feel natural
-
supply-chain-trust-example-crate-000053
A lightweight version of pin-project written with declarative macros
-
nanotweaks
moved to https://crates.io/crates/spread_macros
-
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
-
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
width_counters
Atomic counters with variable bit widths and customizable atomic ordering
-
tacit
macro to make newtypes easier to create
-
sapp-jsutils
Helper functions for working with js objects in miniquad based apps
-
devgen-splitter
Devgen Splitter is a Rust library that breaks down source code into contextual chunks
-
superstruct
Versioned data types with minimal boilerplate
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
opaque_typedef
Supports defining opaque typedefs
-
iter-identify_first_last
A helper iterator, flagging first and last elements
-
tracked
A stringly-typed Error that includes
#[track_caller]information -
sod-actix-web
Service Oriented Design - Actix Web
-
next_tuple
A trait to build and extend tuples
-
mini-macro-magic
Export tokens to other modules and crates. Now with 100% less proc macros!
-
cond
Rust macro to use a match-like syntax as an elegant alternative to nesting if-else statements
-
envsubst
Variables substitution
-
erasable
Type-erased thin pointers
-
carboxyl
functional reactive programming
-
macro-bits
performing macro-based bit manipulation
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
mvutils
made from commonly used functions in my projects
-
genmesh
A package for generating 3D meshes
-
type-sets
Sets implemented in the rust type-system
-
roxygen
Seamlessly document function parameters with rustdoc
-
hexchat-plugin
Lets you write HexChat plugins in Rust
-
valued-enums
Macros collection and specify trait for creating valued or python-like enums
-
declarative_enum_dispatch
Declarative macro generating boilerplate for enum dispatch
-
easy-error
error utilities
-
iter_fixed
Iterator of fixed length
-
methods-enum
Two macros for easy implementation of 'state' design pattern and other dynamic polymorphism using enum instead of dyn Trait
-
char-device
Character Device I/O
-
loop-let
An immutable loop structure that can be used as an expression
-
totally-safe
that allows you to bypass Rust's safety guarantees with totally safe patterns, featuring arbitrary lifetimes, aliasing, and more!
-
ubits
Bit fields and masks
-
gravitron_macro_utils
Gravitron's Macro Utils
-
custom-format
Custom formatting for Rust
-
shelter
ROP-based sleep obfuscation to evade memory scanners
-
tcp-struct
Share structs over tcp
-
named-tup
Create named tuples using the tup!() macro
-
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
hello-world-in-rust
Hello World!
-
airbag
handling errors and panics using 3rd party services
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
flexi_func_declarative
exposes the fb! macro to create a function with a flexible signature
-
nz
Collection of 100% safe macros for creating non-zero integers more easily
-
rancor
Scalable and efficient error handling without type composition
-
accursed-unutterable-type-id
A worse version of std::any::TypeId
-
hax-frontend-exporter-options
The options the
hax-frontend-exportercrate is sensible to -
oberst
A type-safe command parser and dispatcher inspired by Brigadier and written in Rust
-
bogdan_hello_macro
adds the method hello_macro that generates a greeting based on the name of the struct
-
errore
error handling and tracing
-
home-prelude
Prelude library to support home applications
-
fu
Just an Error
-
rt-format
Fully-runtime equivalent of the format! macro
-
digitize
Traits for accessing digits of primitive integers & floats
-
variadiz
Variadic function support for rust
-
restructed
Quickly derive subsets of your structs
-
wherr
Enhance Rust errors with file and line details using the
#[wherr]macro for clearer debugging -
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…
-
typeful
A collection of helper derive macros for type patterns
-
git-ref-format
Everything you never knew you wanted for handling git ref names
-
maelstrom-worker-child
Helper library for maelstrom-worker
-
partial_application
partial function application via the partial! macro
-
genrc
refcounted pointer type that allows subobject pointers
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
objid
Generate a random object identifier
-
lazyinit
Initialize a static value lazily
-
human-errors
An error library focused on providing your users with relevant advice for any problem
-
primitive-from-enum
macros for get primitive enum from complex
-
goof
A reusable, composable, aggregate and
no_std-friendly error library -
match_cfg
A convenience macro to ergonomically define an item depending on a large number of
#[cfg]parameters. Structured like match statement, the first matching branch is the item that gets emitted. -
const_fn
A lightweight attribute for easy generation of const functions with conditional compilations
-
interning
Thread-Lcoal and Global Interning Library
-
bty
Streamlined definition and usage of branded types in Rust
-
mac
A collection of great and ubiqutitous macros
-
scratchstack-aws-principal
Principal types for AWS/AWS-like services
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
asm_block
Translate tokens to string for Rust inline assembly
-
dims_macro
Macros for Generating Systems of Units
-
dare
daring flexible data representation
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
thin_cstr
An experimental crate which provides a truly thin std::ffi::CStr
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
failed-result
A small crate for converting various failed value to result with corresponding error type
-
typed-sql
A strongly typed sql serialization/deserialization framework
-
iter_peek_end
current element the last one of a peekable iterator ? (
is_last()andis_not_last()) -
isclose
A collection of trait and macros for comparing approximate equality
-
zerror_full
macro for implementing helpful errors
-
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
panic-analyzer
an audit tool to scan your crate or workspace searching for potential panic points in your codebase
-
ctor-lite
Run code at program startup or shutdown
-
python-packaging
Python packaging primitives implemented in Rust
-
tany
Type-erased container with inline storage for small values
-
apply
A tiny library for chaining free functions into method call chains
-
dispose
wrapper for values that must be consumed on drop
-
shadow_counted
An iterator that counts every iteration and commits the count to an optional parent iterator
-
tuppipe
pipe operator-like implementation using tuples in Rust
-
nanvm
NaN VM
-
gobble
A Combinator based parser for strings that gets out of the way, and leaves your code looking like a grammer
-
duplicate_macrotest
Fork of the macrotest crate specifically to test the duplicate crate
-
as_num
Checked conversions between Rust's numeric types
-
lichen
Scripting DSL (for Dialogue Graphs, et al)
-
fallback-if
Fall back to an alternative given some predicate
-
bit_roles
Granular role management based on bit flags
-
noco
no code, no problem
-
srb-std
test description 02
-
sumtype
Generate zerocost sumtype of iterators or closures
-
degeneric-macros
Hides struct generics into trait associated types
-
anthill-di
Rust di containers system
-
map
map!macro that creates a HashMap then inserts key-value pairs -
ergokv
Easily store and retrieve data from TiKV with a derive
-
kinds
Higher-Kinded Types simulated by GATs
-
netherite
A tokio implementation of the Minecraft Protocol with derive macros
-
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
-
cisness
Runtime 'live witness' of two types being the same
-
re_error
Helpers for handling errors
-
reductor
Generic abstractions for combining and nesting reduction patterns for iterables
-
relrc
Reference counted pointers, with relationships to other pointers
-
some_crate
If you just need a crate that's guaranteed(*) to do practically nothing
-
shared_singleton
trait provides singleton pattern state management with shared container
-
tuple_list
macro-free variadic tuple metaprogramming
-
non_structural_derive
nonstructural derives for auto traits
-
html
Structured HTML encoder
-
cifg
A macro for defining #[cfg] if/else blocks; alternate to cfg-if
-
bounded-vector
Vec wrapper that guarantees upper and lower bounds on type level
-
thin_delegate
Auto implementation of trivial delegation to inner types
-
tiny-input
Tiny input macros
-
version-ranges
Performance-optimized type for generic version ranges and operations on them
-
peeking-iter
An iterator adapter that allows infinitely-deep peeking
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
thiserror_string_context
Adds context string to error enums generated with thiserror
-
wrappr
A libary for some useful wrapping traits
-
prev-iter
Iterator which allows you to view the previous element
-
service-layer-rs
alternative to the tower service layer, implemented using async trait, making the code more concise and easier to use
-
objective-rust
Seamlessly bind Rust and Objective-C code
-
esync
This package contains some useful synchronization primitives
-
syllogism
allow for some specialization using stable Rust
-
firestore-structured-query
A Firestore StructuredQuery builder
-
rco_utils
Shared functions for "Remote Code Execution"'s (RCO's) binaries
-
quote-data
A tokenization Library for Rust
-
tiny-ordered-float
Tiny version of OrderedFloat
-
simple_detailed_error
Stack and specify errors explainations saying what happened, why, how, where, how to solve it and its causes
-
typestate
A proc macro DSL for typestates
-
err-rs
Error level management
-
doc-search-dsl
procedural macro for creating complex regex patterns using a Domain-Specific Language (DSL)
-
jkcenum
Rust enum library
-
syrette
The convenient dependency injection framework
-
docsplay
A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc
-
string_from
A three-letter macro for String::from
-
taskchampion-lib
Personal task-tracking
-
summum-types
A sum-type macro crate with all the conversions, accessors, and support for abstract methods across variants, and interoperability between sum-types
-
nvptx-std
stdlib for nvptx64-nvidia-cuda
-
zip_clone
Zip an iterator to a repeately cloned object
-
rust-witness
Build a circom witness in Rust
-
maelstrom-test
Test macros for Maelstrom
-
materially
A macro for material implication
-
cmdstruct
A lightweight macro for implementing commands with a struct
-
mod
project that provides two simple and useful utility functions for converting between Option and Result types
-
sudo_plugin
Macros to easily write custom sudo plugins
-
mongo_indexed
derive macro to declaratively index mongo collections
-
twinsies
Smart pointer providing 2-way joint ownership of an object
-
dbg_unreachable
Switch between unreachable! and unreachable_unchecked with a single macro
-
closure
A macro for capturing variables on a per variable basis
-
binmarshal
Pack and unpack structs and enums into and out of binary data streams
-
clap-doc
Create markdown descriptions for
clap::Commands -
tartan-bitfield
Define structures with accessors for particular bits or bit ranges
-
unsafe_cell_slice
A microlibrary for creating multiple mutable references to a slice
-
docify_clone
Docify allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples
-
inherent
Make trait methods callable without the trait in scope
-
air-macros
Macros for the TNJ Assembly Intermediate Representation (AIR)
-
string_error_wrap
providing a macro for an error type wrapping a String
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
marker_trait
Implement a blanket implementation for a marker trait
-
strdeser
A struct serializer for rust empowered with a macro
-
aranya-buggy
A less panicky replacement for unreachable!() and unwrap
-
scan-rules
some macros for quickly parsing values out of text. Roughly speaking, it does the inverse of the print!/format! macros; or, in other words, a similar job to scanf from C.
-
fmt-derive
A more robust and versatile derive macro for Debug and Display
-
typederror
A wrapper around anyhow that allows for a primary error type
-
relax
Derive Partial<T>
-
gerber-types
Types and code generation for Gerber files (RS-274X)
-
conerror
macro that automatically adds context to errors
-
should
Postfix assertion library for Rust
-
num_bound
Add bounds fn to anything implementing
Ordthat bounds a number to a range -
aoko
extension library
-
consumable
Consume the value by replacing it with the default value and returning the previous value
-
oneline-eyre
A fork of
simple-eyrewhich outputs errors on a single line -
symbolism
Unique symbols made from human readable tags
-
tca-rs
The Composable Architecture (TCA, for short) is a library for building applications in a consistent and understandable way, with composition, testing, and ergonomics in mind
-
gull
type generation
-
proto-mapper
A Macro library for easier mapping between custom models and proto generated code
-
derive_variants
derives an additional enum from a nested enum that contains only variants and no nested fields
-
unwrap_or
Four easy unwrap Result and Option macros that allow for any inline-scoped code for things like return, continue, and break
-
str_crypter
A macro library for XOR encryption and decryption of strings at compile time, meaning no cleartext strings will be in your release binary (when using the macro). The encrypted strings will be decoded at runtime.
-
thiserror-context
A wrapper around thiserror, giving you the ability to add context
-
tlns-google-oauth2-traits
A bunch of traits for
tlns-google-oauth2-traits -
retrying
General-purpose retrying library for Rust with macros and functions
-
unwinder
Call stack spoofing for Rust
-
terra-items
enum contatining terraria items and prefixes
-
cstr-argument
A trait for converting function arguments to null terminated strings
-
gilder
Golden testing library
-
commonware-utils
Leverage common functionality across multiple primitives
-
trot
Trait library
-
flatty-base
Flatty traits and primitives
-
lmutils
A set of utilities for working with linear regression models
-
cew
Personal Rust utility library
-
os-thread-local
OS-backed thread-local storage. This crate provides a
ThreadLocaltype as an alternative tostd::thread_local!that allows per-object thread-local storage, while providing a similar API… -
borrow-or-share
Traits for either borrowing or sharing data
-
accountable-refcell
A RefCell wrapper that provides actionable information for dynamic borrow failures
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
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…
-
cfgenius
Conditional compilation with macro support in Rust
-
vector3d
3D vector type
-
quickbits
Fast bit manipulation routines for Rust's native integer types
-
macroex
An extractor based low level macro parsing crate that provides high level parsing support through derive macros
-
messages
Runtime-agnostic actor library
-
hotswap
Easy code swapping in running executables
-
case_iterable
A procedural macro to iterate over enum variants, ala Swift's CaseIterable
-
strunemix
allows to build a struct with a form of its fields, by deriving enums of them
-
tupl
Perform generic operations on tuples
-
aranya-trouble
A wrapper to implement the Error trait
-
round
your floats with precision from 1 to 10
-
bint
Bounded Integer in Rust
-
s-string
s!() macro for quick String::from()
-
circomspect-parser
Support crate for the Circomspect static analyzer
-
io-close
An extension trait for safely dropping I/O writers such as File and BufWriter
-
elor
Base generic implementation of an Either type
-
element-ptr
A macro to make accessing elements through raw pointers easier
-
lazy-init
Lazy initialization
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
arch-into
safe type conversions between pointer-sized types (usize/isize) and types with fixed size
-
mudra
Currencies as distinct structs
-
snapup
Abstractions for handling snapshots with streams of subsequent updates
-
proc-easy
Macros to make writing proc-macro crates easy
-
tentacli-traits
Traits and types for tentacli and related projects
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
peggen
Generate recursive-descent & precedence climbing parsers
-
diffuser-edit
Edit diffuser models without GPU and Python
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
ffd
Fast Function Dispatch: Improving the performance of Rust's dynamic function calls
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
assume
Macro for stating unsafe assumptions in Rust
-
snowflaked
creating and working with snowflake ids
-
unwrap-overflow-ops
arithmetic operations that always panic on overflow
-
ez_log
logging library for Rust
-
sinter
An easy to use & fast global interning pool
-
exec-rs
that provides utility traits for task execution and, if the sync feature is enabled, the ability to synchronise tasks based on the value of a key
-
subplotlib
functions and types for
subplot codegengenerated Rust based test suites. Relies onsubplotlib-derivefor associated macros. -
ptrplus
Additional funtionality for pointer types
-
seqgen
Sequence generation library
-
scope-functions
Kotlin-inspired scope functions for use in almost any situation
-
aws-lib
Helper functions and types for AWS operations
-
defer-lite
A lightweight high-performance implementation of Go's defer statement
-
first-err
Find the first Err in Iterator<Item = Result<T, E>> and allow iterating continuously
-
field33_rdftk_names_temporary_fork
set of modules that contain the
IRIs andQNamestrings for commonly used vocabularies. It also provides macro support for defining new namespaces in the same style as this library. -
ointer
Steal the high bits of a pointer to store an extra value
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
kurtbuilds_regex
Wraps the regex library to also provide macros
-
qm-utils
functions and macros
-
lib-tan-core
The core library
-
holder
getter setter auto gen with holder trait
-
eventmill
Event sourcing and CQRS for Rust applications
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
builder-pattern
A derivable macro for declaring a builder pattern
-
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
algar
Algebraic structures, higher-kinded types and other category theory bad ideas
-
str-macro
The str!() macro, similar to vec![] but for strings
-
irox-types
Enums and structs to describe Rust's basic type system
-
wutil
A lightweight library that contains useful functions, wrappers, and macros
-
libipld-macro
ipld macro
-
singleton-manager
A programatical singleton manager
-
gur
A undo-redo framework
-
rustc-ap-rustc_expand
Automatically published version of the package
rustc_expandin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
coded
concrete error type with an
ErrorKindenum matching Google’s “canonical error codes” -
softfloat-sys
Rust bindings for Berkeley SoftFloat 3
-
effing-mad
The hottest algebraic effects library in Rust
-
std-traits
Traits for types in the standard library
-
typology
Type derivation for foreign use
-
sendable
Rc and Option equivalents that facilitate sending data between threads
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
bittorrent-primitives
collections of basic types for BitTorrent projects
-
piglog
beautiful way to print out log messages in the terminal
-
standalone-syn
Fork of syn that turns of the proc-macro feature in proc-macro2 and standalone-quote so as to remove the rustc dylib dependency
-
struct-metadata
Macros for attaching metadata to structs
-
derive-merge-struct
A derive macro to partially update a named struct
-
litenum
minimal convertion utilities between literal and enum
-
autoproto
Replacement derive macros for
prost::Message, and supporting traits and types to make implementing this trait easier -
tao-of-rust
《Rust编程之道》随书源码
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
despatma
Design Pattern Macro like Loki
-
typenum-consts
Procedural macros that take a literal integer (or the result of an evaluation of simple mathematical expressions or an environment variable whose value is a literal integer) and convert…
-
ty_map_gen
A type projecting map generator
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
lemurs-8080
An emulator for the Intel 8080 microprocessor
-
enum-assoc
Procedural macro to associate constants with enum variants
-
hictor
declarative macro for __attribute__((constructor))/__attribute__((destructor))
-
dirk_framework
Dependency Injection for Rust
-
structz
Anonymous struct implementation in rust
-
lazy_bastard
A helpfull macro because writeing a seperate Default function is too much effort
-
iter-n
functions returning impl Iterator to return one of several distinct types
-
kusprint
A set of macros for printing objects to stdout without having to specify a template literal
-
overloadf
unlock function overloading for rust
-
orfail
Error handling library for portable unrecoverable errors
-
entrance
A command line argument parser library which provides type assisted tools
-
exhaustive
The trait for generating all values of a type, and a property-based test macro
-
xwt-error
A suite of reusable error types that naturally emerge from the xwt API. Use when you don't want/need your own more precise types
-
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
mathelogos
as a functional programming language
-
timed
Macros to time function execution
-
cloned_trait
Cloned Trait
-
json-query
Run jq programs to extract data from json strings
-
filterable-enum
generating filterable enums (Combining bitflags and discriminated unions)
-
market
Infrastructure for producers and consumers
-
grouping_by
allows the user to group an iterator by various ways
-
irange
A data structure to store and manipulate ranges of integers with set operations
-
eventually
using Event Sourcing in Rust applications
-
lucene_query_builder
A procmacro derive crate to generate lucene query builder for Rust structs :
-
deadlocker
Bringing builder pattern to defeat deadlocks
-
konst_macro_rules
detail of the konst crate
-
cast_trait_object
Cast between trait objects using only safe Rust
-
option-ext
Extends
Optionwith additional operations -
named-block
Macro implementing early-exit-from-any-block
-
uwuizer
Rust Macro to UwUize your text. UwU.
-
reax
A reactivity system for Rust that infers dependencies between functions
-
plain_enum
Mimicing Java's enum::values() and EnumMap
-
rvs
defining and evaluating random variables using a simple DSL
-
instancebuilder
Convenient way of managing dependency injection
-
byteflags
A macro to generate bitflag-like structures with u8 flag values
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
buf-read-ext
Trait extending anything that implements BufRead with stream_until_token()
-
roopert
object-oriented toolkit for Rust
-
fixnum
Fixed-point numbers with explicit rounding
-
closure_example
A short description of my package
-
iterpipes
Compositional, pipes-style stream processing
-
coi-rocket
integration support between coi and rocket
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
vmprotect
Unofficial VMProtect SDK for Rust
-
dioxus-shareables
Hooks for sharing structures between components
-
state-shift
Macros for implementing Type-State-Pattern on your structs and methods
-
bitty_write_macro
A drop-in
write!replacement that optimizes non-formatting writes for code size -
control-flow
A hack to control control-flow outside closures
-
runestr
User-perceived characters related types and data structures
-
doxed
making Rust doc strings available at runtime
-
enumx
Ad-hoc enum extension
-
sized-dst
Owned container for dynamically-sized types backed by inline memory
-
bigerror
handle big errors ¯\_(ツ)_/¯
-
vsprintf
Rust bindings to the libc vsprintf function
-
lset
Data types describing linear sets
-
rust-corosync
Rust bindings for corosync libraries
-
htmxpress
Procedural macros for generating htmx strings
-
permeable
A permission-demand trait. Decouples the permission-demander from the permission / auth provider.
-
humane_commands
Allows you to write more shell-like Commands
-
greattraits
My own collection for traits extending standard library types
-
scopefn
Scope functions for Rust
-
once-fn
cache the result of a function, make it runs only once
-
thread-object
Abstraction over thread-local storage allowing dynamic creation of TLS variables
-
lmml-parser
LMML parser
-
malachite-bigint
A drop-in num-bigint replacement based on malachite
-
have_len
container empty ? (
is_empty()andis_not_empty()) -
any_cmp
Support dynamic type comparisons
-
type-toppings
Opinionated extensions to standard types
-
ownedbytes
Expose data as static slice
-
sign-bound
Layout-optimized positive and negative integers
-
nonasync
A set of utilities useful for building a non-blocking non-async APIs
-
piston-float
Traits for generic floats in game development
-
range_map_vec
range map data structure backed by a Vec
-
poison-guard
maintaining sane state in the presence of panics and failures
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
jget
Rust tools
-
io-adapters
Adapters to convert between different writable APIs
-
fnichol-cime
A demonstration of a Rust CI build/test/release workflow supporting multi-platform testing, binary builds, Docker image building, and Crates.io publishing
-
wtflip
A language in a Rust macro... or something.
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
consclr
console text colorful
-
box-dyn
Macro to derive the implementation of Trait for Box<T: Trait>
-
impl_ops
Macros for easy operator overloading
-
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
frayed
Unfused and unashamed iterators
-
rama-error
error types and utilities for rama
-
multer-derive
derive for constructign type from multer Multipart
-
concat-string
macros for concatenating string slices into owned strings
-
liftor
Functors for Rust lifetimes
-
defile
Proc-macro helper to ungroup macro metavariables
-
lyneate
beautiful code underlining and error reporting
-
fallible_map
fallible mapping over
Optionand iterators using functions that can returnResults -
const_struct
macro that allows const structures to be passed as const generics
-
physical-quantity
dimension and unit system for general physical physical quantities
-
leptos_datatable
A leptos component for creating tables with data validation
-
peekable-fwd-bwd
Iterator Peekable with multi-forward-peek and multi-backward-peek
-
ambient-authority
Ambient Authority
-
nanvm-lib
NaNVM library
-
defmac
A macro to define lambda-like macros inline
-
rnet
Easily call into Rust from C# or other .net langauges
-
pooled-writer
using N threads to write to M compressed files/writers
-
macroland
macro shorthands of various types in Rust
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
io-window
Seekable I/O adapter that limits operations to a byte range
-
stecs
Experimental static compiler-checked ECS library
-
kittycad-execution-plan-traits
Types for KittyCAD execution plans
-
singleton-attr
singleton procedural attribute and derive macro
-
river-layout-toolkit
Write River layouts in Rust with ease
-
greedy_enum
derive macro of FromStr for enum
-
nonicle
Tools for type-safe, canonical data representations
-
pathogen
Typed references and deep mutation into Rust types
-
defer-rs
Deferred execution Rust utilities
-
cadeau-sys
FFI bindings to Cadeau library, performance primitives and media foundation functions
-
macroquest
Write MacroQuest plugins in Rust
-
irox-structs
Traits for Struct Types - linearly serialized big/little endian bytes
-
adhesion
A set of macros for design by contact in Rust. The design of this library was inspired by D's contract programming facilities.
-
partial-borrow
Partially borrow a struct
-
probe
Static instrumentation probes
-
beaver
setting up Rust objects inspired by factory_bot
-
display_with
Return opaque impl Display and/or impl Debug types via display_with and debug_with
-
thisctx
Easily create error with contexts
-
brug
enum command generation for implementation blocks
-
handle_errors
just a macro to get the thiserror with colors and the error place
-
rtml
(r)ust macros for h(tml) expansion => rtml. (r)ust type safe (css) => rcss
-
pi_null
define trait is named Null. u8,u32,u64,Option...is implements Null
-
chassis
Compile-time dependency injection framework
-
murrelet_livecode_macros
livecode macros for murrelet, a livecode framework
-
isr-macros
Macros for ISR
-
fmu_from_struct
A derive macro for automatically setting up FMU models in Rust
-
dbus-strings
Rust native implementation of different D-Bus string types
-
imstr
Cheaply clonable and slicable immutable strings
-
supply-chain-trust-example-crate-000046
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… -
rombok
boilerplate generation macros like lombok
-
tailwag_macro_inline
The logic for A collection of macros to support the tailwag crate
-
smallnum
Compile-time size optimization for numeric primitives
-
early_returns
Macros to make early returns easier to work with in Rust
-
funkjon
One of the worst macros this world has ever been (dis)graced with
-
flip-flop
implements the flip-flop operator from Perl and Ruby as a Rust macro
-
hrbf
Hermite Radial Basis Functions with higher order derivatives
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
namewise
Derived trivial name-wise conversions for Rust types
-
enum-rotate
Rotate and iterate your enums
-
problem
Error handling for command line applications or prototypes
-
cronjob
scheduling your methods
-
windows-helpers
Helpers for the windows crate
-
ieee-apsqrt
Square root functions for IEEE floats using rustc_apfloat
-
mstr
2-word, immutable Cow<str>
-
apparat
A lightweight event-driven behavioral state machine
-
rs_transducers
transducers for Rust
-
nan-tag
NaN-tagged pointers in Rust, storing an f64 in the same space as a pointer
-
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
perhaps
Maybe monad implementation with a more intuitive name. Using Certain and Dubious instead of Just and Nothing
-
squote
A clone of the quote crate that uses a String as its backing store
-
cgp-async
Async-generic primitives to support both sync/async in context-generic programming
-
function_overloading
that adds function overloading
-
filters
Build filters/predicates with the builder pattern
-
let_clone
Declarative macro to clone multiple values at once
-
projecture
Easy arbitrary type projections without proc macros
-
rustpython-literal
Common literal handling utilities mostly useful for unparse and repr
-
illicit
An implicit thread-local environment which is indexed by type
-
nightly-quirks
A basic set of utilities that mimic nightly behaviour in stable Rust, with the possibility of using nightly implementation with the nightly feature
-
iter-scanb
Extend Iterator::scan, but use B, instead of Option<B>
-
ground-env
Parse env variables by defining a struct
-
flexible-io
Wraps values such that dyn-safe IO traits need not appear as static bounds
-
type_utilities
Implementing more methods to rust type primitives
-
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
flaky_test
atttribute macro for running a flaky test multiple times
-
cgp-error
Context-generic programming error components
-
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
hxdmp
A small utility to create hexdump output from byte slices
-
min-max
max! and min! macros
-
lithium
Lightweight exceptions
-
descriptive_toml_derive
Procedural derive macro for serializing a struct into a TOML template with field descriptions that is easily edited and deserialized
-
strser
A struct serializer for rust empowered with a macro
-
error-iter
Error::sources on stable Rust
-
stub-macro
stub!() is a better version of todo!() that can be assigned to a variable
-
std_nightly_to_stable_3db085279c83
-
hold-macro
extended todo!() macro that can suppress unused value warnings
-
yugen
Writing rust like python
-
koute/nes
emulator written in Rust
-
enum-derive-2018
macros for deriving additional functionality for enums
-
supply-chain-trust-example-crate-000043
derive(Error)
-
zngur
A Rust/C++ interoperability tool
-
typemap-meta
compile-time macro to create type-to-value maps
-
async_fn_traits
Trait synonyms for “Fn[…]”-trait bounds returning futures
-
bitmask
generator for enum scoped bit flags
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
simplicio
Gets rid of the boilerplate in rust
-
arc-interner
An interner that deallocates unused values
-
enum_index
Trait and macros for extracting Enum variant index
-
raw-cstr
Keep raw-cstrings in thread local storage for reuse
-
instruct-macros-types
Instructor Macro Types are a collection of simple types that we export to work with the instruct-macros crate
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
burrtype
A framework for exporting types to other languages
-
delegare
delegate struct easy
-
conditional-trait-gen
Trait implementation generator macro supporting conditional methods
-
ident-mash
Mash idents together inside macro_rules!
-
const_sort_rs
Sort slices in const items
-
oxydized-money-macros
Companion library to oxydized-gains providing convenience macros
-
tea-map
Map functions for tevec
-
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
perthread
ThreadMap structure for accessing PerThread thread local variables form a static context
-
medi-rs
mediator library for Rust
-
timely_container
Container abstractions for Timely
-
procedural-masquerade
macro_rules for making proc_macro_derive pretending to be proc_macro
-
trait_cast_rs
Get your own Any with support for casting to trait objects
-
to_snake_case
that transforms strings to snake_case
-
partially
Partial trait, and an optional macro to mirror a struct, wrapping each field in an Option
-
kstring
Key String: optimized for map keys
-
hado
Monadic do notation using a macro
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
netsblox-extension-util
Allows for automatic generation of a NetsBlox extension that uses WASM
-
steel-gen
Code generation crates for use within steel
-
type_reflect
Extensible runtime reflection through a Derive macro
-
turbostate
Finite State Machine
-
replace_err
Adds a
replace_errmethod toResultwhich throws away the current error and replaces it -
assert_unordered
A direct replacement for
assert_eqfor unordered collections -
partial_derive2
makes all the properties of a struct type an optional property
-
imgref-iter
A small crate for iterating over the rows or columns of
imgrefbuffers -
jsona-openapi
A openapi dsl in jsona
-
dyn-dyn
Flexible trait object downcasting using ptr_metadata
-
scope-lock
Safely extend lifetimes
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
scientisto
A light-weight Rust implementation of the github/scientist library used for careful refactoring of critical code paths
-
standback
New standard library, old compiler
-
word_iter
Iterator over all words in a string
-
slice-utils
A collection of slice utils, like itertools
-
peak-result
trait that extends the standard Result enum to allow you to run some code in case of error or success
-
casual
parsing user input
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
nanoval
A nan-tagged value for representing f64, i32, u32, booleans, null and arbitrary pointers
-
hb_error
Useful macros and traits for creating and handling errors
-
derive_default_builder
derives a builder implementation relying on all fields implementing Default
-
type-factory
unique opaque types
-
xconstants
Adds preliminary support for enum const generics
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
racros
Collection of rust macros
-
type-uuid
Safe, stable IDs for Rust types
-
zerror
error interface for context-aware error-reporting
-
xselfref
Fork of the selfref library, with some additions
-
swapbytes
swapping the endianess of structures
-
rbtag
A procedural macro to add build DateTime and git commit information at compile time
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
utility-macros
emulate Utility Types and Unions from TypeScript
-
fastpeek
A different way to peek iterators
-
enumcapsulate
Safe casting for newtype enums and their variants
-
tracerr
Custom compile-time captured error tracing
-
supply-chain-trust-example-crate-000008
A macro to ergonomically define an item depending on a large number of #[cfg] parameters. Structured like an if-else chain, the first matching branch is the item that gets emitted.
-
posix-errors
Posix error codes and handy functions for using them
-
rust_bridge
The rust_bridge
-
dyncast
Downcasting made easy
-
shoulda
derive macro for test assertions
-
op-alloy
Connect applications to the OP Stack
-
enum_derive
macros for deriving additional functionality for enums
-
fixed-macro-types
Macro aliases used in the
fixed-macrocrate -
readonly
Struct fields that are made read-only accessible to other modules
-
notzero
macro for constructing
std::num::NonZero*from constants -
kube-core
Kube shared types, traits and client-less behavior
-
ribbon
Tape machine for peeking through windows of iterators
-
ftkit
A small set of utilities for newcomers learning Rust
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
shoogah
Add some syntactic 'shoogah' to Rust
-
declarative_type_state
A collection of declarative macros to reduce boilerplate code when implementing type-state patterns
-
bidir_iter
Bidirectional iterators
-
aspect
Toolkit for Rust
-
vec_vec
When dealing with
Vec<Vec<T>>is unavoidable -
whiskers-widgets
Dynamic UI sub-system for whiskers
-
lup
A custom indexed loop macro library for Rust
-
eeric-interpreter
A front-end abstraction layer over eeric
-
cantor
A general toolkit for working with types that have a small number of values
-
checked_sum
safely summing up iterators
-
is_empty
Easily check if the struct is empty
-
ssi-core
Core types and traits for the ssi library
-
merge2
Merge structs into single by values
-
better_any
Type id and Any for non static types
-
raw_struct
procedural macro for easily declaring C-style structs that reference local or external memory, based on your memory implementation. It generates appropiate getter methods for easy access.
-
rsor
Reusable slice of references
-
osu-file-parser
parse an osu! beatmap file
-
retoken
Build &str tokenizers using regex
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
tuplemagic
manipulating tuples through various operations like mapping, filtering, nesting, and reducing
-
supply-chain-trust-example-crate-000032
Extra iterator adaptors, iterator methods, free functions, and macros
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
tcs-dhbw
Modules for a model traffic control system project at DHBW Stuttgart
-
dyn-context
mechanism for lifetimes erasing
-
sod-mpsc
Service Oriented Design - Multi Producer Single Consumer
-
pusherator
Push-based version of Rust iterators
-
macro-utils
Some macros to make code writing more elegant and funny
-
rs-std-ext
An extension for the standard library
-
smartcow
a cow for smartstrings
-
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
maybe-uninit
MaybeUninit for friends of backwards compatibility
-
close-err
Add .close() to file-like types, for error handling
-
gl-env
Bulk-edit Group- and Project-level CI/CD variables in GitLab
-
anyhow_ext
Extension of anynow
-
thiserror-ext
Useful extension utilities for
thiserror -
dev_bestia_url_utf8
url utf8 encode/decode
-
transactional_iterator
Iterator that allows to commit or abort progress
-
ghost-lite
custom PhantomData types
-
maflow
Flow macros: basically unwrap for return, continue and break
-
quasi_iter
that contains supplementary iterator objects and methods
-
curerr
easy error handling
-
brain_flak_macro
Brain-Flak macro
-
ctrlgen
Generate enums for message-passing services
-
itermap
Iterator tools for maps (
HashMap,BTreeMap, etc.) -
printc
Print-clean macro. Like
println!but cleaner input. -
chalk-macros
Macros for Chalk
-
objectionable
storage of unsized types inline inside allocated objects
-
redis-om
Redis ORM-style library that simplify the development process and reduce the amount of boilerplate code needed to build programs that leverage [redis] powerful capabilities and use cases
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
list_comprehension
A macro for Haskell-like list comprehensions in Rust
-
thread-scoped-ref
that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
try_as
Macros and traits to ease using enums whose sole purpose is to enumerate a set of types
-
will_exit
work on program will exit
-
iterator_item
a generator syntax experiment
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
enum_macro
Useful macro for enum
-
tryvial
Small crate for ok-wrapping and try blocks
-
pyderive
Derive macro of Python special methods and a class attributes for PyO3
-
partial_function
A clean way to define function as a set of subfunctions where each has defined start and end bounds
-
wrapping-macro
wrapping macro
-
iter_ref
Traits for iterating over referenced data without consuming the iterator
-
log_err
Log error messages from Unwrap and Expect with log crate
-
wasmer-wit-bindgen-gen-core
wit-bindgen-gen-c
-
fancy-default
A better
derive(Default)implementation -
slice-copy
Go style copying for slices
-
sly_static
Seamless Rust Static Initialization: Effortless and Efficient
-
const-units
that lets you check the dimensions of your quantities at compile time and run time
-
pluck
Extract values conveniently
-
asset-derive
asset handling derive macro for enums, and a proc-macro learning resource!
-
anonymous-trait
Anonymous trait implementation with capturing the environment
-
ffizz-passby
FFI helpers for implementing pass-by-value and pass-by-pointer
-
num-sign
enum Sign { Positive = 1, Negative = -1 }
-
simple_scan
Iterator extensions for simple scan operation
-
range_checker
derive-macro crate aimed to provide declarative bounds checking and filtering for structure
-
yansongda-utils
rust 中一些关于我自己的常用工具
-
selfref
Semi-pain-free self-referential pinned types
-
anony
Anonymous struct
-
squeak
providing types allowing execution of callbacks in response to values being broadcast or mutated
-
enum-unitary
Trait and macro for unitary enums
-
injectables
procedural macro library that enables field injection between Rust structs through #[injectable] and #[inject_fields] attributes. The library handles visibility rules, generic type resolution…
-
lifterr
A small set of adapters extending Rust's error-handling capabilities
-
kmacros
Useful macros
-
iter_accumulate
An iterator adaptor that accumulates the elements and yields the current accumulated value for each iteration
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
tor-async-utils
Async/futures helpers for use with Tor
-
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
fmodel-rust
Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust
-
warrant
A Swift-guard-like macro for Rust
-
veccell
variant of Vec with interior mutability
-
laby_common
Shared code required by laby
-
deferred-box
Defer the value set after the struct has been initialized
-
tch-tensor-like
Derive convenient methods for struct or enum of tch tensors
-
throwing
Create explicit errors easily with a handy macro
-
hereditary
Procedural macros for emulating OOP Inheritance in Rust
-
value_unit
every unit imaginable. Also contains a handy macro
-
as-result
Traits for converting types which may be interpreted as or into a result
-
high_mem_utils
bunch of mem safe abstractions,some involving transmute
-
is-odd
Returns true if the given number is odd
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
bronzeflow
Bronze: A workflow scheduler in rust
-
temporary_enum_delegate_0_3_0
trait delegation functionality for enums and structs
-
wgsl-types
WGSL Types
-
redhook
Dynamic function call interposition / hooking (LD_PRELOAD) for Rust
-
string-join
A python-like way to join items in an iterator with a separator
-
tugger-snapcraft
Snapcraft packaging primitives
-
data_type_checker
A lightweight Rust library for validating and converting data types from strings
-
regex-macro
A macro to generate a lazy regex expression
-
pyspark-arrow-rs
Derive macros to be used to add some helper functions to Rust structs to make them useable in Pyspark's mapInArrow
-
bloc
A state management library
-
nougat
(lifetime) GATs on stable Rust
-
enum_pipeline
way to use enums to describe and execute ordered data pipelines
-
fold-license
Folding licenses from multiple dirs with
cargo/Cargo.toml andyarn/package.json -
qcontext
One-time initializable static state with statically-checked zero-cost interior mutability
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
diesel_derives_traits
Traits for diesel_derives_extra
-
whiteout
macros that erase the type of any value into an impl Trait for a given trait
-
ip-family
IP family enum with functions to get special ips of the right family
-
ddd-rs
Domain-Driven Design (DDD) building blocks, for Rust applications
-
knife
An iterator that divides things evenly
-
rmin
A minimal Rust lib for writting R extensions
-
nanopre
A a zero-dependency, no-unsafe implementation of a minimal C-style text preprocessor
-
pokers
Rust Poker Library
-
bilk
Miscellaneous convenience functions and traits
-
syn-test-suite
Test suite of the syn crate
-
ebacktrace
error wrapper which captures a backtrace and can carry an optional textual description
-
cudd-sys
Bindings for CU Decision Diagram library (CUDD)
-
failsafe
A circuit breaker implementation
-
csharp_binder
generate C# bindings for a Rust foreign function interface (FFI)
-
termal_core
contains implementation for the termal library
-
teo-teon
Object notation for Teo
-
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
macon_api
builder macro-based generator with its own idioms
-
tailsome
Blanket traits providing
.into_ok(),.into_err(), and.into_some()for happier method chaining -
arraybox
A box with fixed capacity, backed by a byte array (it can be stored on the stack too). Implements fixed capacity
ArrayBox. -
almost
comparing floating point numbers
-
mapcomp
Python-like list comprehensions for standard containers
-
onlyerror
Obsessively tiny error derive macro
-
field-visibility
Attribute to specify the visibility of all fields in a Rust struct
-
merge-hashmap
Merge multiple values into one
-
repeated
Allows you to repeat a block of code a number of times
-
variant_counter
Rust's Enum variant counter
-
ferrite-session
Session Types DSL for Rust
-
darkly
scanf-style scanner
-
standalone-proc-macro2
Fork of proc-macro2 that uses rustc-ap-proc_macro so as to remove the rustc dylib dependency
-
dyn_traits
Magically derive non-object-safe traits
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
vmm
A math library focused on vectors and square matrices
-
temp-stack
A data structure for contexts or similar stack structures that are allocated on the call stack, using the temp-inst crate for lifetime erasure
-
sconcat
String concatenation
-
destruct-drop
Macro for dropping the fields of a struct or enum without dropping the container
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
supply-chain-trust-example-crate-000028
A macro for declaring lazily evaluated statics in Rust
-
split_exact
splitting strings into arrays of slices
-
throw
Efficiently add statically-calculated stack traces to errors
-
vnum
Create enums with a constant value associated to every variant
-
metaprogramming
Port C++ metaprogramming to Rust
-
mixed_array
Construct arrays of mixed types
-
partial-result
results that return success for non-critical errors
-
aoc-util
function for aoc
-
retryiter
A wrapper lib on top of rust Iterator with added retry support
-
ijzer
Main crate for IJzer. Provides a macro for using IJzer in a rust project, and a prelude with dependencies..
-
zoomer
Making Rust a true modern language™️ with revolutionary macros
-
type-variance
Marker traits for subtype variance
-
string-eyre
Convenience traits for dealing with errors that don't want to eyre
-
btl
shell scripting in rust. Github Repo: https://github.com/znx3p0/btlsh
-
no_std_strings
no_std version of crate fixedstr: strings of constant maximum size that can be copied and stack allocated
-
multindex
Index slices with multiple const indices/ranges
-
jealousy
A wrapper arount the envy crate, providing an easily implementable trait
-
strflags
A string-enum and string-flags with fixed variants that can also accept arbitrary data
-
cor_iter
Correlate of two iterators
-
malvolio
programmatically generating HTML
-
uni_tmp_jni
It's temporary fork for https://crates.io/crates/jni. Don't use!
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
pyadvreader
Split text file into text sequences, strings and (line) comments
-
dynamic-cast
The fifth pillar of OOP: dynamic casting
-
loopcell
cell for multiple routes of access that are only used one-at-a-time in sequence
-
asserteq_pretty
An assert_eq macro that prints more helpful diffs on mismatch
-
dyn-eq
Test equality between trait objects
-
postgres-mapper
Struct mapping for postgres
-
io-read-line-prototype
Prototype for io::read_line
-
oi-unwrap
unwrap without unwrap
-
rw-exact-ext
Extension of std::io to read and write data types with exact amounts of bytes
-
err-convert-macro
Errors converting macros
-
int-to-c-enum
TryFromInt - A convenient derive macro for converting an integer to an enum
-
prometheus-metric-storage
Derive macro to instantiate and register prometheus metrics without having to write tons of boilerplate code
-
kix
A result type for testing that supports to eliminate using of Result::unwrap
-
oofs
Error handling library that generates and injects context for you
-
sod-bus
Service Oriented Design - Single Producer Multi Consumer
-
todo_using
A super small crate only exporting a single macro to "use" parameters
-
classes
Dependency-free macro that simplifies the process of building class strings for DOM elements
-
binstring
Binary strings
-
lateinit
Unsafe late-initialization for statics
-
splop
Helper functions to determine the first/last repetition of something
-
error-ext
Error utilities
-
target-cpu-fetch
Exposes a method for querying the CPU name from the current target specification JSON file
-
rustils
Utilities for rust
-
easy-min-max
Easy to use macros for min, max and clamp. Works with no_std
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
stringlit
A macro to convert from str to String
-
retry-block
retry operations that may fail with configurable backoff behavior using macros over blocks of code
-
vec_filter
Vec Filter is a Rust library to filter a vector of structs based on a query string. It allows you to specify filter conditions on struct fields with a simple query syntax. The library provides a custom derive macro…
-
navigator
A Macro-heavy Domain-Specific Language for console apps with menu systems
-
gha_main
Convenience macros for writing GitHub Actions in Rust
-
iter_from_fn
Create iterator from repeatedly aplying a function that takes no parameters
-
cron_macro
cron macro
-
custom_float
Custom floating-point types
-
error_handling
Macro used to clean and centralize error handling within async processes
-
another-visitor
Lets you derive visitor pattern implementations
-
destruct
structs and enums for simpler combinator implementation
-
memprint
A way to print memory layout of a struct
-
include_data_uri
include a file as a data uri
-
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!,include!, orconcat_idents!) -
mogrify
macro for autogenerating a “Parse, Don’t Validate”
TryFromimplementation for structs -
unreachable_checked
unreachable!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won't panic.
-
sod-log
Service Oriented Design - Log Integrations
-
buffer
Safe, write-only, generics-free buffer abstraction
-
rerast_macros
Macros for use in Rerast rules
-
std_io_iterators
An iterator for
STDINand a wrapper forSTDOUT. Allows easy piping, and graceful closing of application if pipe breaks -
shvar
POSIX-compliant shell variable substitution routine
-
get-field-by-type
Get a value of field, based on the type of a field
-
simple-dmenu
macro to call dmenu
-
forkable
Fork-able iterators and asynchronous streams
-
ordered_iter
Ordered iterators
-
mcurry
Macros for creating curried functions
-
sha2-derive
exporting a derivable
Hashabletrait that works withsha2 -
tagged-pointer-as-enum
A set of structs, traits and macros to implement tagged pointers
-
rexpr
Rust Json Object access Runtime
-
displaythis
derive(Display)
-
string-config-parser
configuration file parser for Rust
-
anymap3
A safe and convenient store for one value of each type
-
try_utils
The try! macro descends into an enum variant. It's more flexible than ? and unwrap(), and it works with your enum, too!
-
pinocchio-pubkey
Companion pubkey helpers for Pinocchio
-
convertable-errors
defines an ergonomic macro for deriving From<Foreign> conversions for variants of Rust enums
-
loop_chain
Macro for writing nested Loop expressions
-
prompt-organizer
better manage AI prompts in your Rust code
-
shoggoth
Generic and type-level programming for Rust
-
ffizz-string
FFI string implementation
-
derive_constructors
Deriving From, TryFrom and create new_with_*args* functions
-
ehttpd-range
comfortably handle HTTP range requests within
ehttpd-based applications -
redb_model_trait
Redb model trait
-
re_types_core
The core traits and types that power Rerun's data model
-
rust_jsc_sys
Low-level bindings to JavaScriptCore
-
negative
impls in stable Rust
-
drop-bin
Defer running expensive destructors until later
-
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
-
string-builder
string builder type
-
rust_c
Write C code inline in your rust code (hacky fork of rust-cpp / cpp crate)
-
accompany
with-like macro for Rust -
mod_use
pub mod xxx; use xxx::*;
-
thiserror-nostd-notrait
derive(Error)
-
type_description
Machine-readable type descriptions
-
description
like Display, but 'static
-
to-syn-value
Defines a derive macro to implement a trait converting values to instances of syn::ToDeriveInput
-
error-doc
proc macro to generate #[doc] comments from #[error] messages
-
these
A three-way enum capturing This, That, or Both. Inspired by the Haskell package https://hackage.haskell.org/package/these
-
avocado-schema
A schema DSL which can be interpreted to implement multiple purposes
-
catch-unwind
Wrappers for catch_unwind that handle the edge case of the caught panic payload panicing
-
ever
Print the build information of your program with minimal boilerplate
-
dependent_ghost
Matt Noonan's 'Ghosts of Departed Proofs'
-
trait-gen
Trait implementation generator macro
-
flowcontrol
clarifying and simplifying control flow
-
regi
Regi
-
mapper-api
Api of the
mappercrate -
heimdall_errors
Macros for From trait errors
-
thin-boxed-slice
ThinBoxedSlicestores the size of the slice before the content of the slice, so thatsize_of::<ThinBoxedSlice>is only the size of a pointer -
extended-primitives
providing primitive-like types for use
-
persian_str_rs
functions for working with Persian strings in Rust
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
enums_arena
enums_arenais an arena that enums can be stored efficiently -
fullypeek
Peek forward in an iterator as far as you'd like, memory allowing!
-
multi_stack_queue
Abstraction layer for a stack-allocated multi-queue with bounded length. WIP
-
makepad-internal-iter
Internal iterators
-
temp-inst
safe lifetime-erased representations for objects with lifetime parameters. Can be used to pass an object across an API where lifetime parameters would prevent it.
-
hazmat
A collection of helpers for working with hazardous materials in Rust crates
-
com-scrape-types
Support code for bindings generated with com-scrape
-
validus
A string validation library
-
write-to-file
Write to a file, simple helper fn and traits lib crate
-
detour2
A cross-platform detour library written in Rust
-
tenacious
[RETIRED: Will not work with MIR] A plugin to prevent certain types from being moved
-
wrapping_macros
A macro for wrapping arithmetic
-
builder_option
A macro to generate builder class for a struct
-
makero
A
macro_rules!macro to aid in the creation of complexmacro_rules!macros -
dynstack
A stack for trait objects that minimizes allocations
-
newstr
macros for declaring String-base new types
-
rustkell
haskell like functions in rust
-
oneline_str_enum
Format and parse enums as strings with macros
-
defvar
A macro that makes defining environment variables easy
-
on_drop
on drop
-
dupe
Marker for types which are cheap to clone
-
typesafe-builders
Infallible compile-time checked builders for your structs
-
tartan-c-enum
Define FFI-safe enums that support unknown values
-
truthy
Check if a value is "truthy"
-
friendly_safety_buddy
A fun macro to write safe code with
-
unify
Trait-based equality constraint for Rust