-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
synstructure
Helper methods and macros for custom derives
-
once_cell
Single assignment cells and lazy values
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
ordered-float
Wrappers for total ordering on floats
-
quick-error
A macro which makes error types pleasant to write
-
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… -
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
thiserror
derive(Error)
-
approx
Approximate floating point equality comparisons and assertions
-
error-chain
Yet another error boilerplate library
-
cast
Ergonomic, checked cast functions for primitive types
-
snafu
An ergonomic error handling library
-
rental
A macro to generate safe self-referential structs, plus premade types for common use cases
-
lazycell
A library providing a lazily filled Cell struct
-
indoc
Indented document literals
-
owning_ref
A library for creating references that carry their owner with them
-
pin-project
A crate for safe and ergonomic pin-projection
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
annotate-snippets
Library for building code annotations
-
geo-types
Geospatial primitive data types
-
frunk
Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
auto_enums
A library for to allow multiple return types by automatically generated enum
-
abscissa
Application microframework with support for command-line option parsing, configuration, error handling, logging, and terminal interactions. This crate contains a CLI utility for generating new applications
-
err-derive
Derive macro for
std::error::Error -
derivative
A set of alternative
deriveattributes for Rust -
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
if_chain
Macro for writing nested
if letexpressions -
palette_derive
Automatically implement traits from the palette crate
-
simple-error
A simple error type backed by a string
-
lazy-static-include
This crate provides
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
shrinkwraprs
Auto-derive for Rust conversion traits – make working with newtypes a breeze
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
abscissa_core
Application microframework with support for command-line option parsing, configuration, error handling, logging, and terminal interactions. This crate contains the framework’s core functionality
-
derive_utils
A procedural macro helper for easily writing derive macros for enums
-
noisy_float
Contains floating point types that panic if they are set to an illegal value, such as NaN
-
scroll_derive
A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate
-
enumflags2
Enum-based bit flags
-
rust_info
Extracts the current rust compiler information
-
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…
-
assert_matches
Asserts that a value matches a pattern
-
indoc-impl
Indented document literals
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
educe
This crate provides procedural macros to help you implement Rust-built-in traits quickly
-
frunk_proc_macros
Proc macros for Frunk
-
safe-transmute
A safeguarded transmute() for Rust
-
detach
helper type for being able to detach/reatach a member item
-
problem
Error handling for command line applications or prototypes
-
v_escape_derive
Procedural macro package for v_escape
-
enum_dispatch
Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed
-
take_mut
Take a T from a &mut T temporarily
-
defmac
A macro to define lambda-like macros inline
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
typed-generational-arena
A safe arena allocator that supports deletion without suffering from the ABA problem by using generational indices. Now with typed indices and custom integer types for generations!
-
reexport-proc-macro
Re-export a procedural macro
-
structural
Abstractions over fields
-
frunk_laws
frunk_laws contains laws for algebras declared in Frunk
-
join
Macros which provide useful shortcut combinators, combine sync/async chains, support single and multi thread (sync/async) step by step execution of branches, transform tuple of results in result of tuple
-
semval
Semantic validation
-
newtype_derive
This crate provides macros for deriving common traits for newtype structures
-
dynomite-derive
Derives AWS DynamoDB dynomite types from native Rust struct types
-
frunk_proc_macro_helpers
Common internal functions for frunk’s proc macros
-
enum_derive
This crate provides macros for deriving additional functionality for enums
-
sugars
A collection of macros in Rust to make some tasks easier to use or less verbose
-
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… -
iter-read
A Read implementation for iterators over u8 and related types
-
autodiff
An automatic differentiation library
-
mode
A behavioral state machine library written in Rust
-
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
-
simple-logging
A simple logger for the log facade
-
enum-iterator
Tools to iterate over the variants of a field-less enum
-
chainerror
Make chaining errors easy
-
lambda_runtime_errors_derive
Rust runtime errors derive for AWS Lambda
-
reduce
Fold an iterator without an initial value
-
structview
Viewing binary data as high-level data structures, safely
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
downcast
Trait for downcasting trait objects back to their original types
-
throw
Efficiently add statically-calculated stack traces to errors
-
opaque_typedef_macros
Supports defining opaque typedefs
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
libffi-sys
Raw Rust bindings for libffi
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
candy
Syntaxic sugar for Rust: macros for lighter error handling code, and more
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
abi_stable_derive
Implementation detail of abi_stable
-
iterslide
A “sliding window” iterator
-
py-comp
A macro implementing a Python-like generator expression
-
filters
Build filters/predicates with the builder pattern
-
coercible_errors
Zero-cost error handling for generic traits
-
progress-streams
Progress callbacks for types which implement Read/Write
-
lazy_format
A utility crate for lazily formatting values for later
-
boolinator
Provides the Boolinator trait, which lets you use Option and Result-style combinators with bools
-
resiter
Helper crate for handling iterators over result
-
arraygen
Derive macro for generating arrays from struct fields
-
displaydoc
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
fstrings
Python3 fstring interpolation in Rust
-
file
For Rust 1.25 and older. 1-liner convenience functions for reading and writing files
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
enum-iterator-derive
Procedural macro to iterate over the variants of a field-less enum
-
error_def
A Rust syntax extension for generating error-handling boilerplate code
-
valid
Validate custom types by composing primitive validation functions. Use one common API for validating all kind of business rules including aspects of the application state. One common error type for all…
-
structural_derive
Implementation detail of the structural crate
-
derive_deref
Adds
#[derive(Deref)]and#[derive(DerefMut)] -
abi_stable_derive_lib
Implementation detail of abi_stable
-
frunk_proc_macros_impl
Proc macros inernal implementations for Frunk
-
error-rules
Error handling without pain
-
current
A library for setting current values for stack scope, such as application structure
-
morphism
A structure for suspended closure composition in Rust
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
fragile
Provides wrapper types for sending non-send values to other threads
-
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 -
structview_derive
Custom derive for structview’s View trait
-
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
require_unsafe_in_body
Make
unsafe fnstill requireunsafeblocks in the function’s body -
moveslice
A one-function crate to move chunks in a slice around
-
enumflags
Bitflags
-
iter-progress
Calculate progress of your iterators
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
unchecked_unwrap
Adds an unchecked version of
unwrap()andexpect()to Option and Result -
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
cute
A macro for Python-esque comprehensions
-
quick-error2
A macro which makes error types pleasant to write
-
cex
Combinators of EnumX, for error-handling
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
validated-slice
Helper macros to implement std traits for custom validated slice types
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
const_fn_assert
Assertions for const functions
-
incomplete
Provides incomplete!(), a compile-time checked version of unimplemented!()
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
easy-error
Simple error utilities
-
arraygen-docfix
Derive macro for generating arrays from struct fields
-
failchain
Ergonomic companion library for failure
-
whiteout
Provides macros that erase the type of any value into an impl Trait for a given trait
-
ward
Provides a ward! macro which returns the contents of an Option and otherwise returns early, and a guard! macro, which does the same, but with a syntax more similar to Swift’s guard syntax
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
str-macro
The str!() macro, similar to vec![] but for strings
-
lang_extension
Rust Lang Extension
-
iter-comprehensions
A library for iterator comprehensions
-
single
Provides the Single trait for extracting the element from a single-element iterator
-
quixutils
Common helpers and utils
-
derive-error
Derive macro for Error using macros 1.1
-
static_assert_macro
Library implementation of so-called
static_assert -
ambassador
Trait implementation delegation via procedural macros
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
const_fn
An attribute for easy generation of a const function with conditional compilations
-
predicates-core
An API for boolean-valued predicate functions
-
const-random
Provides compile time random number generation
-
newtype_array
A macro to help implementing the standard derived traits on newtype arrays
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
interpolate_idents
Useable macro identifier concatenation plugin
-
try_match
An expression macro that does pattern matching and returns the result in
Result -
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
extension-trait
Macro to declare extension traits
-
mapcomp
Python-like list comprehensions for standard containers
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
overload
Provides a macro to simplify operator overloading
-
kaguya_rs
Functional Programming tools and ADTs
-
enumx
Structural enum implemented in enum exchange
-
conquer-once
synchronization primitives for lazy and one-time initialization
-
r-rust
Useful tools and macros for research (WIP). Currently, a microbench probe is implemented
-
miniserde-enum
Derive macros for miniserde on enums
-
precog_iter
An iterator adapter that returns the equivalent of
(iter.next(), iter.peek()) -
mitochondria
Mitochondria is the powerhouse of the
Cell -
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…
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
type-uuid
Safe, stable IDs for Rust types
-
riker-patterns
A collection of common actor patterns for Riker
-
iter-python
Python generator expressions and ‘list’ comprehensions
-
named-block
Macro implementing early-exit-from-any-block
-
phantom-enum
A simple macro library for creating phantom enums
-
aspect-weave
An Aspect Toolkit for Rust
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
const-if
This crate adds if-else expression into your constant functions
-
gumdrop_derive
custom derive support for gumdrop
-
macro_machine
State machine generator using macros
-
error-context
Methods and types that help with adding additional context information to error types
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
big_s
Rust’s missing
Stringliteral -
status
Error container
-
aspect
An Aspect Toolkit for Rust
-
join_to_string
Join a list of items to string/buffer
-
kinder
Kinder is a small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
stackpin
Crate for data that should be pinned to the stack at the point of declaration
-
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.
-
sum_error
Derive macros for fast summing of error types into error enum
-
trace-error
Extensions to Rust’s error system to automatically include backtraces
-
eliza_error
“Times are bad. Children no longer obey their parents, and everyone is writing an error handling library.” — Cicero
-
unborrow
Macro for calling a &mut self method with transient &-borrows of self in the parameters
-
range-split
Utilities for splitting sequences with range parameters
-
join-lazy-fmt
Lazy
separator.join(iterable)method andlazy_format!for Rust -
d2_iterators_smc
Demo : Dummy upload for checking
-
init_with
Helper trait to initilize an array with a function
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
error-type
Provides a macro for constructing unifying error types
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
err-context
Lightweight context layers for stdandard library errors
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
tuple-conv
Allows converting tuples of one element to vectors
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
error-chain-mini
error-chain for minimalist
-
disjoint-borrow
Disjoint mutable borrows of slices
-
displaydoc-watt
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
primitive-from
Provides a trait PrimitiveFrom that is what From is to Into for num_traits::AsPrimitive
-
concat-string
Provides macros for concatenating string slices into owned strings
-
inner
The inner! macro descends into an enum variant. It’s more flexible than try!() and unwrap(), and it works with your enum, too!
-
iter_vals
On the fly iterator creation
-
uwuizer
Rust Macro to UwUize your text. UwU.
-
kwarg_macros
Keyword argument plugin
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
into-result
A simple convenience trait for converting something into a
ResultorOption -
collect_slice
Collect an iterator into a slice
-
diesel-derive-newtype
Automatically connect newtypes to Diesel using their wrapped type
-
enum_traits_macros
Procedural macros that adds functionality to enums by deriving traits from the crate
enum_traits -
empty-option
Convenient wrappers for taking/replacing values from mutable references to
Options and enforcing invariants -
copy_from_str
An extension trait to copy a string into another string
-
ketos_derive
Derive traits for Ketos scripting language
-
errors_rust
Just a simple library for error mapping
-
size_hint
A very simple library to provide a size_hint for an iterator which does not provide it’s own
-
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:…
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
trackable_derive
Custom derive for
trackablecrate -
tilde
Using ~ to provide syntax sugar for Rust
-
unroll
An attribute-like procedural macro for unrolling for loops
-
getters-by-type
Derive macro for adding a getter method for each type in the struct
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
cbox
C pointer boxing, for when working with ffi
-
tylift
Lift enum variants to the type-level
-
adjacent-pair-iterator
An iterator over adjacent pairs in another iterator
-
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
-
zkp-macros-decl
Procedural macros
-
zkp-macros-lib
Library of procedural macros implemented using
proc_macro2 -
di
Dependency injection container
-
scopefunc
A trait defining kotlin-like scope functions
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
boow
Borrow Or oWnedsmart pointer. Alternative to Cow. -
zkp-criterion-utils
Criterion helpers to benchmark over size and number of processors
-
mysql_enum
Convert between Rust enum and MySQL enum
-
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
-
throttled-reader
An io::Read proxy that limits calls to read()
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
sconcat
String concatenation
-
drop_bomb
A runtime guard for implementing linear types
-
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…
-
abscissa_generator
Template-based generator for creating new Abscissa applications
-
slugify
Macro for flexible slug generation
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
shawshank
An efficient, generic internment structure
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
lfa_derive
Macros for LFA
-
snaptest
Dead simple snapshot testing
-
rev_slice
A newtype for operating on a reversed view of a slice
-
tiny_fail
Provides simple Fail type
-
ffi_helpers
A crate to help make working with FFI easier
-
zkp-error-utils
Assertion like macros for returning
Result::Err -
clone-into-box
A library for cloning trait objects
-
conditional
Provides a conditional! macro which lets you use the syntax of the conditional operator (also known as the ternary operator) in Rust
-
ngram
Iterator adaptors for n-grams and k-skip-n-grams
-
threadbound
Make any value Sync but only available on its original thread
-
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
unzip-n
Procedural macro to generate
unzipfor iterators over n-sized tuples -
splop
Helper functions to determine the first/last repetition of something
-
tyenum
Attribute macro for type enums
-
dont_panic
panic!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won’t panic.
-
enum-methods
Generates methods for each enum variant
-
expand_str
ExpandEnvironmentStrings-like function and string formatting utility
-
subset
Various subsets of slice’s items that are able to iterate over references to selected items
-
impl_ops
Macros for easy operator overloading
-
extend
Create extensions for types you don’t own with extension traits but without the boilerplate
-
geopattern
Beautiful generative geometric background images from a string, a Rust implementation of geo_pattern from @jasonlong
-
internship
Interned string and more
-
tuple-transpose
Transpose tuple of results and options to result and option of tuple
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
tyname
Retrieve type names during program execution on stable Rust
-
split_by
Split anything implementing Read trait by multiple sequences of bytes
-
macro_lisp
Lisp-like DSL for Rust language
-
def-mod
Simplifies module implementation routing and statically verifies exports
-
assert-impl
Macro for static assert types implement a trait or not
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
static-cond
Macro for performing comparisons during macro expansion
-
arc-io-error
A version of std::io::Error implemented on top of Arc instead of Box, making it cloneable
-
function_group
A macro to hack in function overloading to rust
-
field_types
Some derive macros for deriving enums, corresponding to the fields of structs
-
take-until
A take until extension for iterators
-
dsl_macros
Convenience macros that rewrites method calls inside a builder closure
-
tuple-map
map methods for tuple
-
yade
Yet Another Derive Error
-
splits_iter
Iterator over all 2-splits
-
slice-cast
Support for casting between slice types
-
map_for
A Rust macro that implements for comprehensions similar to Scala’s
-
refstruct
Generates code for structs which can rerefence their own fields. Currently alpha/experimental.
-
closure
A macro for capturing variables on a per variable basis
-
typebool
Type-level booleans meant for compile-time hackery
-
pure_decimal
A decimal type with no NaN and Infinity
-
control-flow
A hack to control control-flow outside closures
-
transfer
Crate that exposes a Transfer trait, that is to move what Clone is to copy
-
parse-generics-poc
A proof-of-concept implementation of the proposed RFC #1583; provides macros for parsing generics and where clauses. Note: requires a compatible nightly compiler. For a stable alternative…
-
try_into_opt
A macro like try!, but turns a Result into an Option, mainly for use in a filter_map
-
ternop
A tiny macro that implements a ternary operator for Rust
-
zkp-macros-impl
Implementation crate for
proc_macro_hack -
interleave
An arbitrary iterator interleaver for exhaustive consumption of iterators. Each iterator is guaranteed to be no more than a single next call behind any other iterator.
-
tilde_derive
Using ~ to provide syntax sugar for Rust
-
throws
A macro for easy creation per-function errors
-
dedup_iter
Deduplicating iterator adapters
-
read-byte-slice
An iterator over chunks of bytes as slices from an underlying reader
-
with-macro
Syntactic sugar for calling methods
-
num_alias
simple macros to declare ‘type checked’ aliases for integers and floats
-
flatten
Tuple flatteing for rust
-
wrap
Generic function wrapping
-
enum_macro
Useful macro for enum
-
chalk-macros
Macros for Chalk
-
gtmpl_derive
Derive for gtmpl_value
-
enumerate
An attribute macro that, given a trait and its implementers, generates an enum that can be used instead of a trait object, avoiding dynamic dispatch
-
ama
Quasi-quotation system for designing procedural macros mixed with Rust code
-
monad
Stackless monads in Rust
-
sugar
Rust syntax sugar collections
-
underscore_args
Macro for underscore named argument syntax, aka Dyon
-
specialize
Type specialization macros and helpers
-
lift-fail
A library to handle
failurein an iterable collection -
pathsep
a small macro to enable easy path construction in other macro calls
-
list_builder
Python-like list comprehensions in Rust
-
unify
Trait-based equality constraint for Rust
-
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
blunder
Dumb crate to make error handling easy
-
powerset-enum
A poor man’s anonymous enum
-
enum_extract
Helper macros for extracting single enum variants of an enum
-
gaclen_shader
Tweaked re-export of vulkano_shader! procedural macro
-
to_vec
convenient to_vec, to_set and to_map methods on iterators
-
io-error
Simple and convenient macro for creating I/O errors
-
hexfloat
Syntax extension to create floating point literals from hexadecimal strings
-
pinpoint
Crate for pinned references
-
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
efficient_enum
Space-efficient enum values
-
bidir_iter
Bidirectional iterators
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
hash-of
A typesafe wrapper for hashes
-
transaction
transaction abstraction library (a.k.a. transaction monad)
-
sorted
Provides compile time guarantees for sorted sequences
-
enum_str
Creates a unitary enum and conversions from enum variants to string and vice versa
-
mem_macros
align_of and size_of as a macro, to avoid turbofish notation
-
match-downcast
A set of downcasting matching Rust macros
-
validator_derive
Macros 1.1 implementation of #[derive(Validate)]
-
rev_lines
Rust Iterator for reading files line by line with a buffer in reverse
-
enum-kinds
Generate enums with matching variants but without any of the associated data
-
scoped
Run deferred closures at success, failure, or exit of a scope. Also supports cancelling them
-
overloadable
Overloadable functions done easy in rust
-
capture
A macro for adding explicit capture clauses to a (closure-) expression
-
limit_read
A companion to std::io::Take and an extension to std::io::BufRead to put a cap on methods that could potentionally read infinitely
-
peek-nth
An iterator adapter that allows you to efficiently peek the nth item of an iterator
-
multizip
Zip 3, 4, 5 or more Rust iterators
-
iterr
Combinators for dealing with iterators of
Results -
progressive
A rust library for showing progress of iterators and loops
-
pub-iterator-type
Abstract an iterator implementation behind a struct tuple
-
bitpat
Bit-level matching against values
-
bounded-integer
Bounded integers
-
iflet
Provides a macro to chain multiple patterns in an
if letrather than nesting them -
apply_pub
A Rust syntax extension for applying the
pubvisibility modifer to many items at once -
tagged_ptr
A safe tagged union pointer datastructure for x64
-
wrapped-vec
Macro for generating wrapped Vec types and associated boilerplate
-
also
A collection of Kotlin-esque blanket impl helper functions, enabling easier function chaining patterns
-
taken
Macros for taking ownership, staring Liam Neeson
-
lain_derive
Derive macros for usage with lain
-
rust-fsm-dsl
Macros for rust-fsm DSL
-
mysql_enum_derive
Library for mysql enum
-
compiler_error
Triggerable compiler error
-
convute
Conversion between types with overlapping valid bit patterns and arrays, vecs and slices of those values
-
anon
Anonymous struct macro
-
enum_from_str
Enable deriving FromStr for enums
-
korat_derive
Derivables for implementation of converters of structures to and from rusoto attribute maps
-
rchunks
Iterator for slices similar to .chunks() but starting from the back of the slice and moving towards the front. Differs from .chunks().rev() in handling cases where the slice is not a multiple of chunk size.
-
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
-
eager
Crate for eager macro expansion
-
iter_from_closure
Iterator<Item = Item> from FnMut() -> Option
-
enum_variants
Deriving traits for C-like enums using macro 1.1
-
rawslice
Reimplementation of the slice iterators, with extra features. For example creation from raw pointers and start, end pointer accessors.
-
altbitflags
Macros to implement a struct which behave similar to bitflags
-
breaktarget
Implementation of nonlocal breaks in Rust
-
clone_all
clone_all!(my,variables,with,long,names);
-
resiter-dpc-tmp
Helper crate for handling iterators over result [dpc’s temporary release]
-
exclusive
Place code into an exclusive context that won’t collide with another context
-
interpolate_idents_gnzlbg_fork
Useable macro identifier concatenation plugin
-
min_max_macros
Macros for nicer min()/max()
-
static-events
A library for creating zero-cost event systems
-
slice-copy
Go style copying for slices