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