Lib.rs

bitflags

A macro to generate structures which behave like bitflags

thiserror

derive(Error)

anyhow

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

itertools

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

derive_more

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

ordered-float

Wrappers for total ordering on floats

predicates

boolean-valued predicate functions

num

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

once_cell

Single assignment cells and lazy values

darling

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

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

lazy_static

A macro for declaring lazily evaluated statics in Rust

miette

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

bytes

Types and traits for working with bytes

derive_builder

Rust macro to automatically implement the builder pattern for arbitrary structs

human-panic

Panic messages for humans

eyre

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

snafu

An ergonomic error handling library

bon

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

downcast-rs

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

smol_str

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

enumflags2

Enum-based bit flags

dyn-clone

Clone trait that is object-safe

pin-project-lite

A lightweight version of pin-project written with declarative macros

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

similar-asserts

assert_eq! like macros with colorized diff output

tap

Generic extensions for tapping values in Rust

typed-builder

Compile-time type-checked builder derive

macro_rules_attribute

Use declarative macros in attribute or derive position

memoffset

offset_of functionality for Rust structs

ouroboros

Easy, safe self-referential struct generation

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

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…

static_assertions

Compile-time assertions to ensure that invariants are met

compiler_builtins

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

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.

rustlings

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

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

ref-cast

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

nonempty

Correct by construction non-empty vector

beef

More compact Cow

arrayref

Macros to take array references of slices

az

Casts and checked casts

inventory

Typed distributed plugin registration

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

sptr

Strict Provenance Polyfill

decorum

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

more-asserts

Small library providing additional assert_* and debug_assert_* macros

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

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

cfg_aliases

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

rustdoc-types

Types for rustdoc's json output

backon

Make retry like a built-in feature provided by Rust

float-cmp

Floating point approximate comparison traits

nutype

The newtype with guarantees

volatile

wrapper types for raw pointers

safer-ffi

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

flagset

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

cmd_lib

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

opaque-debug

Macro for opaque Debug trait implementation

if_chain

Macro for writing nested if let expressions

constcat

concat! with support for const variables and expressions

assertables

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

replace_with

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

trie-db

Merkle-Patricia Trie generic over key hasher and node encoding

abi_stable

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

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

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

derive-where

Deriving with custom trait bounds

iri-string

IRI as string types

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

unwinding

in Rust and for Rust

async-once-cell

Async single assignment cells and lazy values

dlib

Helper macros for handling manually loading optional system libraries

extism-pdk

Extism Plug-in Development Kit (PDK) for Rust

float-ord

A total ordering for floating-point numbers

stdext

Extensions for the Rust standard library structures

fallible_collections

adds fallible allocation api to std collections

bounded-integer

Bounded integers

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

auto_impl

Automatically implement traits for common smart pointers and closures

bit_field

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

writeable

A more efficient alternative to fmt::Display

fixedstr

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

lazy_format

lazily formatting values for later

typewit

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

color-eyre

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

aws-smithy-types-convert

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

recursion

cache-aware stack safe recursion

fragile

wrapper types for sending non-send values to other threads

pact_consumer

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

by_address

Wrapper for comparing and hashing pointers by address

iter-read

A Read implementation for iterators over u8 and related types

testresult

type for concise and precise test failures

rustler

Safe Rust wrappers for creating Erlang NIF functions

buffered-reader

A super-powered Reader

erasable

Type-erased thin pointers

async-trait

Type erasure for async trait methods

tuples

many useful tools related to tuples

byte-slice-cast

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

fallible-iterator

Fallible iterator traits

field-offset

Safe pointer-to-member implementation

terrors

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

maplit

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

castaway

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

tynm

Returns type names in shorter form

virtue

A sinless derive macro helper

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

const-gen

generating (relatively) complex compile-time constants in rust

fix-hidden-lifetime-bug

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

bounded-collections

Bounded types and their supporting traits

fatality

extension to thiserror::Error

error-code

Error code

rustrict

profanity filter 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…

rustversion

Conditional compilation according to rustc compiler version

retour

A cross-platform detour library written in Rust

oxrdf

providing basic data structures related to RDF

chalk-ir

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

cascade

Dart-like cascade macro for Rust

psm

Portable Stack Manipulation: stack manipulation and introspection routines

st-map

Runtime for a stack-alocated map

shaku

Compile Time Dependency Injection for Rust

loupe

Profiling tool for Rust

safe-transmute

A safeguarded transmute() for Rust

internal-iterator

Internal iteration equivalent of std::iter::Iterator

bounded-vec

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

pyo3-polars

Expression plugins and PyO3 types for polars

pinned-init

facilitate safe pinned initialization

version-sync

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

indoc

Indented document literals

parse-display

Procedural macro to implement Display and FromStr using common settings

tor-error

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

konst

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

mirai-annotations

Macros that provide source code annotations for MIRAI

argp

Derive-based argument parser optimized for code size

lender

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

advent-of-code

Solutions to Advent of Code

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…

anymap3

A safe and convenient store for one value of each type

shopify_function

write Shopify Functions in Rust

error_set

An error set macro that simplifies error management by providing a streamlined method for defining errors and easily converting between them. Inspired by Zig's error set type.

calendrical_calculations

Calendrical calculations in Rust

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

autosurgeon

working with data in automerge documents

conjure-object

Runtime support for generated Conjure objects

moveit

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

nshare

Conversion between n-dimensional types in different Rust crates

log-once

Collection of helper macros for logging some events only once

strck

Checked owned and borrowed strings

tryhard

Easily retry futures

socketpair

Cross-platform socketpair functionality

overload

macro to simplify operator overloading

servo_arc

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

oxc_index

Newtype-style helpers for Vec and usize

bounded-static

Defines the ToBoundedStatic and IntoBoundedStatic traits

o2o

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

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.

tstr

Type-level strings

try_match

Fallible pattern matching with a function-like syntax

libc-print

println! and eprintln! macros on libc without stdlib

formatx

A macro for formatting non literal strings at runtime

capacity_builder

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

k8-client

Core Kubernetes metadata traits

deno_error

Error representation to JavaScript for deno

implicit-clone

Immutable types and ImplicitClone trait similar to Copy

thiserror-no-std

derive(Error)

vtable

Helper crate to generate ffi-friendly virtual tables

retry

retrying operations that can fail

mirror-mirror

Reflection library for Rust

joinery

A small crate for generically joining iterators with a separator

reborrow

Emulate reborrowing for user types

aoc-parse

A little library for parsing your Advent of Code puzzle input

devela

A cohesive development layer

statum

Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation

cast_trait_object

Cast between trait objects using only safe Rust

sealed

Macro for sealing traits and structures

with_locals

Function attribute to return references to locals by using CPS

random-number

Generate random numbers quickly

rc-box

Known unique versions of Rc and Arc

dync

An efficient alternative to dyn Trait for containerized types

concat-with

Extend the function of the concat! macro in std

unleash-yggdrasil

Unleash SDK domain logic extracted into a library to facilitate building your own Unleash SDKs in anything, anywhere

slice_ops

A selection of useful slice operations

timely_bytes

Disjoint mutable byte slices from a common allocation

ra_ap_mbe

Handling of macro_rules macros for rust-analyzer

outref

Out reference

elain

Set a type's minimum alignment with const generics

myutil

Rust Util Collections

flex-error

Flexible error definitions using macros and traits

documented

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

parsel

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

rust-fsm

A framework and a DSL for building finite state machines 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

lazy_errors

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

better_scoped_tls

scoped-tls, but with good error message

data-rw

io buffer write reader

extend

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

macro-attr-2018

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

assert_approx_eq

assert approximately equal

doc-comment

Macro to generate doc comments

soa-rs

A Vec-like structure-of-arrays container

tuplex

Rust tuple extension

i_float

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

display-error-chain

Formats a standard error and its sources

conflate

Merge multiple values into one

safelog

Conditionally suppress confidential information from logs

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.

devise

devising derives and other procedural macros

hax-frontend-exporter-options

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

miden-miette

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

rust_info

Extracts the current rust compiler information

familiar

reserve

fixed-hash

Macros to define custom fixed-size hash types

semval

Semantic validation

open-enum

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

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…

thiserror-core

derive(Error)

lowdash

A Lodash inspired utility library to manipulate array and object

lazycell

providing a lazily filled Cell struct

copyless

Ways to eliminate memcpy calls when using the standard library

macon

builder macro-based generator with its own idioms

egui-probe

Trait and derive macro for exposing value editing in egui

phantom-type

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

autofolder

Single-element folding wrapper

cap-std-ext

Extension APIs for cap-std

sqlx-paginated

A flexible, type-safe SQLx query builder for dynamic web APIs, offering seamless pagination, searching, filtering, and sorting

void

The uninhabited void type for use in statically impossible cases

k8s-openapi-codegen-common

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

const-field-offset

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

stak-native

Optimized primitives of native functions for Stak Scheme

ungrammar

A DSL for describing concrete syntax trees

vector2d

The spoon of 2D vector libraries, intended for simple game development

cl-format

Use Common Lisp format in Rust

zoet

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

dispose

wrapper for values that must be consumed on drop

andex

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

funty

Trait generalization over the primitive types

buildstructor

Macro to derive a builder from a constructor function

xx

A collection of useful Rust macros and small functions

condtype

Choose types at compile-time via boolean constants

delegation

Macro-based delegation for enums and structs

munge

Macro for custom destructuring

fmt2io

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

entrait

Loosely coupled Rust application design made easy

fn_vm

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

TSPL

The Simplest Parser Library

suika_templates

template engine for the suika web stack

exhaust

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

resiter

Helper crate for handling iterators over result

octseq

Abstractions for types representing octet sequences

doku

A framework for documenting Rust data structures

raw-parts

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

mitsein

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

yffi

Bindings for the Yrs native C foreign function interface

sugars

An useful collection of macros to make tasks easier

psl-types

Common types for the public suffix implementation crates

pilgrimage

A Kafka-like message broker in Rust

vitasdk-sys

Raw bindings to vitasdk

iterate-trait

Experiment with methods on IntoIterator

macro-asm-builder

macro-assemblers

refined_type

imbuing rules into types and elevating them to more robust types

qualifier_attr

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

lending-iterator

Fully general lending iterators in stable rust: windows_mut!

bool_ext

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

metastruct

Abstractions for iterating and mapping over struct fields

hermit-sync

Synchronization primitives for kernels

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.

cexpr

A C expression parser and evaluator

nar_dev_utils

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

comfy-bounded-ints

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

aerosol

dependency injection for Rust

blanket

macro to derive blanket implementations for your traits

trybuild-internals-api

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

event-driven-library

Event Driven Message Handling

scale-typegen

Type Generation for SCALE encoded Rust Types

arr_macro

Initialize arrays with ease!

downcast

Trait for downcasting trait objects back to their original types

fmt-cmp

Traits and utilities for lexicographically comparing values in their Display representations

rudi

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

one_err

OneErr to rule them all

more-di

support for dependency injection (DI)

swipl

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

proc-bitfield

expressively declare bitfield-like structs

copy_from_str

An extension trait to copy a string into another string

fauxgen

write your own generators in stable rust

rvstruct

A helper macros implementation for Value Classes in Rust

globals

Painless global variables in Rust

human-errors

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

custom_error

Define custom errors without boilerplate using the custom_error! macro

cumulus-primitives-aura

Core primitives for Aura in Cumulus

smarterr

Smart error handling library

conv2

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

capnp_conv

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

direction

Representations of directions

checked-rs

encoding validation semantics into the type system

relib_host

relib is a framework for reloadable dynamic libraries

nenyr

initial version of the Nenyr parser delivers robust foundational capabilities for interpreting Nenyr syntax. It intelligently processes central, layout, and module contexts, handling complex variable…

culpa

error-handling syntax in Rust

leptos-mview

A concise view macro for Leptos

auto_enums

allow multiple return types by automatically generated enum

btypes

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

option_trait

Helper traits for more generalized options

wmlua

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

tinyvec_macros

Some macros for tiny containers

enum-assoc

Procedural macro to associate constants with enum variants

radiation

Convert Rust type into raw bytes and vice versa

generics

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

model-mapper

Derive macro to map between different types

wiwi

Stuff™

fallible-streaming-iterator

Fallible streaming iteration

scaffolding-core

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

next_tuple

A trait to build and extend tuples

heterob

conversion between bytes/bits and heterogeneous lists (tuples)

text-block-macros

Create a multiline string literal

nunny

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

logkit

Super fast, structured, scalable logging library for Rust

unsafe-fields

unsafe to access or modify fields with safety invariants