Lib.rs

bitflags

A macro to generate structures which behave like bitflags

miette

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

thiserror

derive(Error)

itertools

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

ordered-float

Wrappers for total ordering on floats

once_cell

Single assignment cells and lazy values

derive_more

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

lazy_static

A macro for declaring lazily evaluated statics in Rust

predicates

boolean-valued predicate functions

anyhow

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

num_enum

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

darling

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

num

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

pin-project

safe and ergonomic pin-projection

async-stream

Asynchronous streams using async & await notation

bytes

Types and traits for working with bytes

validator

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

libloading

Bindings around the platform's dynamic library loading primitives with greatly improved memory safety

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.

memoffset

offset_of functionality for Rust structs

smol_str

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

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

enumflags2

Enum-based bit flags

similar-asserts

assert_eq! like macros with colorized diff output

approx

Approximate floating point equality comparisons and assertions

snafu

An ergonomic error handling library

tap

Generic extensions for tapping values in Rust

enum-iterator

Tools to iterate over all values of a type (e.g. all variants of an enumeration)

shellexpand

Shell-like expansions in strings

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

arrayref

Macros to take array references of slices

trie-db

Merkle-Patricia Trie generic over key hasher and node encoding

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.

ref-cast

Safely cast &T to &U where the struct U contains a single field of type T

static_assertions

Compile-time assertions to ensure that invariants are met

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…

beef

More compact Cow

valico

JSON Schema validator and JSON coercer

more-asserts

Small library providing additional assert_* and debug_assert_* macros

extendr-api

Safe and user friendly bindings to the R programming language

backon

Make retry like a built-in feature provided by Rust

az

Casts and checked casts

pin-project-lite

A lightweight version of pin-project written with declarative macros

safer-ffi

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

error-stack

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

amplify

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

new_debug_unreachable

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

if_chain

Macro for writing nested if let expressions

nutype

The newtype with guarantees

cfg_aliases

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

bitfield

macros to generate bitfield-like struct

castaway

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

educe

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

orchestra

Generate an orchestra of subsystems from a single struct

static_init

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

bounded-collections

Bounded types and their supporting traits

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…

inventory

Typed distributed plugin registration

flagset

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

konst

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

byte-slice-cast

Safely cast bytes slices from/to slices of built-in fundamental numeric types

fallible-iterator

Fallible iterator traits

fallible_collections

adds fallible allocation api to std collections

float-ord

A total ordering for floating-point numbers

parse-display

Procedural macro to implement Display and FromStr using common settings

async-trait

Type erasure for async trait methods

stdext

Extensions for the Rust standard library structures

polonius-the-crab

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

lazy_format

lazily formatting values for later

volatile

wrapper types for raw pointers

extism-pdk

Extism Plug-in Development Kit (PDK) for Rust

garde

Validation library

auto_impl

Automatically implement traits for common smart pointers and closures

assertables

macros assert…! for better tests, quality assurance, debug testing, and runtime reliability

virtue

A sinless derive macro helper

sptr

Strict Provenance Polyfill

replace_with

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

derive-where

Deriving with custom trait bounds

pyo3-polars

Expression plugins and PyO3 types for polars

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

opaque-debug

Macro for opaque Debug trait implementation

maplit

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

bon

Generate builders for everything!

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

cmd_lib

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

fixedstr

strings of constant maximum size that can be copied and stack allocated using const generics

thiserror-no-std

derive(Error)

nonempty

Correct by construction non-empty vector

field-offset

Safe pointer-to-member implementation

static_cell

Statically allocated, initialized at runtime cell

crevice

Create GLSL-compatible versions of structs with explicitly-initialized padding

by_address

Wrapper for comparing and hashing pointers by address

testresult

type for concise and precise test failures

writeable

A more efficient alternative to fmt::Display

bounded-integer

Bounded integers

doc-comment

Macro to generate doc comments

constcat

concat! with support for const variables and expressions

version-sync

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

aws-smithy-types-convert

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

rustdoc-types

Types for rustdoc's json output

rustler

Safe Rust wrappers for creating Erlang NIF functions

tynm

Returns type names in shorter form

async-once-cell

Async single assignment cells and lazy values

cascade

Dart-like cascade macro for Rust

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…

nonmax

Numeric types that cannot hold maximum values

tlua

Zero-cost high-level wrapper for Tarantool-LuaJIT

iri-string

IRI as string types

aide

A code-first API documentation library

fatality

extension to thiserror::Error

fix-hidden-lifetime-bug

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

dlib

Helper macros for handling manually loading optional system libraries

recursion

cache-aware stack safe recursion

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

iter-read

A Read implementation for iterators over u8 and related types

inout

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

retry

retrying operations that can fail

error-code

Error code

flex-error

Flexible error definitions using macros and traits

indoc

Indented document literals

tryhard

Easily retry futures

thiserror-core

derive(Error)

parsel

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

unwinding

in Rust and for Rust

const-gen

generating (relatively) complex compile-time constants in rust

const-random

compile time random number generation

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

arrow-array

Array abstractions for Apache Arrow

mem_dbg

Traits and associated procedural macros to display recursively the layout and memory usage of a value

st-map

Runtime for a stack-alocated map

safe-transmute

A safeguarded transmute() for Rust

abi_stable

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

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…

tuples

many useful tools related to tuples

rust-fsm

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

psm

Portable Stack Manipulation: stack manipulation and introspection routines

typewit

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

derivative

A set of alternative derive attributes for Rust

conjure-object

Runtime support for generated Conjure objects

fragile

wrapper types for sending non-send values to other threads

tiny-fn

Type erased closures on stack

bit_field

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

k9

rust testing library

mirai-annotations

Macros that provide source code annotations for MIRAI

bounded-static

Defines the ToBoundedStatic and IntoBoundedStatic traits

internal-iterator

Internal iteration equivalent of std::iter::Iterator

implicit-clone

Immutable types and ImplicitClone trait similar to Copy

shaku

Compile Time Dependency Injection for Rust

joinery

A small crate for generically joining iterators with a separator

decorum

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

k8-client

Core Kubernetes metadata traits

tuplex

Rust tuple extension

safelog

Conditionally suppress confidential information from logs

lender

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

float-cmp

Floating point approximate comparison traits

autosurgeon

working with data in automerge documents

async-fn-stream

Lightweight implementation of async-stream without macros

validify

struct validation and modification functionality through the use of derive macros

sugar_path

Sugar functions for manipulating paths

arr_macro

Initialize arrays with ease!

panic-analyzer

an audit tool to scan your crate or workspace searching for potential panic points in your codebase

tstr

Type-level strings

cl-format

Use Common Lisp format in Rust

components-arena

creating complex domain-specific self-referential data structures

pinned-init

facilitate safe pinned initialization

arrow_convert

Convert between nested rust types and Arrow with arrow

ra_ap_stdx

Missing batteries for standard libraries for rust-analyzer

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.

aoc-parse

A little library for parsing your Advent of Code puzzle input

overload

macro to simplify operator overloading

rustrict

profanity filter for Rust

retour

A cross-platform detour library written in Rust

formatx

A macro for formatting non literal strings at runtime

socketpair

Cross-platform socketpair functionality

fixed-hash

Macros to define custom fixed-size hash types

dync

An efficient alternative to dyn Trait for containerized types

o2o

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

nshare

Conversion between n-dimensional types in different Rust crates

with_locals

Function attribute to return references to locals by using CPS

calendrical_calculations

Calendrical calculations in Rust

lazy-static-include

lazy_static_include_bytes and lazy_static_include_str macros to replace include_bytes and include_str macros

hooks

Compile-time, async hooks

speculoos

Fluent test assertions

extend

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

display-error-chain

Formats a standard error and its sources

shopify_function

write Shopify Functions in Rust

devela

A development foundation

as-any

provide the AsAny trait

moveit

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

mirror-mirror

Reflection library for Rust

sealed

Macro for sealing traits and structures

userfaultfd

Rust bindings for the Linux userfaultfd functionality

pin-utils

pinning

fluent-comparisons

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

atc-router

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

doku

A framework for documenting Rust data structures

ufotofu

Abstractions for lazily consuming and producing sequences

funty

Trait generalization over the primitive types

rustversion

Conditional compilation according to rustc compiler version

copyless

Ways to eliminate memcpy calls when using the standard library

trybuild-internals-api

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

data-rw

io buffer write reader

dprint-swc-ext

Functionality to make swc easier to work with

raw-parts

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

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

mitsein

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

more-di

support for dependency injection (DI)

proc-bitfield

expressively declare bitfield-like structs

concat-with

Extend the function of the concat! macro in std

cowstr

Copy-on-Write shared strings

easy-cast

Type conversions which are expected to succeed

andex

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

terrors

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

swipl

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

bool_ext

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

munge

Macro for custom destructuring

rust_info

Extracts the current rust compiler information

devise

devising derives and other procedural macros

lending-iterator

Fully general lending iterators in stable rust: windows_mut!

void

The uninhabited void type for use in statically impossible cases

try_match

Fallible pattern matching with a function-like syntax

defer

excecution of code, inspired by go's defer statement

fvm_shared

Filecoin Virtual Machine shared types and functions

rs-event-emitter

simulate promise implementation for rust

assert_approx_eq

assert approximately equal

one_err

OneErr to rule them all

resiter

Helper crate for handling iterators over result

generativity

Generation of unique invariant lifetimes

tor-error

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

vtable

Helper crate to generate ffi-friendly virtual tables

zoet

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

comfy-bounded-ints

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

checked-rs

encoding validation semantics into the type system

miden-miette

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

wmlua

heterob

conversion between bytes/bits and heterogeneous lists (tuples)

simple-error

error type backed by a string

wiwi

Stuff™

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…

myutil

Rust Util Collections

lazycell

providing a lazily filled Cell struct

gat-lending-iterator

iterators who's items can [mutably] reference the iterator

fmt2io

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

octseq

Abstractions for types representing octet sequences

kind

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

macro-attr-2018

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

enum-display

A macro to derive Display for enums

nunny

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

k8s-openapi-codegen-common

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

atom

A safe abstraction around AtomicPtr

documented

Traits and derive macros for accessing your type's documentation at runtime

sugars

An useful collection of macros to make tasks easier

radiation

Convert Rust type into raw bytes and vice versa

macro-asm-builder

macro-assemblers

auto_enums

allow multiple return types by automatically generated enum

reborrow

Emulate reborrowing for user types

qualifier_attr

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

self-rust-tokenize

Turns instances of Rust structures into a token stream that creates the instance

vitasdk-sys

Raw bindings to vitasdk

globals

Painless global variables in Rust

metastruct

Abstractions for iterating and mapping over struct fields

iter-chunks

Extend Iterator with chunks

gumdrop

Option parser with custom derive support

aerosol

dependency injection for Rust

fallible-streaming-iterator

Fallible streaming iteration

cap-std-ext

Extension APIs for cap-std

smarterr

Smart error handling library

sosecrets-rs

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

TSPL

The Simplest Parser Library

rutie

The tie between Ruby and Rust

psl-types

Common types for the public suffix implementation crates

open-enum

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

semval

Semantic validation

rudi

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

io-streams

Unbuffered and unlocked I/O streams

libc-print

println! and eprintln! macros on libc without stdlib

const-field-offset

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

box_raw_ptr

providing safe wrappers for working with raw pointer. These raw pointers are *const T and *mut T. These wrappers ensure memory safety by encapsulating the raw pointers in safe abstractions…

null-kane

currency crate with the option to add your own currency localization logic

result-like

Option/Result-like monad interface for your own enum

tupletools

functions for tuples

fmt-cmp

Traits and utilities for lexicographically comparing values in their Display representations

model-mapper

Derive macro to map between different types

loga

Combined logging and error handling

entrait

Loosely coupled Rust application design made easy

ungrammar

A DSL for describing concrete syntax trees

macon

builder macro-based generator with its own idioms

reweb3-num

Arbitrary precision, fixed-size signed and unsigned integer types for ethereum, this a fork of bnum crate

nar_dev_utils

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

soa-rs

A Vec-like structure-of-arrays container

many-unzip

multiunzip from itertools but with support for larger than 12-tuples

intern-arc

An interner that deallocates unused values

blanket

macro to derive blanket implementations for your traits

awint_macro_internals

Internal macro utilities for the awint system of crates

culpa

error-handling syntax in Rust

backtrace-error

wrap errors with automatic backtrace capture and print-on-result-unwrap

corlib

A various ideas library

jnix

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

tisel

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

indicator

Abstractions for stream aggregation, we call them Indicator s

rust-quiz

Medium to hard Rust questions with complete explanations

lmml

LMML Music Macro Language

stack_dst

A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)

orx-closure

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

aliri_braid

Improve and strengthen your strings by making them strongly-typed with less boilerplate

carboxyl

functional reactive programming

ice_code

A macro to mark code paths as cold, allowing the common case to be inlined

tokenlock

cell types that decouple permissions from data

coi

Dependency Injection library

quick-error

A macro which makes error types pleasant to write

rst-common

A shortcut to common Rust crates

format-bytes

A macro to format bytestrings

custom_error

Define custom errors without boilerplate using the custom_error! macro

core_extensions

Extensions for core/std library types, and other miscelaneous features

cexpr

A C expression parser and evaluator

scaffolding-core

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

async-iterator

An async version of iterator

scale-typegen

Type Generation for SCALE encoded Rust Types

file_rw

high-performance, memory-mapped file I/O utilities

refined_type

imbuing rules into types and elevating them to more robust types

windows-targets

Import libs for Windows

bash-builtins

implement loadable builtins for bash

naan

A fast, easy, and tasty functional programming prelude