-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
error-chain
Yet another error boilerplate library
-
synstructure
Helper methods and macros for custom derives
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
quick-error
A macro which makes error types pleasant to write
-
once_cell
Single assignment cells and lazy static values without macros
-
scopeguard
A 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!,defer_on_success!as shorthands for guards with one of the implemented strategies -
ordered-float
Wrappers for total ordering on floats
-
frunk
Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
nodrop
A wrapper type to inhibit drop (destructor). Use std::mem::ManuallyDrop instead!
-
lazycell
A library providing a lazily filled Cell struct
-
owning_ref
A library for creating references that carry their owner with them
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
rental
A macro to generate safe self-referential structs, plus premade types for common use cases
-
indoc
Indented document literals
-
trackable
This library provides a way to track objects manually as an alternative to mechanisms like backtracing
-
derivative
A set of alternative
deriveattributes for Rust -
derive_builder_core
Internal helper library for the derive_builder crate
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
lambda_runtime_errors
Rust runtime errors for AWS Lambda
-
bitfield
This crate provides macros to generate bitfield-like struct
-
rust_info
Extracts the current rust compiler information
-
simple-error
A simple error type backed by a string
-
hex-literal
Procedural macro for converting hexadecimal string to byte array at compile time
-
noisy_float
Contains floating point types that panic if they are set to an illegal value, such as NaN
-
lazy-static-include
This crate provides
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
assert_matches
Asserts that a value matches a pattern
-
annotate-snippets
Library for building code annotations
-
abscissa
Application microframework with support for command-line option parsing, configuration, error handling, logging, and shell interactions
-
frunk_proc_macro_helpers
Common internal functions for frunk’s proc macros
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
opaque_typedef
Supports defining opaque typedefs
-
frunk_proc_macros
Proc macros for Frunk
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
cast
Ergonomic, checked cast functions for primitive types
-
lambda_runtime_errors_derive
Rust runtime errors derive for AWS Lambda
-
reexport-proc-macro
Re-export a procedural macro
-
auto_enums
A library for to allow multiple return types by automatically generated enum
-
interpolate_idents
Useable macro identifier concatenation plugin
-
mbox
malloc-based box. Supports wrapping pointers or null-terminated strings returned from malloc as a Rust type, which will be free’d on drop
-
if_chain
Macro for writing nested
if letexpressions -
elastic_types_derive_internals
Codegen internals for elastic_types
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
derive_utils
A procedural macro helper for easily writing custom derives for enums
-
scroll_derive
A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate
-
downcast
Trait for downcasting trait objects back to their original types
-
abi_stable_derive_lib
Implementation detail of abi_stable
-
swc_macros_common
Common utilities for swc macros
-
throw
Efficiently add statically-calculated stack traces to errors
-
chainerror
Make chaining errors easy
-
crates-io-cli
Interact with crates.io from the command-line
-
auto_enums_core
This library provides an attribute macro for to allow multiple return types by automatically generated enum
-
refl
Provides a
reflencoding which you can use to provide a proof witness that one type is equivalent (identical) to another type. You can use this to encode a subset of what GADTs allow you to in Haskell -
take_mut
Take a T from a &mut T temporarily
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
auto_enums_derive
This library provides an attribute macro like a wrapper of
#[derive], implementing the supported traits and passing unsupported traits to#[derive] -
file
For Rust 1.25 and older. 1-liner convenience functions for reading and writing files
-
enum_derive
This crate provides macros for deriving additional functionality for enums
-
simple-logging
A simple logger for the log facade
-
cstr
Macro for building static CStr reference
-
coercible_errors
Zero-cost error handling for generic traits
-
spaces
Set/space primitives for defining machine learning problems
-
problem
Error handling for command line applications or prototypes
-
cex
Combinators of EnumX, for error-handling
-
iterslide
A “sliding window” iterator
-
snafu
An ergonomic error handling library
-
reduce
Fold an iterator without an initial value
-
err-derive
Derive macro for
std::error::Error -
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
py-comp
A macro implementing a Python-like generator expression
-
custom_derive
(Note: superseded by
macro-attr) This crate provides a macro that enables the use of custom derive attributes -
mode
A behavioral state machine library written in Rust
-
quick-error2
A macro which makes error types pleasant to write
-
enum_kind
Easily manage values related to enum
-
newtype_derive
This crate provides macros for deriving common traits for newtype structures
-
incomplete
Provides incomplete!(), a compile-time checked version of unimplemented!()
-
current
A library for setting current values for stack scope, such as application structure
-
filters
Build filters/predicates with the builder pattern
-
safe-transmute
A safeguarded transmute() for Rust
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
enumx
Structural enum implemented in enum exchange
-
enum_stream_codegen
A parser generator. This package handles code generation for the
enum_streammacro.” -
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
error_def
A Rust syntax extension for generating error-handling boilerplate code
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
string_enum
String based enum
-
libffi-sys
Raw Rust bindings for libffi
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
enum-unitary
Trait and macro for unitary enums
-
failchain
Ergonomic companion library for failure
-
proc_macro_roids
Traits and functions to make writing proc macros more ergonomic
-
derive_deref
Adds
#[derive(Deref)]and#[derive(DerefMut)] -
enumflags
Bitflags
-
autodiff
An automatic differentiation library
-
morphism
A structure for suspended closure composition in Rust
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
kaguya_rs
Functional Programming tools and ADTs
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
diff-enum
A macro library to help defining enum variants by their differences
-
single
Provides the Single trait for extracting the element from a single-element iterator
-
pin-project
An attribute that creates a projection struct covering all the fields
-
predicates-core
An API for boolean-valued predicate functions
-
structview
Viewing binary data as high-level data structures, safely
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
static_assert_macro
Library implementation of so-called
static_assert -
enumflags2
Enum-based bit flags
-
iter-python
Python generator expressions and ‘list’ comprehensions
-
build-deps
Rust build-script dependencies generator for data/IDL files
-
bitmask
A bitmask generator for enum scoped bit flags
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
join_to_string
Join a list of items to string/buffer
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
peeking_take_while
Like
Iterator::take_while, but calls the predicate on a peeked value. This allows you to useIterator::by_refandIterator::take_whiletogether, and still get the first value for which thetake_whilepredicate returned false after dropping theby_ref. -
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
field_types
Some derive macros for deriving enums, corresponding to the fields of structs
-
sliding_windows
a non-copying implementation of a sliding windows iterator adaptor
-
parse_cfg
Parse Rust’s
cfg(not(any(target)))attribute syntax -
shrinkwraprs
Auto-derive for Rust conversion traits – make working with newtypes a breeze
-
enumset_derive
An internal helper crate for enumset
-
resiter
Helper crate for handling iterators over result
-
lazy_format
A utility crate for lazily formatting values for later
-
commandspec
Rust macro to build std::process::Command objects with shell syntax. Uses macro_rules! and works on stable.
-
tylift
Lift enum variants to the type-level
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
macro-attr
This crate provides the
macro_attr!macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derivecrate. -
join-lazy-fmt
Lazy
separator.join(iterable)method andlazy_format!for Rust -
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
vlog
Macros to do stdout / stderr logs based on verbosity level
-
iter-comprehensions
A library for iterator comprehensions
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
ifmt
Inline expression interpolation for Rust
-
cute
A macro for Python-esque comprehensions
-
newtype_array
A macro to help implementing the standard derived traits on newtype arrays
-
defmac
A macro to define lambda-like macros inline
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
getters-by-type
Derive macro for adding a getter method for each type in the struct
-
precog_iter
An iterator adapter that returns the equivalent of
(iter.next(), iter.peek()) -
parity-send-wrapper
This Rust library 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. You also have to make sure that the wrapper is dropped from within the original thread. If any of these constraints is violated, a panic occurs. Forked from https://github.com/thk1/send_wrapper because it was unmaintained
-
named-block
Macro implementing early-exit-from-any-block
-
phantom-enum
A simple macro library for creating phantom enums
-
structview_derive
Custom derive for structview’s View trait
-
enum-iterator-derive
Procedural macro to iterate over the variants of a field-less enum
-
parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
macro_machine
State machine generator using macros
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
iter-read
A Read implementation for iterators over u8 and related types
-
copy_from_str
An extension trait to copy a string into another string
-
extension-trait
Macro to declare extension traits
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
boolinator
Provides the Boolinator trait, which lets you use Option and Result-style combinators with bools
-
enum-iterator
Tools to iterate over the variants of a field-less enum
-
vectorize_struct
vectorize_struct adds an procedural macro attribute that makes it possible to iterate over Trait Objects of every field of a Struct that implements a specific trait
-
const_fn
An attribute for easy generation of a const function with conditional compilations
-
error-rules
Error handling without pain
-
mdo
Monadic do notation for rust using macro and duck typing
-
jit_macros
JIT Macros
-
const-if
This crate adds if-else expression into your constant functions
-
threadbound
Make any value Sync but only available on its original thread
-
kinder
Kinder is a small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
unborrow
Macro for calling a &mut self method with transient &-borrows of self in the parameters
-
trace-error
Extensions to Rust’s error system to automatically include backtraces
-
cfor
A macro that gives Rust a C-style for loop, with initialisation, condition and step. This correctly handles control-flow like continue and break.
-
error-type
Provides a macro for constructing unifying error types
-
tilde
Using ~ to provide syntax sugar for Rust
-
unchecked_unwrap
Adds an unchecked version of
unwrap()andexpect()to Option and Result -
numeric_literals
Easily cope with numeric literals in generic Rust code
-
init_with
Helper trait to initilize an array with a function
-
lazy-pool
Experimental lazy object pool
-
str-macro
The str!() macro, similar to vec![] but for strings
-
fragile
Provides wrapper types for sending non-send values to other threads
-
const-random
Provides compile time random number generation
-
send_wrapper
This Rust library 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. You also have to make sure that the wrapper is dropped from within the original thread. If any of these constraints is violated, a panic occurs.
-
shippai
failure in other languages
-
cryo
Extend the lifetime of a reference. Safely.
-
iota-rs
A rust macro for other Go refuges who miss const blocks and iota
-
function_group
A macro to hack in function overloading to rust
-
vector2math
Traits for doing 2D vector geometry operations using standard types
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
error-chain-mini
error-chain for minimalist
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
ngram
Iterator adaptors for n-grams and k-skip-n-grams
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
type-uuid
Safe, stable IDs for Rust types
-
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
concat-string
Provides macros for concatenating string slices into owned strings
-
kwarg_macros
Keyword argument plugin
-
iterator-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, FusedIterator, Extend)] for enums
-
derive-error
Derive macro for Error using macros 1.1
-
mitochondria
Mitochondria is the powerhouse of the
Cell -
nes
New Error System for rust
-
r-rust
Useful tools and macros for research (WIP). Currently, a microbench probe is implemented
-
with-macro
Syntactic sugar for calling methods
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
inner
The inner! macro descends into an enum variant. It’s more flexible than try!() and unwrap(), and it works with your enum, too!
-
boow
Borrow Or oWnedsmart pointer. Alternative to Cow. -
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
singleton-stepanov
It isn’t meant to be used by itself, but as template for your our types. Attempt to do Efficient Programming with Components: Lecture 2 Part 1, Efficient Programming with Components: Lecture 2 Part 2 and Efficient Programming with Components: Lecture 3 Part 1 from C++ to Ruts. [1] https://www.youtube.com/watch?v=FUMPsmKnKv8 [2] https://www.youtube.com/watch?v=B5yiLvaxPS4 [3] https://www.youtube.com/watch?v=sp_IBYVqMeQ
-
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
enum_traits_macros
Procedural macros that adds functionality to enums by deriving traits from the crate
enum_traits -
rev_slice
A newtype for operating on a reversed view of a slice
-
io-enum
#[derive(Read, BufRead, Write, Seek)] for enums
-
size_hint
A very simple library to provide a size_hint for an iterator which does not provide it’s own
-
assert-impl
Macro for static assert types implement a trait or not
-
error-context
Methods and types that help with adding additional context information to error types
-
bidir_iter
Bidirectional iterators
-
tyname
Retrieve type names during program execution on stable Rust
-
cbox
C pointer boxing, for when working with ffi
-
mysql_enum
Convert between Rust enum and MySQL enum
-
drop_bomb
A runtime guard for implementing linear types
-
drop_guard
The drop_guard crate enables you to implement the Drop trait on any type. So you can run a closure on any value running out of scope
-
pathsep
a small macro to enable easy path construction in other macro calls
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
pinpoint
Crate for pinned references
-
progress-streams
Progress callbacks for types which implement Read/Write
-
compile_msg
A plugin for emitting errors, warnings and notes to the developer at compile time
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
hypospray
Lightweight dependency injection library
-
str-concat
Concatenate two adjacent string slices
-
num_alias
simple macros to declare ‘type checked’ aliases for integers and floats
-
tilde_derive
Using ~ to provide syntax sugar for Rust
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
shawshank
An efficient, generic internment structure
-
grange
create range numbers macro
-
scoped
Run deferred closures at success, failure, or exit of a scope. Also supports cancelling them
-
powerset-enum
A poor man’s anonymous enum
-
sconcat
String concatenation
-
lazyonce
Store “immutable” cell that computes its value once, when it’s first accessed. Allows lazy initialization as an implementation detail, without need to expose any mutable methods.
-
enum_macro
Useful macro for enum
-
closet
CLOSure-Enhancing Toolbox (CLOSET) provides some questionably-useful macro utilities for closures, including clone_army!, which reduces boilerplate for clone-capturing closures, and vindaloo!, which does automatic currying
-
aspect-weave
An Aspect Toolkit for Rust
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
snaptest
Dead simple snapshot testing
-
tyenum
Attribute macro for type enums
-
convute
Conversion between types with overlapping valid bit patterns and arrays, vecs and slices of those values
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively