-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
error-chain
Yet another error boilerplate library
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
once_cell
Single assignment cells and lazy static values without macros
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
ordered-float
Wrappers for total ordering on floats
-
quick-error
A macro which makes error types pleasant to write
-
synstructure
Helper methods and macros for custom derives
-
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 -
frunk
Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
nodrop
A wrapper type to inhibit drop (destructor). Use std::mem::ManuallyDrop instead!
-
geo-types
Geospatial primitive data types
-
indoc
Indented document literals
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
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
-
owning_ref
A library for creating references that carry their owner with them
-
derivative
A set of alternative
deriveattributes for Rust -
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
-
annotate-snippets
Library for building code annotations
-
snafu
An ergonomic error handling library
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
lambda_runtime_errors
Rust runtime errors for AWS Lambda
-
validator_derive
Macros 1.1 implementation of #[derive(Validate)]
-
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 -
hex-literal
Procedural macro for converting hexadecimal string to byte array at compile time
-
rust_info
Extracts the current rust compiler information
-
noisy_float
Contains floating point types that panic if they are set to an illegal value, such as NaN
-
frunk_proc_macro_helpers
Common internal functions for frunk’s proc macros
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
auto_enums
A library for to allow multiple return types by automatically generated enum
-
assert_matches
Asserts that a value matches a pattern
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
opaque_typedef
Supports defining opaque typedefs
-
cast
Ergonomic, checked cast functions for primitive types
-
frunk_proc_macros
Proc macros for Frunk
-
frunk_laws
frunk_laws contains laws for algebras declared in Frunk
-
lambda_runtime_errors_derive
Rust runtime errors derive for AWS Lambda
-
indoc-impl
Indented document literals
-
derive_utils
A procedural macro helper for easily writing derive macros for enums
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
abi_stable_derive_lib
Implementation detail of abi_stable
-
if_chain
Macro for writing nested
if letexpressions -
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
opaque_typedef_macros
Supports defining opaque typedefs
-
scroll_derive
A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate
-
reexport-proc-macro
Re-export a procedural macro
-
err-derive
Derive macro for
std::error::Error -
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!
-
educe
This crate provides procedural macros to help you implement Rust-built-in traits quickly
-
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
-
auto_enums_derive
This library provides an attribute macro like a wrapper of
#[derive], implementing the supported traits and passing unsupported traits to#[derive] -
fomat-macros
Alternative syntax for print/write/format-like macros with a small templating language
-
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
-
enumflags2
Enum-based bit flags
-
frunk_proc_macros_impl
Proc macros inernal implementations for Frunk
-
pin-project
A crate for safe and ergonomic pin-projection
-
take_mut
Take a T from a &mut T temporarily
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
interpolate_idents
Useable macro identifier concatenation plugin
-
enum_derive
This crate provides macros for deriving additional functionality for enums
-
chainerror
Make chaining errors easy
-
throw
Efficiently add statically-calculated stack traces to errors
-
downcast
Trait for downcasting trait objects back to their original types
-
cstr
Macro for building static CStr reference
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
safe-transmute
A safeguarded transmute() for Rust
-
simple-logging
A simple logger for the log facade
-
problem
Error handling for command line applications or prototypes
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
coercible_errors
Zero-cost error handling for generic traits
-
iterslide
A “sliding window” iterator
-
derive_deref
Adds
#[derive(Deref)]and#[derive(DerefMut)] -
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 -
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
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
-
reduce
Fold an iterator without an initial value
-
sugars
A collection of macros in Rust to make some tasks easier to use or less verbose
-
auto_enums_core
This library provides an attribute macro for to allow multiple return types by automatically generated enum
-
py-comp
A macro implementing a Python-like generator expression
-
progress-streams
Progress callbacks for types which implement Read/Write
-
mode
A behavioral state machine library written in Rust
-
file
For Rust 1.25 and older. 1-liner convenience functions for reading and writing files
-
abi_stable_derive
Implementation detail of abi_stable
-
cex
Combinators of EnumX, for error-handling
-
quick-error2
A macro which makes error types pleasant to write
-
newtype_derive
This crate provides macros for deriving common traits for newtype structures
-
derive-getters
Simple boilerplate getters generator
-
crates-index-diff
Learn what’s changed in the crates.io index
-
filters
Build filters/predicates with the builder pattern
-
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
-
incomplete
Provides incomplete!(), a compile-time checked version of unimplemented!()
-
current
A library for setting current values for stack scope, such as application structure
-
inline-python
Inline Python code directly in your Rust code
-
enumflags
Bitflags
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
failchain
Ergonomic companion library for failure
-
unchecked_unwrap
Adds an unchecked version of
unwrap()andexpect()to Option and Result -
autodiff
An automatic differentiation library
-
morphism
A structure for suspended closure composition in Rust
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
piston2d-drag_controller
A drag controller
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
enumx
Structural enum implemented in enum exchange
-
shrinkwraprs
Auto-derive for Rust conversion traits – make working with newtypes a breeze
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
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 -
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
lazy_format
A utility crate for lazily formatting values for later
-
kaguya_rs
Functional Programming tools and ADTs
-
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. -
iter-python
Python generator expressions and ‘list’ comprehensions
-
error-rules
Error handling without pain
-
single
Provides the Single trait for extracting the element from a single-element iterator
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
fluent-impl
A procedural macro that generates chaining methods from non-chaining ones in an impl block
-
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
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
require_unsafe_in_body
Make
unsafe fnstill requireunsafeblocks in the function’s body -
iter-comprehensions
A library for iterator comprehensions
-
getters-by-type
Derive macro for adding a getter method for each type in the struct
-
tylift
Lift enum variants to the type-level
-
structview
Viewing binary data as high-level data structures, safely
-
easy-error
Simple error utilities
-
join_to_string
Join a list of items to string/buffer
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
libffi-sys
Raw Rust bindings for libffi
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
cute
A macro for Python-esque comprehensions
-
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
-
macro-attr
This crate provides the
macro_attr!macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derivecrate. -
unroll
An attribute-like procedural macro for unrolling for loops
-
const-random
Provides compile time random number generation
-
overload
Provides a macro to simplify operator overloading
-
newtype_array
A macro to help implementing the standard derived traits on newtype arrays
-
defmac
A macro to define lambda-like macros inline
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
boolinator
Provides the Boolinator trait, which lets you use Option and Result-style combinators with bools
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
conquer-once
synchronization primitives for lazy and one-time initialization
-
const_fn
An attribute for easy generation of a const function with conditional compilations
-
def-mod
Simplifies module implementation routing and statically verifies exports
-
precog_iter
An iterator adapter that returns the equivalent of
(iter.next(), iter.peek()) -
iter_vals
On the fly iterator creation
-
field_types
Some derive macros for deriving enums, corresponding to the fields of structs
-
fstrings
Python3 fstring interpolation in Rust
-
iterator-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, FusedIterator, Extend)] for enums
-
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.
-
errors_rust
Just a simple library for error mapping
-
named-block
Macro implementing early-exit-from-any-block
-
phantom-enum
A simple macro library for creating phantom enums
-
resiter
Helper crate for handling iterators over result
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
const-if
This crate adds if-else expression into your constant functions
-
macro_machine
State machine generator using macros
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
function_name
macro that expands to the name of the annotated function
-
abscissa_generator
Template-based generator for creating new Abscissa applications
-
mdo
Monadic do notation for rust using macro and duck typing
-
jit_macros
JIT Macros
-
kinder
Kinder is a small crate which adds an algebraic structure to common Rust structs and emulates higher order types
-
parse_cfg
Parse Rust’s
cfg(not(any(target)))attribute syntax -
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
trace-error
Extensions to Rust’s error system to automatically include backtraces
-
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.
-
copy_from_str
An extension trait to copy a string into another string
-
unborrow
Macro for calling a &mut self method with transient &-borrows of self in the parameters
-
fragile
Provides wrapper types for sending non-send values to other threads
-
ketos_derive
Derive traits for Ketos scripting language
-
fields-converter-derive
Fields-wise type conversions derive macros
-
init_with
Helper trait to initilize an array with a function
-
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
-
rent_to_own
A wrapper type for optionally giving up ownership of the underlying value
-
trackable_derive
Custom derive for
trackablecrate -
str-macro
The str!() macro, similar to vec![] but for strings
-
big_s
Rust’s missing
Stringliteral -
error-type
Provides a macro for constructing unifying error types
-
tilde
Using ~ to provide syntax sugar for Rust
-
error-chain-mini
error-chain for minimalist
-
structview_derive
Custom derive for structview’s View trait
-
moveslice
A one-function crate to move chunks in a slice around
-
iter-read
A Read implementation for iterators over u8 and related types
-
function_group
A macro to hack in function overloading to rust
-
structdoc-derive
Extract structure and documentation from structs (derive support)
-
tyenum
Attribute macro for type enums
-
grange
create range numbers macro
-
throttled-reader
An io::Read proxy that limits calls to read()
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
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
-
extension-trait
Macro to declare extension traits
-
gtmpl_derive
Derive for gtmpl_value
-
predicates-core
An API for boolean-valued predicate functions
-
higher-derive
Custom derives for
higher -
splitmut
Safely retrieves multiple mutable values from the same collection
-
ngram
Iterator adaptors for n-grams and k-skip-n-grams
-
map_retry
Zero dependency trait that provides retry function that works with iterators
-
threadbound
Make any value Sync but only available on its original thread
-
traitlit
This crate exposes an atribute for implementing traits for integer and float types
-
r-rust
Useful tools and macros for research (WIP). Currently, a microbench probe is implemented
-
mitochondria
Mitochondria is the powerhouse of the
Cell -
derive-error
Derive macro for Error using macros 1.1
-
kwarg_macros
Keyword argument plugin
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
adjacent-pair-iterator
An iterator over adjacent pairs in another iterator
-
collect_slice
Collect an iterator into a slice
-
nes
New Error System for rust
-
inner
The inner! macro descends into an enum variant. It’s more flexible than try!() and unwrap(), and it works with your enum, too!
-
enum-iterator-derive
Procedural macro to iterate over the variants of a field-less enum
-
enum-iterator
Tools to iterate over the variants of a field-less enum
-
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 -
concat-string
Provides macros for concatenating string slices into owned strings
-
rev_slice
A newtype for operating on a reversed view of a slice
-
error-context
Methods and types that help with adding additional context information to error types
-
size_hint
A very simple library to provide a size_hint for an iterator which does not provide it’s own
-
enumflags2_derive
Enum-based bitflags - the macros
-
cbox
C pointer boxing, for when working with ffi
-
subset
Various subsets of slice’s items that are able to iterate over references to selected items
-
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
-
aspect-weave
An Aspect Toolkit for Rust
-
di
Dependency injection container
-
mysql_enum
Convert between Rust enum and MySQL enum
-
primitive-from
Provides a trait PrimitiveFrom that is what From is to Into for num_traits::AsPrimitive
-
compile_msg
A plugin for emitting errors, warnings and notes to the developer at compile time
-
boow
Borrow Or oWnedsmart pointer. Alternative to Cow. -
lain_derive
Derive macros for usage with lain
-
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
-
with-macro
Syntactic sugar for calling methods
-
drop_bomb
A runtime guard for implementing linear types
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
into-result
A simple convenience trait for converting something into a
ResultorOption -
powerset-enum
A poor man’s anonymous enum
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
tilde_derive
Using ~ to provide syntax sugar for Rust
-
sconcat
String concatenation
-
enum_macro
Useful macro for enum
-
enum_index
Trait and macros for extracting Enum variant index
-
assert-impl
Macro for static assert types implement a trait or not
-
aspect
An Aspect Toolkit for Rust
-
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
-
enum-methods
Generates methods for each enum variant
-
shoggoth_macros
Generic and type-level programming for Rust
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
snaptest
Dead simple snapshot testing
-
function_name-proc-macro
macro that expands to the name of the annotated function
-
ffi_helpers
A crate to help make working with FFI easier
-
bidir_iter
Bidirectional iterators
-
slugify
Macro for flexible slug generation
-
splop
Helper functions to determine the first/last repetition of something
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
tyname
Retrieve type names during program execution on stable Rust
-
range-split
Utilities for splitting sequences with range parameters
-
loosen
Derives a wrapper function which loosen the arguments into a tuple
-
num_alias
simple macros to declare ‘type checked’ aliases for integers and floats
-
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
pinpoint
Crate for pinned references
-
pathsep
a small macro to enable easy path construction in other macro calls
-
impl_ops
Macros for easy operator overloading
-
internship
Interned string and more
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
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
-
str-concat
Concatenate two adjacent string slices
-
macro_lisp
Lisp-like DSL for Rust language
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
peek-nth
An iterator adapter that allows you to efficiently peek the nth item of an iterator
-
scoped
Run deferred closures at success, failure, or exit of a scope. Also supports cancelling them
-
static-cond
Macro for performing comparisons during macro expansion
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
arc-io-error
A version of std::io::Error implemented on top of Arc instead of Box, making it cloneable
-
reciter
Macro that allows converting a recursive function into an Iterator, which uses a cache
-
dsl_macros
Convenience macros that rewrites method calls inside a builder closure
-
yade
Yet Another Derive Error
-
quixutils
Common helpers and utils
-
splits_iter
Iterator over all 2-splits
-
refstruct
Generates code for structs which can rerefence their own fields. Currently alpha/experimental.
-
map_for
A Rust macro that implements for comprehensions similar to Scala’s
-
closure
A macro for capturing variables on a per variable basis
-
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, see the parse-generics-shim crate.
-
try_into_opt
A macro like try!, but turns a Result into an Option, mainly for use in a filter_map
-
interpolate_idents_gnzlbg_fork
Useable macro identifier concatenation plugin
-
mem_macros
align_of and size_of as a macro, to avoid turbofish notation
-
type-uuid
Safe, stable IDs for Rust types
-
tyenum_attribute
Attribute macro for type enums
-
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.
-
easy-pin
Using Pin made easy
-
throws
A macro for easy creation per-function errors
-
dedup_iter
Deduplicating iterator adapters
-
exclusive
Place code into an exclusive context that won’t collide with another context
-
enum-kinds
Generate enums with matching variants but without any of the associated data
-
read-byte-slice
An iterator over chunks of bytes as slices from an underlying reader
-
split_by
Split anything implementing Read trait by multiple sequences of bytes
-
convute
Conversion between types with overlapping valid bit patterns and arrays, vecs and slices of those values
-
wrap
Generic function wrapping
-
approx
Approximate floating point equality comparisons and assertions
-
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
enum_from_str
Enable deriving FromStr for enums
-
ama
Quasi-quotation system for designing procedural macros mixed with Rust code
-
sugar
Rust syntax sugar collections
-
underscore_args
Macro for underscore named argument syntax, aka Dyon
-
blunder
Dumb crate to make error handling easy
-
specialize
Type specialization macros and helpers
-
lift-fail
A library to handle
failurein an iterable collection -
builder_macro
A macro to generate structs and a corresponding builder
-
also
A collection of Kotlin-esque blanket impl helper functions, enabling easier function chaining patterns
-
enumx_derive
Structural enum implemented in enum exchange
-
multi-structs
Macro for generating a merged struct from multiple sub-structs
-
fourcc
Syntax extension to generate FourCCs (four-character code)
-
derive-enum-error
Derive macro for
std::error::Error -
list_builder
Python-like list comprehensions in Rust
-
unify
Trait-based equality constraint for Rust
-
to_vec
convenient to_vec, to_set and to_map methods on iterators
-
errorderive
Derive macro for
std::error::Error -
io-error
Simple and convenient macro for creating I/O errors
-
hexfloat
Syntax extension to create floating point literals from hexadecimal strings
-
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
dont_panic
panic!()-like macro that causes linking error instead of panicking. May be used to statically ensure some code won’t panic.
-
monad
Stackless monads in Rust
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
cex_derive
Combinators of EnumX, for error-handling
-
transaction
transaction abstraction library (a.k.a. transaction monad)
-
enumflags_derive
Bitflags
-
sorted
Provides compile time guarantees for sorted sequences
-
enum_str
Creates a unitary enum and conversions from enum variants to string and vice versa
-
match-downcast
A set of downcasting matching Rust macros
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
as_tuple
View any struct as a tuple! ✨
-
enum_extract
Helper macros for extracting single enum variants of an enum
-
mapcomp
Python-like list comprehensions for standard containers