Lib.rs

bitflags

A macro to generate structures which behave like bitflags

thiserror

derive(Error)

itertools

Extra iterator adaptors, iterator methods, free functions, and macros

anyhow

Flexible concrete Error type built on std::error::Error

derive_more

Adds #[derive(x)] macros for more traits

predicates

boolean-valued predicate functions

once_cell

Single assignment cells and lazy values

derive_builder

Rust macro to automatically implement the builder pattern for arbitrary structs

num

A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!

lazy_static

A macro for declaring lazily evaluated statics in Rust

ordered-float

Wrappers for total ordering on floats

miette

Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers

async-stream

Asynchronous streams using async & await notation

num_enum

Procedural macros to make inter-operation between primitives and enums easier

validator

Common validation functions (email, url, length, …) and trait - to be used with validator_derive

bytes

Types and traits for working with bytes

darling

A proc-macro library for reading attributes into structs when implementing custom derives

eyre

Flexible concrete Error Reporting type built on std::error::Error with customizable Reports

downcast-rs

Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.

human-panic

Panic messages for humans

typed-builder

Compile-time type-checked builder derive

rustlings

Small exercises to get you used to reading and writing Rust code!

dyn-clone

Clone trait that is object-safe

similar-asserts

assert_eq! like macros with colorized diff output

approx

Approximate floating point equality comparisons and assertions

frunk

developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends

pin-project-lite

A lightweight version of pin-project written with declarative macros

bon

Next-gen compile-time-checked builder generator, named function's arguments, and more!

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

memoffset

offset_of functionality for Rust structs

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

smol_str

small-string optimized string type with O(1) clone

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

ouroboros

Easy, safe self-referential struct generation

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.

pin-project

safe and ergonomic pin-projection

bitfield

macros to generate bitfield-like struct

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…

float-cmp

Floating point approximate comparison traits

arrayref

Macros to take array references of slices

backon

Make retry like a built-in feature provided by Rust

more-asserts

Small library providing additional assert_* and debug_assert_* macros

beef

More compact Cow

nonempty

Correct by construction non-empty vector

extendr-api

Safe and user friendly bindings to the R programming language

error-stack

A context-aware error-handling library that supports arbitrary attached user data

tap

Generic extensions for tapping values in Rust

inventory

Typed distributed plugin registration

new_debug_unreachable

panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)

amplify

Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros

cmd_lib

Common rust commandline macros and utils, to write shell script like tasks easily

az

Casts and checked casts

if_chain

Macro for writing nested if let expressions

castaway

Safe, zero-cost downcasting for limited compile-time specialization

cfg_aliases

A tiny utility to help save you a lot of effort with long winded #[cfg()] checks

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

trie-db

Merkle-Patricia Trie generic over key hasher and node encoding

orchestra

Generate an orchestra of subsystems from a single struct

rustdoc-types

Types for rustdoc's json output

assertables

assert macros for better testing, debugging, quality assurance, and runtime reliability

nutype

The newtype with guarantees

safer-ffi

Write safer FFI code in Rust without polluting it with unsafe code

pact_consumer

Pact-Rust module that provides support for writing consumer pact tests

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

flagset

Data types and a macro for generating enumeration-based bit flags

inlinable_string

inlinable_string crate provides the InlinableString type – an owned, grow-able UTF-8 string that stores small strings inline and avoids heap-allocation – and the StringExt trait…

polonius-the-crab

Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust

index_vec

Newtype-style helpers for Vec and usize

static_init

Safe mutable static and non const static initialization, and code execution at program startup/exit

replace_with

Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one

opaque-debug

Macro for opaque Debug trait implementation

abi_stable

For doing Rust-to-Rust ffi,writing libraries loaded at program startup

sptr

Strict Provenance Polyfill

dlib

Helper macros for handling manually loading optional system libraries

constcat

concat! with support for const variables and expressions

konst

Const equivalents of std functions, compile-time comparison, and parsing

stdext

Extensions for the Rust standard library structures

async-once-cell

Async single assignment cells and lazy values

float-ord

A total ordering for floating-point numbers

unwinding

in Rust and for Rust

derive-where

Deriving with custom trait bounds

extism-pdk

Extism Plug-in Development Kit (PDK) for Rust

auto_impl

Automatically implement traits for common smart pointers and closures

parse-display

Procedural macro to implement Display and FromStr using common settings

volatile

wrapper types for raw pointers

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

fallible-iterator

Fallible iterator traits

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

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

by_address

Wrapper for comparing and hashing pointers by address

thiserror-no-std

derive(Error)

aws-smithy-types-convert

Conversion of types from aws-smithy-types to other libraries

testresult

type for concise and precise test failures

lazy_format

lazily formatting values for later

writeable

A more efficient alternative to fmt::Display

recursion

cache-aware stack safe recursion

tuples

many useful tools related to tuples

bounded-integer

Bounded integers

educe

offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits

iter-read

A Read implementation for iterators over u8 and related types

field-offset

Safe pointer-to-member implementation

retry

retrying operations that can fail

virtue

A sinless derive macro helper

rustler

Safe Rust wrappers for creating Erlang NIF functions

cascade

Dart-like cascade macro for Rust

tynm

Returns type names in shorter form

terrors

ergonomic and precise error handling built atop type-level set arithmetic

maplit

Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet

fallible_collections

adds fallible allocation api to std collections

bounded-collections

Bounded types and their supporting traits

internal-iterator

Internal iteration equivalent of std::iter::Iterator

fatality

extension to thiserror::Error

inout

Custom reference types for code generic over in-place and buffer-to-buffer modes of operation

fix-hidden-lifetime-bug

Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue

iri-string

IRI as string types

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

retour

A cross-platform detour library written in Rust

chalk-ir

Chalk's internal representation of types, goals, and clauses

tryhard

Easily retry futures

log-once

Collection of helper macros for logging some events only once

psm

Portable Stack Manipulation: stack manipulation and introspection routines

pyo3-polars

Expression plugins and PyO3 types for polars

flex-error

Flexible error definitions using macros and traits

maybe-owned

MaybeOwned (and MaybeOwnedMut) type similar to std’s Cow but it implements From<T> and From<&'a T> and does not require ToOwned

pinned-init

facilitate safe pinned initialization

bounded-static

Defines the ToBoundedStatic and IntoBoundedStatic traits

safe-transmute

A safeguarded transmute() for Rust

st-map

Runtime for a stack-alocated map

typewit

type-witness-based abstractions, mostly for emulating polymorphism in const fns

fragile

wrapper types for sending non-send values to other threads

shaku

Compile Time Dependency Injection for Rust

safelog

Conditionally suppress confidential information from logs

tuplex

Rust tuple extension

mirai-annotations

Macros that provide source code annotations for MIRAI

elain

Set a type's minimum alignment with const generics

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…

autosurgeon

working with data in automerge documents

lender

A lending-iterator trait based on higher-rank trait bounds, with full std::iter::Iterator functionality

nshare

Conversion between n-dimensional types in different Rust crates

decorum

Total ordering, equivalence, hashing, and constraints for floating-point types

implicit-clone

Immutable types and ImplicitClone trait similar to Copy

rust-fsm

A framework and a DSL for building finite state machines in Rust

rustrict

profanity filter for Rust

moveit

safe, in-place construction of Rust (and C++!) objects

lazycell

providing a lazily filled Cell struct

derivative

A set of alternative derive attributes for Rust

arr_macro

Initialize arrays with ease!

strck

Checked owned and borrowed strings

shopify_function

write Shopify Functions in Rust

refined_type

imbuing rules into types and elevating them to more robust types

k8-client

Core Kubernetes metadata traits

socketpair

Cross-platform socketpair functionality

rdftk_names

set of modules that contain the IRIs and QName strings for commonly used vocabularies. It also provides macro support for defining new namespaces in the same style as this library.

joinery

A small crate for generically joining iterators with a separator

conjure-object

Runtime support for generated Conjure objects

anymap3

A safe and convenient store for one value of each type

parsel

Zero-code parser generation by using AST node types as the grammar

try_match

Fallible pattern matching with a function-like syntax

servo_arc

A fork of std::sync::Arc with some extra functionality and without weak references

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.

thiserror-core

derive(Error)

overload

macro to simplify operator overloading

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.

ra_ap_mbe

Handling of macro_rules macros for rust-analyzer

cl-format

Use Common Lisp format in Rust

o2o

Object to Object mapper for Rust. Derive '(Try)From' and '(Try)Into' traits.

fluent-comparisons

Boost readability by writing multicomparison expressions like if any_of!({a,b,c}>=5) {...} while keeping the benefits of hand-written code

aoc-parse

A little library for parsing your Advent of Code puzzle input

void

The uninhabited void type for use in statically impossible cases

with_locals

Function attribute to return references to locals by using CPS

mirror-mirror

Reflection library for Rust

calendrical_calculations

Calendrical calculations in Rust

reborrow

Emulate reborrowing for user types

as-any

provide the AsAny trait

documented

Derive and attribute macros for accessing your type's documentation at runtime

better_scoped_tls

scoped-tls, but with good error message

sealed

Macro for sealing traits and structures

extend

Create extensions for types you don't own with extension traits but without the boilerplate

tor-error

unified type-erased error type returned by many (esp. high-level) Tor APIs.

myutil

Rust Util Collections

bounded-vec

Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity

wiwi

Stuff™

miden-miette

Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers

libc-print

println! and eprintln! macros on libc without stdlib

timely_bytes

Disjoint mutable byte slices from a common allocation

zoet

Adds #[zoet] macro to reduce boilerplate when implementing common traits

concat-with

Extend the function of the concat! macro in std

random-number

Generate random numbers quickly

andex

Safe, strongly typed array indexes and wrappers for rust with zero dependencies

i_float

This fixed float math library provides an efficient and deterministic solution for arithmetic and geometric operations

mitsein

Strongly typed APIs for non-empty collections, slices, and iterators

formatx

A macro for formatting non literal strings at runtime

dync

An efficient alternative to dyn Trait for containerized types

rustversion

Conditional compilation according to rustc compiler version

cap-std-ext

Extension APIs for cap-std

fn_vm

A lightweight frame based virtual machine, meant as the base for rigz_vm

buildstructor

Macro to derive a builder from a constructor function

peeking_take_while

Like Iterator::take_while, but calls the predicate on a peeked value. This allows you to use Iterator::by_ref and Iterator::take_while together, and still get the first value…

copyless

Ways to eliminate memcpy calls when using the standard library

octseq

Abstractions for types representing octet sequences

data-rw

io buffer write reader

generics

macros for parsing generics (with optional where clause) in macro_rules!

doku

A framework for documenting Rust data structures

advent-of-code

Solutions to Advent of Code

condtype

Choose types at compile-time via boolean constants

fixed-hash

Macros to define custom fixed-size hash types

doc-comment

Macro to generate doc comments

qualifier_attr

Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items

culpa

error-handling syntax in Rust

conflate

Merge multiple values into one

bool_ext

defines and implements a complete set of Option/Result-style Boolean functional combinators on Rust’s bool primitive type

version-sync

ensuring that version numbers in README files and other files are kept in sync with the crate version

devise

devising derives and other procedural macros

autofolder

Single-element folding wrapper

atc-router

Versatile DSL based rule matching engine used by the Kong API Gateway

const-field-offset

Wrapper around field-offset crate and const-field-offset-macro

semval

Semantic validation

sugars

An useful collection of macros to make tasks easier

fmt2io

A bridge between std::io::Write and std::fmt::Write

open-enum

An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants

easy-cast

Type conversions which are expected to succeed

ungrammar

A DSL for describing concrete syntax trees

borrow

Zero-overhead, safe implementation of partial borrows. This crate allows you to borrow selected fields from a struct and split structs into non-overlapping sets of borrowed fields.

raw-parts

Ergonomic wrapper around Vec::from_raw_parts and Vec::into_raw_parts

bit_field

bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types

funty

Trait generalization over the primitive types

swipl

A high-level library for building SWI-Prolog extensions and embedding SWI-Prolog in rust applications

exhaust

Trait and derive macro for working with all possible values of a type (exhaustive enumeration)

lazy_errors

Effortlessly create, group, and nest arbitrary errors, and defer error handling ergonomically

macon

builder macro-based generator with its own idioms

unsafe-fields

unsafe to access or modify fields with safety invariants

rust_info

Extracts the current rust compiler information

resiter

Helper crate for handling iterators over result

trybuild-internals-api

A fork of trybuild with the internals exposed as a public API

entrait

Loosely coupled Rust application design made easy

blanket

macro to derive blanket implementations for your traits

copy_from_str

An extension trait to copy a string into another string

try-specialize

Zero-cost specialization in generic context on stable Rust

nunny

the definitive non-empty slice/array/vec library for Rust

munge

Macro for custom destructuring

heterob

conversion between bytes/bits and heterogeneous lists (tuples)

phantom-type

A PhantomData analog which prevents “parameter is never used” error, but does not produce any restrictions in contrast with PhantomData

psl-types

Common types for the public suffix implementation crates

ufotofu

Abstractions for lazily consuming and producing sequences

capnp_conv

capnp write/read traits to convert from structs to readers/builders

comfy-bounded-ints

Bounded-integer types focused on ergonomics and safety. (See README.md)

one_err

OneErr to rule them all

macro-attr-2018

macro_attr! macro that enables the use of custom, macro-based attributes and derivations

wmlua

TSPL

The Simplest Parser Library

more-di

support for dependency injection (DI)

endian-writer

[no_std] Methods for efficient reading and writing of structures to raw pointers in a stream-like fashion

radiation

Convert Rust type into raw bytes and vice versa

k8s-openapi-codegen-common

Common code for the k8s-openapi code generator and k8s-openapi-derive

lending-iterator

Fully general lending iterators in stable rust: windows_mut!

defer

excecution of code, inspired by go's defer statement

macro-asm-builder

macro-assemblers

vitasdk-sys

Raw bindings to vitasdk

globals

Painless global variables in Rust

aerosol

dependency injection for Rust

scaffolding-core

A software development kit that provides the scaffolding for building applications and services using OOP

validify

struct validation and modification functionality through the use of derive macros

allow

Alias/label lints (to disable) with your intentions. Reexported from allow_prefixed, grouped under rustc::, clippy:: and rustdoc:: modules.

metastruct

Abstractions for iterating and mapping over struct fields

enum-display

A macro to derive Display for enums

fallible-streaming-iterator

Fallible streaming iteration

nar_dev_utils

用于NARS相关项目开发的实用工具包

expect-exit

Result.expected(): display an error message and exit without a panic

event-driven-library

Event Driven Message Handling

fmt-cmp

Traits and utilities for lexicographically comparing values in their Display representations

fauxgen

write your own generators in stable rust

funcmap

Derivable functorial mappings for Rust

generativity

Generation of unique invariant lifetimes

hermit-sync

Synchronization primitives for kernels

scale-typegen

Type Generation for SCALE encoded Rust Types

downcast

Trait for downcasting trait objects back to their original types

soa-rs

A Vec-like structure-of-arrays container

indicator

Abstractions for stream aggregation, we call them Indicator s

tinyvec_macros

Some macros for tiny containers

string_more

Extension traits for String and &str types

a1

A package for converting to and from A1 spreadsheet notation

collate

Traits and a data structure to support collation and bisection

cexpr

A C expression parser and evaluator

cowstr

Copy-on-Write shared strings

enum-ptr

Ergonomic tagged pointer

rudi

out-of-the-box dependency injection framework for Rust

vtable

Helper crate to generate ffi-friendly virtual tables

auto_enums

allow multiple return types by automatically generated enum

kind

Costless typed identifiers backed by UUID, with kind readable in serialized versions

smarterr

Smart error handling library

lazy-static-include

lazy_static_include_bytes and lazy_static_include_str macros to replace include_bytes and include_str macros

ranged_integers

An integer restricted to a compile-time defined bounds driven by const generics

drcp-format

Parse and write DRCP and literal definition files

iced_anim

creating animations in Iced

sosecrets-rs

Secret wrapper type that reveals the secret at most MEC: typenum::Unsigned times with compile time guarantees

checked-rs

encoding validation semantics into the type system

fomat-macros

Alternative syntax for print/write/format-like macros with a small templating language

enum-assoc

Procedural macro to associate constants with enum variants

tevec

provide quantitative analysis functions for vec | ndarray | polars backend

byondapi

Idiomatic Rust bindings for BYONDAPI

const-type-layout

Derivable const trait to view and compare the layout of a struct, union, or enum

jni-toolbox

tools to make writing JNI native functions less tiresome

hlist2

Compile-time heterogeneous list implementation

direction

Representations of directions

synonym

Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.

fieldx

Procedural macro for constructing structs with lazily initialized fields, builder pattern, and serde support with a focus on declarative syntax

anyinput

A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input

jnix

High-level extensions to help with the usage of JNI in Rust code

cortex-ai

An asynchronous flow-based processing framework for building flexible data pipelines with conditional branching and error handling

deptypes

Dependent types

swift-rs-hatter-fork

Call Swift from Rust with ease!

conv2

number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'

custom_error

Define custom errors without boilerplate using the custom_error! macro

crustal

generating C/C++ code

mownstr

Maybe Owned String

tisel

Effective type-based pseudodynamic dispatch to impls, enums and typeid

is_empty

Easily check if the struct is empty

orx-closure

An explicit closure with absolute seperation of the captured data from the function

proc-bitfield

expressively declare bitfield-like structs

ownable

Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more

xx

A collection of useful Rust macros and small functions