Lib.rs

once_cell

Single assignment cells and lazy values

lazy_static

A macro for declaring lazily evaluated statics in Rust

thiserror

derive(Error)

num_enum

Procedural macros to make inter-operation between primitives and enums easier

float-cmp

Floating point approximate comparison traits

downcast-rs

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

ordered-float

Wrappers for total ordering on floats

derivative

A set of alternative derive attributes for Rust

derive_builder

Rust macro to automatically implement the builder pattern for arbitrary structs

snafu

An ergonomic error handling library

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…

synstructure

Helper methods and macros for custom derives

maplit

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

eyre

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

pin-project

A crate for safe and ergonomic pin-projection

annotate-snippets

Library for building code annotations

custom_error

Define custom errors without boilerplate using the custom_error! macro

anyhow

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

frunk

Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends

version-sync

Simple crate for ensuring that version numbers in README files are updated when the crate version changes

lazycell

A library providing a lazily filled Cell struct

enumflags2

Enum-based bit flags

indoc

Indented document literals

quick-error

A macro which makes error types pleasant to write

educe

This crate provides procedural macros to help you implement Rust-built-in traits quickly

typed-builder

Compile-time type-checked builder derive

itertools

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

owning_ref

A library for creating references that carry their owner with them

geo-types

Geospatial primitive data types

trie-db

Merkle-Patricia Trie generic over key hasher and node encoding

if_chain

Macro for writing nested if let expressions

simple-error

A simple error type backed by a string

noisy_float

Contains floating point types that panic if they are set to an illegal value, such as NaN

cmd_lib

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

parse-display

Procedural macro to implement Display and FromStr using common settings

maybe-owned

provides a MaybeOwned (and MaybeOwnedMut) type similar to std’s Cow but it implements From<T> and From<&'a T> and does not require ToOwned

fehler

A library for error-handling syntax in Rust

decorum

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

err-derive

Derive macro for std::error::Error

color-eyre

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

replace_with

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

auto_enums

A library for to allow multiple return types by automatically generated enum

sugars

A collection of macros in Rust to make some tasks easier to use or less verbose

tap

Generic extensions for tapping values in Rust

evcxr_repl

A REPL for Rust

enum-primitive-derive

enum_primitive implementation using procedural macros to have a custom derive

rust_info

Extracts the current rust compiler information

displaydoc

A derive macro for implementing the display Trait via a doc comment and string interpolation

safe-transmute

A safeguarded transmute() for Rust

hex-literal

Procedural macro for converting hexadecimal string to byte array at compile time

from_variants

Rust macro to automatically generate conversions for newtype enums

auto_impl

Automatically implement traits for common smart pointers and closures

conv

This crate provides a number of conversion traits with more specific semantics than those provided by ‘as’ or ‘From’/‘Into’

riker-patterns

A collection of common actor patterns for Riker

tt-call

Token tree calling convention

rental

A macro to generate safe self-referential structs, plus premade types for common use cases

failsafe

A circuit breaker implementation

amethyst_error

Internal error handling for Amethyst

uninit

A collection of tools for a safer usage of uninitialized memory

approx

Approximate floating point equality comparisons and assertions

drop_bomb

A runtime guard for implementing linear types

frunk_core

Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic

gumdrop

Option parser with custom derive support

unchecked_unwrap

Adds an unchecked version of unwrap() and expect() to Option and Result

enum-iterator

Tools to iterate over the variants of a field-less enum

pin-utils

Utilities for pinning

autodiff

An automatic differentiation library

command-macros

Macros for creating std::process::Command with shell-like syntax

scroll_derive

A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate

mode

A behavioral state machine library written in Rust

semval

Semantic validation

abi_stable

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

anomaly

Error context library with support for type-erased sources and backtraces

palette_derive

Automatically implement traits from the palette crate

smart-default

Rust custom-derive macro for Default with more control on the fields

cex

Combinators of EnumX, for error-handling

state_machine_future

Easily create type-safe Futures from state machines — without the boilerplate

impls

Determine if a type implements a logical trait expression

rusty-money

Money type for Rust

retain_mut

Provide retain_mut method that has the same functionality as retain but gives mutable borrow to the predicate

unroll

An attribute-like procedural macro for unrolling for loops

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…

derive_deref

Adds #[derive(Deref)] and #[derive(DerefMut)]

shadow-clone

A macro to clone variables into the current scope shadowing old ones

structview

Viewing binary data as high-level data structures, safely

pin-project-lite

A lightweight version of pin-project written with declarative macros

take_mut

Take a T from a &mut T temporarily

problem

Error handling for command line applications or prototypes

iter-read

A Read implementation for iterators over u8 and related types

amplify

Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros

arraygen

Derive macro for generating arrays from struct fields

buffered-reader

A super-powered Reader

advent-of-code

Solutions to Advent of Code

shrinkwraprs

Auto-derive for Rust conversion traits – make working with newtypes a breeze

validator_types

Basic type for validator and validator_derive

tynm

Returns type names in shorter form

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

chainerror

Make chaining errors easy

illicit

An implicit thread-local environment which is indexed by type

enumx

Structural enum implemented in enum exchange

idata

Small tools to reduce mutability

fstrings

Python3 fstring interpolation in Rust

lazy_format

A utility crate for lazily formatting values for later

try_match

An expression macro that does pattern matching and returns the result in Result

float-ord

A total ordering for floating-point numbers

refl

Provides a refl encoding 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

macro-attr-2018

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

tokenlock

Send-able cell type whose contents can be accessed only via an inforgeable token

cstr

Macro for building static CStr reference

components-arena

Simple library for creating complex domain-specific self-referential data structures

chalk-macros

Macros for Chalk

assert_matches

Asserts that a value matches a pattern

bio-types

A collection of common biomedical types for use in rust-bio and rust-htslib

cast

Ergonomic, checked cast functions for primitive types

partial_function

A clean way to define function as a set of subfunctions where each has defined start and end bounds

const-random

Provides compile time random number generation

result-like

Option/Result-like monad interface for your own enum

lazy-static-include

This crate provides lazy_static_include_bytes and lazy_static_include_str macros to replace include_bytes and include_str macros

frunk_proc_macros

Proc macros for Frunk

detach

helper type for being able to detach/reatach a member item

matches2

A macro to evaluate, as a boolean, whether an expression matches a pattern

dict_derive

Derive macros for some PyO3 traits to convert python dicts into rust structs

yui_internal

Internal functions, struct for derive in Yui

concat-with

Extend the function of the concat! macro in std

tylift

Lift enum variants to the type-level

derive-try-from-primitive

Custom derive a try_from method for primitive to enum conversions

extend

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

structural

Field accessor traits,and emulation of structural types

k8-client

Core Kubernetes metadata traits

intertrait

Allow for inter-trait casting

enum-kinds

Generate enums with matching variants but without any of the associated data

enum_derive

This crate provides macros for deriving additional functionality for enums

thread-scoped-ref

A library that is similar to a thread local storage but allows to store references / dyn Trait within a scope

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…

aspect-weave

An Aspect Toolkit for Rust

ffi_helpers

A crate to help make working with FFI easier

tear

Typed early returns and loop control + Syntax sugar for try!-like error handling

direction

Representations of directions

trackable_derive

Custom derive for trackable crate

hash256-std-hasher

Standard library hasher for 256-bit prehashed keys

xladd-derive

A simple macro that helps write Excel UDF functions in Rust

funty

Trait generalization over the primitive types

type-operators

A macro system for creating type operators in Rust and writing type-level logic

cast_trait_object

Cast between trait objects using only safe Rust

chalk-derive

A helper crate for use by chalk crates for derive macros

static_assert_macro

Library implementation of so-called static_assert

typename

Stable alternative to Rust’s type_name intrinsic

extprim_literals

Plugin for creating extra primitive types literals (u128!(n), i128!(n))

xmlparser-derive

A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser

hado

Monadic do notation using a macro

reduce

Fold an iterator without an initial value

cryo

Extend the lifetime of a reference. Safely.

quick-error2

A macro which makes error types pleasant to write

resiter

Helper crate for handling iterators over result

error_def

A Rust syntax extension for generating error-handling boilerplate code

reax

A reactivity system for Rust that infers dependencies between functions

advancedresearch-higher_order_core

Core structs and traits for programming with higher order structures in Rust

progress-streams

Progress callbacks for types which implement Read/Write

common_failures

Helpers for ‘failure’, including io::Error wrappers with paths, quick_main!, display_causes_and_backtrace

simple-logging

A simple logger for the log facade

blanket

A simple macro to derive blanket implementations for your traits

current

A library for setting current values for stack scope, such as application structure

rsb_derive

An opinionated macros implementation for Rust struct builder pattern

guard

Macro implementation of RFC 1303: a guard-let-else statement a la Swift

ambassador

Trait implementation delegation via procedural macros

str-macro

The str!() macro, similar to vec![] but for strings

dynerr

Macros for dynamic error handling

bool_ext

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

butcher

An easy way to interact with structs and enums wrapped in Cows

bossy

Opinionated convenience wrappers for std::process::Command and friends

enum_access

Custom derive for automatically generating the accessor methods for Enums

easy-error

Simple error utilities

derive_di

This crate is realized the dependency injection pattern

once

This crate provides an assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.

boolean-enums

Generate enums with Yes and No variants. Supports no_std and serde.

random-number

Generate random numbers quickly

unzip-n

Procedural macro to generate unzip for iterators over n-sized tuples

cargo-verify

Prettier error messages for the verified crate

iter-progress

Calculate progress of your iterators

enum-as-inner

A proc-macro for deriving inner field accessor functions on enums

exitfailure

A basic newtype wrappers for use with ? in main

bounded-integer

Bounded integers

yui

An attribute reader generator for Rust

error-rules

Error handling without pain

haskell_bits

Rust implementations of various Haskell typeclasses and functions

partial_application

partial function application via the partial! macro

merge

Merge multiple values into one

eventually

Crate for using Event Sourcing in Rust applications

rustils

Utilities for rust

grouping_by

A simple library which allows the user to group an iterator by various ways

fragile

Provides wrapper types for sending non-send values to other threads

dyn-context

Non-owning service provider pattern implementation

unique-type-id-derive

A unique id proc-macro generator for types

delegate-attr

Attribute proc-macro to delegate method to a field

format

A utility crate to make it easier to work with the formatter

typeable

Exposes Typeable, for getting TypeIds at runtime

aerosol

Dependency injection with compile-time guarantees

require_unsafe_in_body

Make unsafe fn still require unsafe blocks in the function’s body

spez

Macro to specialize on the type of an expression

drop_ok

.drop_ok syntax sugar for Result. It’s instead of .map(|_|()).

enum_traits

Traits for builtin enum items that are primarily used by enum_traits_macros when automatically deriving types

stdext

Extensions for the Rust standard library structures

opaque_typedef_macros

Supports defining opaque typedefs

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

bidule

Ultra simple Functional Reactive Programming, made with stuff, things, device, thingumajig, etc

by_address

Wrapper for comparing and hashing pointers by address

fp_rust

Implement fp features for Rust

closure

A macro for capturing variables on a per variable basis

woah

A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)

k8s-openapi-codegen-common

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

pre-proc-macro

Procedural marco implementations for pre

tupletools

Utility functions for tuples

multindex

Index slices with multiple const indices/ranges

tia

tia; trait, impl, accessors | automatic

cute

A macro for Python-esque comprehensions

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

throw

Efficiently add statically-calculated stack traces to errors

edisp

Dispatch-on-collect for Rust enums

bitwrap_derive

derive for bitwrap

assert_approx_eq

assert approximately equal

ndless-static-vars

Rust library for storing static, program-wide parameters for Ndless

mac

A collection of great and ubiqutitous macros

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…

peeking_take_while

Like Iterator::take_while, but calls the predicate on a peeked value. This allows you to use Iterator::by_ref and Iterator::take_while together, and still get the first value…

inner

The inner! macro descends into an enum variant. It’s more flexible than try!() and unwrap(), and it works with your enum, too!

iterslide

A “sliding window” iterator

amplify_derive

Amplifying Rust language capabilities: derive macros for the ‘amplify’ library

cell

A replacement of std::cell::RefCell adding advanced support for mapping borrows

alone_ee

Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted

moveslice

A one-function crate to move chunks in a slice around

num_enum_derive

Internal implementation details for ::num_enum (Procedural macros to make inter-operation between primitives and enums easier)

enum-repr

Derive enum repr conversions compatible with type aliases

fool

Traits for interoperation of Boolean and sum types

eventmill_derive

Derive macros for convient implementation of some traits of the eventmill crate

type-variance

Marker traits for subtype variance

tapir

Adding tapping functionality to rust

enum-unitary

Trait and macro for unitary enums

parse-display-derive

Procedural macro to implement Display and FromStr using common settings

improved_slice_patterns

A tiny crate that provides macros to help matching on Vecs and iterators using the syntax of slice_patterns

mox

Mockery Of X(ML): a JSX-alike syntax for the builder pattern

enum-lexer

A proc_macro lexer generator. using enum-like syntax.

fed

A sketch implementation of anonymous, tagged unions in stable Rust

boxfnonce

safe FnOnce boxing for rust stable

rvs-repl

REPL for Rvs - A library for defining and evaluating random variables using a simple DSL

newtype-ops

Mass-derive many operators for newtypes. Wartier than newtype_derive.

try_from

TryFrom and TryInto traits for failable conversions that return a Result

morphism

A structure for suspended closure composition in Rust

structview_derive

Custom derive for structview’s View trait

noship

Noship is a macro that acts similar as todo! but will throw a compilation error when compiled on release profile

py-comp

A macro implementing a Python-like generator expression

named-block

Macro implementing early-exit-from-any-block

high_mem_utils

This crate provides a bunch of mem safe abstractions,some involving transmute

enum_set2

A bit-set indexed by enum variants

lambda_runtime_errors_derive

Rust runtime errors derive for AWS Lambda

phantom-enum

A simple macro library for creating phantom enums

const_fn_assert

Assertions for const functions

generic-bytes

A derivable trait for conversion to and from an array of bytes with a type-level size

ref-portals

Safely use (stack) references outside their original scope

reffers

Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!

lang_extension

Rust Lang Extension

indoc-impl

Indented document literals

market

Infrastructure for producers and consumers

ff_derive

Procedural macro library used to build custom prime field implementations

error-code

Alternative Error for Rust

summon

A logic engine designed to magically give you what you ask for

frunk_proc_macro_helpers

Common internal functions for frunk’s proc macros

fn_chain

Helper macro/function to create function chaining

arg_enum_proc_macro

A procedural macro compatible with clap arg_enum

metatype

Helper methods to determine whether a type is TraitObject, Slice or Concrete, and work with them respectively

type-uuid

Safe, stable IDs for Rust types

unwrap-infallible

Unwrapping Result values with compile-time guarantee of infallibility

incomplete

Provides incomplete!(), a compile-time checked version of unimplemented!()

rust-fsm-dsl

Macros for rust-fsm DSL

ff_derive_ce

Procedural macro library used to build custom prime field implementations

butcher_proc_macro

Procedural macros for butcher

kinder

Kinder is a small crate which adds an algebraic structure to common Rust structs and emulates higher order types

numeric_literals

Easily cope with numeric literals in generic Rust code

switch_statement

A simple switch statement macro

cenum-derive

A rust derive macro for C-style primitive enums

downcast

Trait for downcasting trait objects back to their original types

as_derive_utils

private derive utilities used by abi_stable and structural

sortby

adds convenient sort functions for Iterators

typemap_rev

A hashmap, but stores types as keys

indexing

Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds

file

For Rust 1.25 and older. 1-liner convenience functions for reading and writing files

cor_iter

Correlate of two iterators

flagset

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

thiserror-impl

Implementation detail of the thiserror crate

bidir_iter

Bidirectional iterators

status

Error container

miniserde-enum

Derive macros for miniserde on enums

predicates-core

An API for boolean-valued predicate functions

frunk_laws

frunk_laws contains laws for algebras declared in Frunk

single

Provides the Single trait for extracting the element from a single-element iterator

drop_some

.drop_some syntax sugar for Option. It’s instead of .map(|_|()).

concat_strs

Macro for quickly building a String from components

numeric-enum-macro

A declarative macro for type-safe enum-to-numbers conversion

filters

Build filters/predicates with the builder pattern

derive_builder_core

Internal helper library for the derive_builder crate

dependent_view

Wrappers to produce weak trait objects from reference types

failchain

Ergonomic companion library for failure

gpg-error

Libgpg-error bindings for Rust

into-result

A simple convenience trait for converting something into a Result or Option

machine

State machine utilities

supercow

A generic way to accept general reference-like values without proliferating generics

dyn-iter

Wrapper around Box<dyn Iterator<Item = V> + 'iter> to simplify your code

with_locals

TODO!

enumflags

Bitflags

rjdebounce

Debouncing function utility

into-owned

Provides a trait for associating a type with its owned variant

read-restrict

Restrict the number of bytes read from a reader

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

ffishim_derive

Procedural macros for generating ffi-compatible stubs

ketos_derive

Derive traits for Ketos scripting language

enum_properties

A macro for declaring static properties on enum variants

aspect

An Aspect Toolkit for Rust

never

A stable version of the unstable never type (!)

kwarg_macros

Keyword argument plugin

generics

Provides macros for parsing generics and where clauses in macro_rules!

noise_fn

Some simple noise functions and traits to allow easy integration with your own

as-result

Traits for converting types which may be interpreted as or into a result

reexport-proc-macro

Re-export a procedural macro

is-same

A trait for comparing object equality

derive_setters

Rust macro to automatically generates setter methods for a struct’s fields

tuple-arity

Get the arity (number of elements) of tuple types with 0-12 elements

whiteout

Provides macros that erase the type of any value into an impl Trait for a given trait

pipeline

A macro collection to pipe |> your functions calls, like in F# or Elixir

shaku_derive

Code generation for the shaku dependency injection framework

bumpalo-herd

Support for bumpalo in scoped threads & rayon

typic

Type-safe transmutations between layout-compatible types

try-guard

A guard! macro inspired by the guard Alternative function from Haskell

len_constraints

Traits and types to implement type-pinned length constraints in your API

array-lit

Macros for array and Vec literals with superpowers

quixutils

Common helpers and utils

messages

A midground between channels and actors

impl-enum

Macro for generating methods on an enum that match on the enum and call the same method on each variant

abi_stable_derive

Implementation detail of abi_stable

gaclen_shader

Tweaked re-export of vulkano_shader! procedural macro

anysafe

any safe

coercible_errors

Zero-cost error handling for generic traits

mapcomp

Python-like list comprehensions for standard containers

ambience

Lightweight library for passing ambient parameters

newtype_array

A macro to help implementing the standard derived traits on newtype arrays

enum_const_value

Providing const values for enums. Unit and enums with associated types are supported. Each variant gets a unique sequential value.

og_fmt

The original format!

xkcd_unreachable

A Rust macro xkcd_unreachable!() inspired by https://xkcd.com/2200/

trace-error

Extensions to Rust’s error system to automatically include backtraces

access-json

Use serde to query large nested structures in Rust. For low-effort, read-only FFI.

iter-comprehensions

A library for iterator comprehensions

ferrum-plugin

Lazily evaluated, order-independent plugins for extensible types

dependent_ghost

An implementation of Matt Noonan’s ‘Ghosts of Departed Proofs’

assert_that

Helper macros for use with boolean-valued predicate functions

lset

Data types describing linear sets

unwrap_all

Unpack multiple levels of Result<T, E> and Option<T> at once

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

mitochondria

Mitochondria is the powerhouse of the Cell

en

The easiest numeric traits!

slugify

Macro for flexible slug generation

struct-pad

Padding types to enable memory layout optimizations

inheritance

Avoiding code repetition in Rust with OOP inheritance

concat-string

Provides macros for concatenating string slices into owned strings

named

Procedural macro which allows you to produce functions which can be called with named arguments, optionally with default values

failure_without_backtrace

Experimental error handling abstraction

take-if

A tiny utility for conditionally taking the contents of an option

rusty_v8_helper_derive

A rust derive macro for rusty_v8_helper

axpy

Macro for auto-vectorizing n-ary linear combinations

exotic-iter

My personal collection of special-case iterator methods

hypospray

Lightweight dependency injection library

read-byte-slice

An iterator over chunks of bytes as slices from an underlying reader

defmac

A macro to define lambda-like macros inline

conventus

Traits for assembling and disassembling items

sum_error

Derive macros for fast summing of error types into error enum

borrow_with_ref_obj

Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)

single-instance

A rust library for single instance application

derive_is_enum_variant

Automatically derives is_dog and is_cat methods for enum Pet { Dog, Cat }

block_effects

A macro to chain block effects

oauth1-request-derive

A derive macro for oauth1_request::Authorize trait

boow

Borrow Or oWned smart pointer. Alternative to Cow.

kaguya_rs

Functional Programming tools and ADTs

plain_enum

Mimicing Java’s enum::values() and EnumMap

snaptest

Dead simple snapshot testing

accel-derive

Procedual macro for writing GPGPU kernel

error-chain-mini

error-chain for minimalist

tyenum

Attribute macro for type enums

namedarg_rustc_macro

namedarg main package

compile_msg

A plugin for emitting errors, warnings and notes to the developer at compile time

fff_derive

Procedural macro library used to build custom prime field implementations

easy-ext

An attribute macro for easily writing extension trait pattern

tuple_list

Crate for macro-free variadic tuple metaprogramming

macroz

A collection of utility macros

iter-enum

#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums

hash-db

Trait for hash-keyed databases

const-if

This crate adds if-else expression into your constant functions

hexfloat

Syntax extension to create floating point literals from hexadecimal strings

round

This crate provides utilities to round your floats with precision from 1 to 10

enum_to_u8_slice_derive

A simple fork of enum_to_str_derive (by @DCjanus), convert enum to u8 slice ref

floatconv

Floating point conversion functions

sum_type

A convenience macro for creating a wrapper enum which may be one of several distinct types

reinterpret

Low level utility functions to reinterpret arrays of data

overload

Provides a macro to simplify operator overloading

gumdrop_derive

custom derive support for gumdrop

dispose

A simple wrapper for values that must be consumed on drop

doublysure

Using types to make sure that you’re sure, sure, and doubly sure

tyname

Retrieve type names during program execution on stable Rust

eieio

Error Implementing Eq + Clone replacing std::io::Error

macro_lisp

Lisp-like DSL for Rust language

event_feed

Event systems implemented using event feeds

gen-iter

temporary util for creating iterators using generators

inherent-pub

Mark methods in impl Trait for Type blocks inherent to the type

aether_primitives

Helpers for common SDR and signal generation operations

expect_macro

The expect! macro

enum_like

A trait to treat any type as an enum. If a type has a reasonably small number of variants, for example a struct A(bool, bool) which has 4 variants, this trait provides a 1-to-1 mapping from type value to a…

macro_macro

Macro templating library for DRYer structs

sugar

Rust syntax sugar collections

lazy-bytes-cast

Lazy casts from & to byte arrays

multi-structs

Macro for generating a merged struct from multiple sub-structs

take_ref

TakeRef, TakeSlice, and TakeString traits enable treating references/slices and values interchangeably. They can be treated as references/slices. And you can take ownership of the value…

range-split

Utilities for splitting sequences with range parameters

impl_ops

Macros for easy operator overloading

envsubst

Variables substitution

error

A fancy error type for highly generic cases

either_trait_macro