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

miette

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

once_cell

Single assignment cells and lazy values

num

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

async-stream

Asynchronous streams using async & await notation

lazy_static

A macro for declaring lazily evaluated statics in Rust

ordered-float

Wrappers for total ordering on floats

derive_builder

Rust macro to automatically implement the builder pattern for arbitrary structs

validator

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

bytes

Types and traits for working with bytes

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

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

snafu

An ergonomic error handling library

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

smol_str

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

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

memoffset

offset_of functionality for Rust structs

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

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

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.

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…

bitfield

macros to generate bitfield-like struct

pin-project

safe and ergonomic pin-projection

backon

Make retry like a built-in feature provided by Rust

float-cmp

Floating point approximate comparison traits

arrayref

Macros to take array references of slices

extendr-api

Safe and user friendly bindings to the R programming language

beef

More compact Cow

more-asserts

Small library providing additional assert_* and debug_assert_* macros

ref-cast

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

tap

Generic extensions for tapping values in Rust

decorum

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

nonempty

Correct by construction non-empty vector

error-stack

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

new_debug_unreachable

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

cmd_lib

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

amplify

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

az

Casts and checked casts

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

if_chain

Macro for writing nested if let expressions

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

trie-db

Merkle-Patricia Trie generic over key hasher and node encoding

enum-ordinalize

enables enums to not only obtain the ordinal values of their variants but also allows for the construction of enums from an ordinal value

rustdoc-types

Types for rustdoc's json output

nutype

The newtype with guarantees

assertables

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

index_vec

Newtype-style helpers for Vec and usize

flagset

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

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

polonius-the-crab

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

orchestra

Generate an orchestra of subsystems from a single struct

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…

replace_with

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

sptr

Strict Provenance Polyfill

inventory

Typed distributed plugin registration

abi_stable

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

opaque-debug

Macro for opaque Debug trait implementation

jaq-std

Standard library for jaq

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

derive-where

Deriving with custom trait bounds

async-once-cell

Async single assignment cells and lazy values

extism-pdk

Extism Plug-in Development Kit (PDK) for Rust

unwinding

in Rust and for Rust

float-ord

A total ordering for floating-point numbers

auto_impl

Automatically implement traits for common smart pointers and closures

volatile

wrapper types for raw pointers

parse-display

Procedural macro to implement Display and FromStr using common settings

writeable

A more efficient alternative to fmt::Display

async-trait

Type erasure for async trait methods

fixedstr

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

fallible-iterator

Fallible iterator traits

byte-slice-cast

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

fallible_collections

adds fallible allocation api to std collections

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

testresult

type for concise and precise test failures

recursion

cache-aware stack safe recursion

bounded-integer

Bounded integers

tuples

many useful tools related to tuples

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

terrors

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

static_init

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

field-offset

Safe pointer-to-member implementation

maplit

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

retry

retrying operations that can fail

rustler

Safe Rust wrappers for creating Erlang NIF functions

virtue

A sinless derive macro helper

by_address

Wrapper for comparing and hashing pointers by address

bounded-collections

Bounded types and their supporting traits

tynm

Returns type names in shorter form

cascade

Dart-like cascade macro for Rust

typewit

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

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

fatality

extension to thiserror::Error

iri-string

IRI as string types

internal-iterator

Internal iteration equivalent of std::iter::Iterator

tryhard

Easily retry futures

const-gen

generating (relatively) complex compile-time constants 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…

indoc

Indented document literals

retour

A cross-platform detour library written in Rust

chalk-ir

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

psm

Portable Stack Manipulation: stack manipulation and introspection routines

pinned-init

facilitate safe pinned initialization

bounded-vec

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

log-once

Collection of helper macros for logging some events only once

thiserror-no-std

derive(Error)

mirai-annotations

Macros that provide source code annotations for MIRAI

flex-error

Flexible error definitions using macros and traits

safe-transmute

A safeguarded transmute() for Rust

pyo3-polars

Expression plugins and PyO3 types for polars

tor-error

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

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

bounded-static

Defines the ToBoundedStatic and IntoBoundedStatic traits

rustrict

profanity filter for Rust

st-map

Runtime for a stack-alocated map

shaku

Compile Time Dependency Injection for Rust

from

A procedural macro that generates custom parsing and validation code

fragile

wrapper types for sending non-send values to other threads

arr_macro

Initialize arrays with ease!

tuplex

Rust tuple extension

strck

Checked owned and borrowed strings

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…

lender

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

elain

Set a type's minimum alignment with const generics

autosurgeon

working with data in automerge documents

implicit-clone

Immutable types and ImplicitClone trait similar to Copy

shopify_function

write Shopify Functions in Rust

moveit

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

nshare

Conversion between n-dimensional types in different Rust crates

calendrical_calculations

Calendrical calculations in Rust

lazycell

providing a lazily filled Cell struct

k8-client

Core Kubernetes metadata traits

bit_field

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

rust-fsm

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

socketpair

Cross-platform socketpair functionality

tstr

Type-level strings

ra_ap_mbe

Handling of macro_rules macros for rust-analyzer

joinery

A small crate for generically joining iterators with a separator

anymap3

A safe and convenient store for one value of each type

display-error-chain

Formats a standard error and its sources

conjure-object

Runtime support for generated Conjure objects

try_match

Fallible pattern matching with a function-like syntax

o2o

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

servo_arc

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

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.

refined_type

imbuing rules into types and elevating them to more robust types

advent-of-code

Solutions to Advent of Code

overload

macro to simplify operator overloading

parsel

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

cl-format

Use Common Lisp format in Rust

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

thiserror-core

derive(Error)

void

The uninhabited void type for use in statically impossible cases

miden-miette

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

mirror-mirror

Reflection library for Rust

with_locals

Function attribute to return references to locals by using CPS

reborrow

Emulate reborrowing for user types

sealed

Macro for sealing traits and structures

octseq

Abstractions for types representing octet sequences

as-any

provide the AsAny trait

better_scoped_tls

scoped-tls, but with good error message

version-sync

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

extend

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

funty

Trait generalization over the primitive types

macon

builder macro-based generator with its own idioms

documented

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

cap-std-ext

Extension APIs for cap-std

myutil

Rust Util Collections

culpa

error-handling syntax in Rust

libc-print

println! and eprintln! macros on libc without stdlib

timely_bytes

Disjoint mutable byte slices from a common allocation

lowdash

A Lodash inspired utility library to manipulate array and object

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

hax-frontend-exporter-options

The options the hax-frontend-exporter crate is sensible to

tor-basic-utils

General helpers used by Tor

mitsein

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

formatx

A macro for formatting non literal strings at runtime

rustversion

Conditional compilation according to rustc compiler version

buildstructor

Macro to derive a builder from a constructor function

data-rw

io buffer write reader

generics

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

fn_vm

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

doc-comment

Macro to generate doc comments

qualifier_attr

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

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.

copyless

Ways to eliminate memcpy calls when using the standard library

fixed-hash

Macros to define custom fixed-size hash types

bool_ext

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

conflate

Merge multiple values into one

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…

devise

devising derives and other procedural macros

dync

An efficient alternative to dyn Trait for containerized types

condtype

Choose types at compile-time via boolean constants

doku

A framework for documenting Rust data structures

iterate-trait

Experiment with methods on IntoIterator

rust_info

Extracts the current rust compiler information

dispose

wrapper for values that must be consumed on drop

open-enum

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

i_float

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

deno_error

Error representation to JavaScript for deno

oxc_index

Newtype-style helpers for Vec and usize

const-field-offset

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

sugars

An useful collection of macros to make tasks easier

autofolder

Single-element folding wrapper

fmt2io

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

exhaust

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

easy-cast

Type conversions which are expected to succeed

phantom-type

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

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

ungrammar

A DSL for describing concrete syntax trees

swipl

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

lazy_errors

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

wiwi

Stuff™

andex

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

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

munge

Macro for custom destructuring

semval

Semantic validation

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.

heterob

conversion between bytes/bits and heterogeneous lists (tuples)

psl-types

Common types for the public suffix implementation crates

nunny

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

copy_from_str

An extension trait to copy a string into another string

lending-iterator

Fully general lending iterators in stable rust: windows_mut!

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)

wmlua

blanket

macro to derive blanket implementations for your traits

more-di

support for dependency injection (DI)

TSPL

The Simplest Parser Library

k8s-openapi-codegen-common

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

custom_error

Define custom errors without boilerplate using the custom_error! macro

macro-asm-builder

macro-assemblers

smarterr

Smart error handling library

one_err

OneErr to rule them all

scaffolding-core

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

vitasdk-sys

Raw bindings to vitasdk

globals

Painless global variables in Rust

aerosol

dependency injection for Rust

heart

Hypermedia-based web development of the 1990 future!

allow

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

sosecrets-rs

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

enum-display

A macro to derive Display for enums

leptos-mview

A concise view macro for Leptos

enum-ptr

Ergonomic tagged pointer

metastruct

Abstractions for iterating and mapping over struct fields

fallible-streaming-iterator

Fallible streaming iteration

nar_dev_utils

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

radiation

Convert Rust type into raw bytes and vice versa

unsafe-fields

unsafe to access or modify fields with safety invariants

defer

excecution of code, inspired by go's defer statement

event-driven-library

Event Driven Message Handling

fmt-cmp

Traits and utilities for lexicographically comparing values in their Display representations

funcmap

Derivable functorial mappings for Rust

generativity

Generation of unique invariant lifetimes

btypes

Better types (BTypes) for when you dislike normal types, I guess

downcast

Trait for downcasting trait objects back to their original types

scale-typegen

Type Generation for SCALE encoded Rust 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

hermit-sync

Synchronization primitives for kernels

collate

Traits and a data structure to support collation and bisection

cowstr

Copy-on-Write shared strings

rudi

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

auto_enums

allow multiple return types by automatically generated enum

expect-exit

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

sabry

Syntactically Awesome But RustY - crate that brings SCSS/SASS into rust

fauxgen

write your own generators in stable rust

text-block-macros

Create a multiline string literal

try-specialize

Zero-cost specialization in generic context on stable Rust

ranged_integers

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

macro-attr-2018

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

iced_anim

creating animations in Iced

checked-rs

encoding validation semantics into the type system

byondapi

Idiomatic Rust bindings for BYONDAPI

fomat-macros

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

kind

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

cexpr

A C expression parser and evaluator

enum-assoc

Procedural macro to associate constants with enum variants

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

lazy-static-include

lazy_static_include_bytes and lazy_static_include_str macros to replace include_bytes and include_str macros

hlist2

Compile-time heterogeneous list implementation

direction

Representations of directions

vtable

Helper crate to generate ffi-friendly virtual tables

anyinput

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

columnation

Unsafe columnar containers for native Rust 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'

crustal

generating C/C++ code

proc-bitfield

expressively declare bitfield-like structs

mownstr

Maybe Owned String

endian-writer

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

autofloat

Pure Rust library for efficient automatic differentiation

is_empty

Easily check if the struct is empty

orx-closure

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