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

once_cell

Single assignment cells and lazy values

ordered-float

Wrappers for total ordering on floats

num

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

predicates

boolean-valued predicate functions

derive_builder

Rust macro to automatically implement the builder pattern for arbitrary structs

lazy_static

A macro for declaring lazily evaluated statics in Rust

async-stream

Asynchronous streams using async & await notation

num_enum

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

miette

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

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

snafu

An ergonomic error handling library

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

similar-asserts

assert_eq! like macros with colorized diff output

frunk

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

approx

Approximate floating point equality comparisons and assertions

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!

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)

self_cell

Safe-to-use proc-macro-free self-referential structs in stable Rust

macro_rules_attribute

Use declarative macros in attribute or derive position

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…

compiler_builtins

Compiler intrinsics used by the Rust compiler. Also available for other targets if necessary!

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

ref-cast

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

pin-project

safe and ergonomic pin-projection

az

Casts and checked casts

arrayref

Macros to take array references of slices

float-cmp

Floating point approximate comparison traits

nonempty

Correct by construction non-empty vector

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

tap

Generic extensions for tapping values in Rust

sptr

Strict Provenance Polyfill

inventory

Typed distributed plugin registration

error-stack

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

cmd_lib

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

decorum

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

amplify

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

cfg_aliases

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

castaway

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

new_debug_unreachable

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

if_chain

Macro for writing nested if let expressions

rustdoc-types

Types for rustdoc's json output

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

jaq-std

Standard library for jaq

nutype

The newtype with guarantees

flagset

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

backon

Make retry like a built-in feature provided by Rust

safer-ffi

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

polonius-the-crab

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

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

assertables

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

pact_consumer

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

opaque-debug

Macro for opaque Debug trait implementation

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

abi_stable

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

index_vec

Newtype-style helpers for Vec and usize

constcat

concat! with support for const variables and expressions

dlib

Helper macros for handling manually loading optional system libraries

volatile

wrapper types for raw pointers

iri-string

IRI as string types

async-once-cell

Async single assignment cells and lazy values

derive-where

Deriving with custom trait bounds

fallible_collections

adds fallible allocation api to std collections

float-ord

A total ordering for floating-point numbers

extism-pdk

Extism Plug-in Development Kit (PDK) for Rust

stdext

Extensions for the Rust standard library structures

unwinding

in Rust and for Rust

auto_impl

Automatically implement traits for common smart pointers and closures

typewit

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

lazy_format

lazily formatting values for later

fixedstr

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

buffered-reader

A super-powered Reader

writeable

A more efficient alternative to fmt::Display

aws-smithy-types-convert

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

color-eyre

An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors

bounded-integer

Bounded integers

static_init

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

recursion

cache-aware stack safe recursion

by_address

Wrapper for comparing and hashing pointers by address

fallible-iterator

Fallible iterator traits

educe

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

testresult

type for concise and precise test failures

iter-read

A Read implementation for iterators over u8 and related types

terrors

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

tuples

many useful tools related to tuples

parse-display

Procedural macro to implement Display and FromStr using common settings

async-trait

Type erasure for async trait methods

field-offset

Safe pointer-to-member implementation

virtue

A sinless derive macro helper

rustler

Safe Rust wrappers for creating Erlang NIF functions

byte-slice-cast

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

bounded-collections

Bounded types and their supporting traits

tynm

Returns type names in shorter form

maplit

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

inout

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

easy-cast

Type conversions which are expected to succeed

fix-hidden-lifetime-bug

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

const-gen

generating (relatively) complex compile-time constants in rust

fatality

extension to thiserror::Error

internal-iterator

Internal iteration equivalent of std::iter::Iterator

cascade

Dart-like cascade macro for 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…

konst

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

tryhard

Easily retry futures

retour

A cross-platform detour library written in Rust

indoc

Indented document literals

pinned-init

facilitate safe pinned initialization

fragile

wrapper types for sending non-send values to other threads

psm

Portable Stack Manipulation: stack manipulation and introspection routines

log-once

Collection of helper macros for logging some events only once

bounded-vec

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

chalk-ir

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

thiserror-no-std

derive(Error)

safe-transmute

A safeguarded transmute() for Rust

pyo3-polars

Expression plugins and PyO3 types for polars

mirai-annotations

Macros that provide source code annotations for MIRAI

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

rustrict

profanity filter for Rust

argp

Derive-based argument parser optimized for code size

shaku

Compile Time Dependency Injection for Rust

retry

retrying operations that can fail

bounded-static

Defines the ToBoundedStatic and IntoBoundedStatic traits

advent-of-code

Solutions to Advent of Code

st-map

Runtime for a stack-alocated map

safelog

Conditionally suppress confidential information from logs

arr_macro

Initialize arrays with ease!

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

strck

Checked owned and borrowed strings

shopify_function

write Shopify Functions in Rust

moveit

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

calendrical_calculations

Calendrical calculations in Rust

lending-iterator

Fully general lending iterators in stable rust: windows_mut!

autosurgeon

working with data in automerge documents

try_match

Fallible pattern matching with a function-like syntax

nshare

Conversion between n-dimensional types in different Rust crates

implicit-clone

Immutable types and ImplicitClone trait similar to Copy

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.

bit_field

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

tuplex

Rust tuple extension

core_extensions

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

k8-client

Core Kubernetes metadata traits

anymap3

A safe and convenient store for one value of each type

socketpair

Cross-platform socketpair functionality

servo_arc

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

o2o

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

vtable

Helper crate to generate ffi-friendly virtual tables

conjure-object

Runtime support for generated Conjure objects

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

version-sync

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

overload

macro to simplify operator overloading

aargvark

Self-similar argument parsing

capacity_builder

Builders where the code to calculate the capacity is the same as the code to write what's being built

mirror-mirror

Reflection library for Rust

ra_ap_mbe

Handling of macro_rules macros for rust-analyzer

fluent-comparisons

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

rust-fsm

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

lowdash

A Lodash inspired utility library to manipulate array and object

parsel

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

aoc-parse

A little library for parsing your Advent of Code puzzle input

reborrow

Emulate reborrowing for user types

cl-format

Use Common Lisp format in Rust

display-error-chain

Formats a standard error and its sources

random-number

Generate random numbers quickly

concat-with

Extend the function of the concat! macro in std

flex-error

Flexible error definitions using macros and traits

lazycell

providing a lazily filled Cell struct

cast_trait_object

Cast between trait objects using only safe Rust

macon

builder macro-based generator with its own idioms

documented

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

elain

Set a type's minimum alignment with const generics

lazy_errors

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

sealed

Macro for sealing traits and structures

void

The uninhabited void type for use in statically impossible cases

timely_bytes

Disjoint mutable byte slices from a common allocation

funty

Trait generalization over the primitive types

oxc_index

Newtype-style helpers for Vec and usize

octseq

Abstractions for types representing octet sequences

libc-print

println! and eprintln! macros on libc without stdlib

myutil

Rust Util Collections

cap-std-ext

Extension APIs for cap-std

conflate

Merge multiple values into one

formatx

A macro for formatting non literal strings at runtime

miden-miette

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

tor-error

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

extend

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

zoet

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

refined_type

imbuing rules into types and elevating them to more robust types

thiserror-core

derive(Error)

rustversion

Conditional compilation according to rustc compiler version

better_scoped_tls

scoped-tls, but with good error message

data-rw

io buffer write reader

mitsein

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

semval

Semantic validation

iterate-trait

Experiment with methods on IntoIterator

with_locals

Function attribute to return references to locals by using CPS

deno_error

Error representation to JavaScript for deno

fn_vm

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

fixed-hash

Macros to define custom fixed-size hash types

copyless

Ways to eliminate memcpy calls when using the standard library

bool_ext

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

doc-comment

Macro to generate doc comments

generics

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

devise

devising derives and other procedural macros

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…

condtype

Choose types at compile-time via boolean constants

k8s-openapi-codegen-common

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

open-enum

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

enum-ptr

Ergonomic tagged pointer

exhaust

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

i_float

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

buildstructor

Macro to derive a builder from a constructor function

dync

An efficient alternative to dyn Trait for containerized types

munge

Macro for custom destructuring

autofolder

Single-element folding wrapper

const-field-offset

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

ungrammar

A DSL for describing concrete syntax trees

dispose

wrapper for values that must be consumed on drop

swipl

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

rust_info

Extracts the current rust compiler information

andex

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

xx

A collection of useful Rust macros and small functions

phantom-type

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

qualifier_attr

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

fmt2io

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

sugars

An useful collection of macros to make tasks easier

culpa

error-handling syntax in Rust

entrait

Loosely coupled Rust application design made easy

TSPL

The Simplest Parser Library

resiter

Helper crate for handling iterators over result

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.

nunny

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

psl-types

Common types for the public suffix implementation crates

raw-parts

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

btypes

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

blanket

macro to derive blanket implementations for your traits

vitasdk-sys

Raw bindings to vitasdk

radiation

Convert Rust type into raw bytes and vice versa

custom_error

Define custom errors without boilerplate using the custom_error! macro

macro-attr-2018

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

comfy-bounded-ints

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

macro-asm-builder

macro-assemblers

egui-probe

Trait and derive macro for exposing value editing in egui

metastruct

Abstractions for iterating and mapping over struct fields

pandora-interpreter

A command-line tool to run pandora language

doku

A framework for documenting Rust data structures

trybuild-internals-api

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

heart

Hypermedia-based web development of the 1990 future!

aerosol

dependency injection for Rust

soa-rs

A Vec-like structure-of-arrays container

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.

fallible-streaming-iterator

Fallible streaming iteration

more-di

support for dependency injection (DI)

nar_dev_utils

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

one_err

OneErr to rule them all

hermit-sync

Synchronization primitives for kernels

leptos-mview

A concise view macro for Leptos

globals

Painless global variables in Rust

stak-r7rs

Stak Scheme primitives for R7RS

enum-display

A macro to derive Display for enums

capnp_conv

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

wmlua

moddef

Macro for convenient module declaration. Each module can be put in a group, and visibility can be applied to the whole group with ease.

event-driven-library

Event Driven Message Handling

fmt-cmp

Traits and utilities for lexicographically comparing values in their Display representations

defer

excecution of code, inspired by go's defer statement

downcast

Trait for downcasting trait objects back to their original types

scale-typegen

Type Generation for SCALE encoded Rust Types

allow

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

tinyvec_macros

Some macros for tiny containers

generativity

Generation of unique invariant lifetimes

autofloat

Pure Rust library for efficient automatic differentiation

checked-rs

encoding validation semantics into the type system

cexpr

A C expression parser and evaluator

copy_from_str

An extension trait to copy a string into another string

rudi

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

auto_enums

allow multiple return types by automatically generated enum

human-errors

An error library focused on providing your users with relevant advice for any problem

fauxgen

write your own generators in stable rust

smarterr

Smart error handling library

heterob

conversion between bytes/bits and heterogeneous lists (tuples)

proc-bitfield

expressively declare bitfield-like structs

sosecrets-rs

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

tstr

Type-level strings

slice_ops

A selection of useful slice operations

strong-type

Procedural macros for naming and strong-typing pritimives and strings

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

assert_approx_eq

assert approximately equal

shape

A decidable static shape system for JSON-like data

text-block-macros

Create a multiline string literal

cowstr

Copy-on-Write shared strings

wiwi

Stuff™

dylint_linting

writing Dylint libraries

hlist2

Compile-time heterogeneous list implementation

scaffolding-core

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

direction

Representations of directions

validify

struct validation and modification functionality through the use of derive macros

synonym

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

windows-targets

Import libs for Windows

endian-writer

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

byondapi

Idiomatic Rust bindings for BYONDAPI

self-rust-tokenize

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

columnation

Unsafe columnar containers for native Rust types

unsafe-fields

unsafe to access or modify fields with safety invariants

cove

Casts Of Varying Elegance (COVE): extension traits for casting numerical types

mownstr

Maybe Owned String

lazy-static-include

lazy_static_include_bytes and lazy_static_include_str macros to replace include_bytes and include_str macros