-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
error-chain
Yet another error boilerplate library
-
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
-
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… -
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
rental
A macro to generate safe self-referential structs, plus premade types for common use cases
-
owning_ref
A library for creating references that carry their owner with them
-
indoc
Indented document literals
-
ordered-float
Wrappers for total ordering on floats
-
geo-types
Geospatial primitive data types
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
frunk
Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
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
-
snafu
An ergonomic error handling library
-
hex-literal
Procedural macro for converting hexadecimal string to byte array at compile time
-
auto_enums
A library for to allow multiple return types by automatically generated enum
-
err-derive
Derive macro for
std::error::Error -
lazycell
A library providing a lazily filled Cell struct
-
cast
Ergonomic, checked cast functions for primitive types
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
pin-project
A crate for safe and ergonomic pin-projection
-
derivative
A set of alternative
deriveattributes for Rust -
lazy-static-include
This crate provides
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
assert_matches
Asserts that a value matches a pattern
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
rust_info
Extracts the current rust compiler information
-
annotate-snippets
Library for building code annotations
-
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
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
lambda_runtime_errors
Rust runtime errors for AWS Lambda
-
enumflags2
Enum-based bit flags
-
auto_enums_derive
This library provides an attribute macro like a wrapper of
#[derive], implementing the supported traits and passing unsupported traits to#[derive] -
strfmt
strfmt: rust library for formatting dynamic strings
-
simple-error
A simple error type backed by a string
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
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
-
educe
This crate provides procedural macros to help you implement Rust-built-in traits quickly
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
opaque_typedef
Supports defining opaque typedefs
-
frunk_proc_macros
Proc macros for Frunk
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
frunk_laws
frunk_laws contains laws for algebras declared in Frunk
-
auto_enums_core
This library provides an attribute macro for to allow multiple return types by automatically generated enum
-
v_escape_derive
Procedural macro package for v_escape
-
lambda_runtime_errors_derive
Rust runtime errors derive for AWS Lambda
-
indoc-impl
Indented document literals
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
abi_stable_derive_lib
Implementation detail of abi_stable
-
defmac
A macro to define lambda-like macros inline
-
if_chain
Macro for writing nested
if letexpressions -
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
-
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!
-
problem
Error handling for command line applications or prototypes
-
enum_derive
This crate provides macros for deriving additional functionality for enums
-
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
-
semval
Semantic validation
-
downcast
Trait for downcasting trait objects back to their original types
-
sugars
A collection of macros in Rust to make some tasks easier to use or less verbose
-
iter-read
A Read implementation for iterators over u8 and related types
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
take_mut
Take a T from a &mut T temporarily
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
simple-logging
A simple logger for the log facade
-
interpolate_idents
Useable macro identifier concatenation plugin
-
chainerror
Make chaining errors easy
-
mode
A behavioral state machine library written in Rust
-
throw
Efficiently add statically-calculated stack traces to errors
-
reduce
Fold an iterator without an initial value
-
derive-getters
Simple boilerplate getters generator
-
enum-iterator
Tools to iterate over the variants of a field-less enum
-
cstr
Macro for building static CStr reference
-
safe-transmute
A safeguarded transmute() for Rust
-
crates-index-diff
Learn what’s changed in the crates.io index
-
structview
Viewing binary data as high-level data structures, safely
-
opaque_typedef_macros
Supports defining opaque typedefs
-
iterslide
A “sliding window” iterator
-
derive_deref
Adds
#[derive(Deref)]and#[derive(DerefMut)] -
coercible_errors
Zero-cost error handling for generic traits
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
autodiff
An automatic differentiation library
-
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
-
py-comp
A macro implementing a Python-like generator expression
-
progress-streams
Progress callbacks for types which implement Read/Write
-
filters
Build filters/predicates with the builder pattern
-
lazy_format
A utility crate for lazily formatting values for later
-
frunk_proc_macros_impl
Proc macros inernal implementations for Frunk
-
file
For Rust 1.25 and older. 1-liner convenience functions for reading and writing files
-
quick-error2
A macro which makes error types pleasant to write
-
newtype_derive
This crate provides macros for deriving common traits for newtype structures
-
enum_dispatch
Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed
-
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 -
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
abi_stable_derive
Implementation detail of abi_stable
-
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…
-
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
-
dynomite-derive
Derives AWS DynamoDB dynomite types from native Rust struct types
-
current
A library for setting current values for stack scope, such as application structure
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
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!
-
gumdrop_derive
custom derive support for gumdrop
-
morphism
A structure for suspended closure composition in Rust
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
cex
Combinators of EnumX, for error-handling
-
unchecked_unwrap
Adds an unchecked version of
unwrap()andexpect()to Option and Result -
incomplete
Provides incomplete!(), a compile-time checked version of unimplemented!()
-
require_unsafe_in_body
Make
unsafe fnstill requireunsafeblocks in the function’s body -
structview_derive
Custom derive for structview’s View trait
-
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
iter-progress
Calculate progress of your iterators
-
const-random
Provides compile time random number generation
-
shrinkwraprs
Auto-derive for Rust conversion traits – make working with newtypes a breeze
-
failchain
Ergonomic companion library for failure
-
enumx
Structural enum implemented in enum exchange
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
libffi-sys
Raw Rust bindings for libffi
-
static_assert_macro
Library implementation of so-called
static_assert -
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
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… -
easy-error
Simple error utilities
-
single
Provides the Single trait for extracting the element from a single-element iterator
-
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
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
easy-ext
An attribute macro for easily writing extension trait pattern
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
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…
-
iter-python
Python generator expressions and ‘list’ comprehensions
-
iter-comprehensions
A library for iterator comprehensions
-
quixutils
Common helpers and utils
-
getters-by-type
Derive macro for adding a getter method for each type in the struct
-
kaguya_rs
Functional Programming tools and ADTs
-
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
-
cute
A macro for Python-esque comprehensions
-
iterator-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
join-lazy-fmt
Lazy
separator.join(iterable)method andlazy_format!for Rust -
palette_derive
Automatically implement traits from the palette crate
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
derive-error
Derive macro for Error using macros 1.1
-
overload
Provides a macro to simplify operator overloading
-
newtype_array
A macro to help implementing the standard derived traits on newtype arrays
-
str-macro
The str!() macro, similar to vec![] but for strings
-
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
-
macro_rules_attribute
Use declarative macros as proc_macro attributes or derives
-
aspect-weave
An Aspect Toolkit for Rust
-
precog_iter
An iterator adapter that returns the equivalent of
(iter.next(), iter.peek()) -
iter_vals
On the fly iterator creation
-
fstrings
Python3 fstring interpolation in Rust
-
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.
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
named-block
Macro implementing early-exit-from-any-block
-
phantom-enum
A simple macro library for creating phantom enums
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
option-filter
Option::filter polyfill for Rust 1.26 and older
-
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
-
error-context
Methods and types that help with adding additional context information to error types
-
aspect
An Aspect Toolkit for Rust
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
errors_rust
Just a simple library for error mapping
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
resiter
Helper crate for handling iterators over result
-
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 -
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…
-
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
-
fields-converter-derive
Fields-wise type conversions derive macros
-
d2_iterators_smc
Demo : Dummy upload for checking
-
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 -
ketos_derive
Derive traits for Ketos scripting language
-
stackpin
Crate for data that should be pinned to the stack at the point of declaration
-
big_s
Rust’s missing
Stringliteral -
geopattern
Beautiful generative geometric background images from a string, a Rust implementation of geo_pattern from @jasonlong
-
error-type
Provides a macro for constructing unifying error types
-
error-chain-mini
error-chain for minimalist
-
moveslice
A one-function crate to move chunks in a slice around
-
borrow_with_ref_obj
Versions of Borrow[Mut] that return reference objects (Ex. std::cell::Ref)
-
grange
create range numbers macro
-
lazy-init
Lazy initialization
-
throttled-reader
An io::Read proxy that limits calls to read()
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
displaydoc
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
extension-trait
Macro to declare extension traits
-
diesel-derive-newtype
Automatically connect newtypes to Diesel using their wrapped type
-
tuple-conv
Allows converting tuples of one element to vectors
-
tilde
Using ~ to provide syntax sugar for Rust
-
gtmpl_derive
Derive for gtmpl_value
-
predicates-core
An API for boolean-valued predicate functions
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
disjoint-borrow
Disjoint mutable borrows of slices
-
primitive-from
Provides a trait PrimitiveFrom that is what From is to Into for num_traits::AsPrimitive
-
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
-
error-rules
Error handling without pain
-
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 -
kwarg_macros
Keyword argument plugin
-
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
-
into-result
A simple convenience trait for converting something into a
ResultorOption -
def-mod
Simplifies module implementation routing and statically verifies exports
-
collect_slice
Collect an iterator into a slice
-
nes
New Error System for rust
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
inner
The inner! macro descends into an enum variant. It’s more flexible than try!() and unwrap(), and it works with your enum, too!
-
drop_bomb
A runtime guard for implementing linear types
-
clone-into-box
A library for cloning trait objects
-
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:…
-
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
-
unroll
An attribute-like procedural macro for unrolling for loops
-
size_hint
A very simple library to provide a size_hint for an iterator which does not provide it’s own
-
tylift
Lift enum variants to the type-level
-
lang_extension
Rust Lang Extension
-
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
-
validated-slice
Helper macros to implement std traits for custom validated slice types
-
di
Dependency injection container
-
scopefunc
A trait defining kotlin-like scope functions
-
mysql_enum
Convert between Rust enum and MySQL enum
-
boow
Borrow Or oWnedsmart pointer. Alternative to Cow. -
compile_msg
A plugin for emitting errors, warnings and notes to the developer at compile time
-
pgc-derive
Garbage collector derive plugin for pgc
-
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
-
field_types
Some derive macros for deriving enums, corresponding to the fields of structs
-
with-macro
Syntactic sugar for calling methods
-
axpy
Macro for auto-vectorizing n-ary linear combinations
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
err-context
Lightweight context layers for stdandard library errors
-
powerset-enum
A poor man’s anonymous enum
-
counted-array
Macro for declaring fixed-size arrays without counting elements by hand. Supports lazy_static.
-
shawshank
An efficient, generic internment structure
-
zkp-macros-lib
Library of procedural macros implemented using
proc_macro2 -
sconcat
String concatenation
-
enum_macro
Useful macro for enum
-
assert-impl
Macro for static assert types implement a trait or not
-
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…
-
detach
helper type for being able to detach/reatach a member item
-
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
-
conditional
Provides a conditional! macro which lets you use the syntax of the conditional operator (also known as the ternary operator) in Rust
-
bidir_iter
Bidirectional iterators
-
slugify
Macro for flexible slug generation
-
unzip-n
Procedural macro to generate
unzipfor iterators over n-sized tuples -
splop
Helper functions to determine the first/last repetition of something
-
lfa_derive
Macros for LFA
-
tyenum
Attribute macro for type enums
-
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
-
miow
A zero overhead I/O library for Windows, focusing on IOCP and Async I/O abstractions
-
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
-
take-until
A take until extension for iterators
-
format-buf
Drop-in replacement for format! macro, which can write to existing buffer
-
glitchup_derive
Helper macros for glitchup
-
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.
-
str-concat
Concatenate two adjacent string slices
-
split_by
Split anything implementing Read trait by multiple sequences of bytes
-
tyname
Retrieve type names during program execution on stable Rust
-
macro_lisp
Lisp-like DSL for Rust language
-
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
function_group
A macro to hack in function overloading to 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
-
tilde_derive
Using ~ to provide syntax sugar for Rust
-
static-cond
Macro for performing comparisons during macro expansion
-
zkp-error-utils
Assertion like macros for returning
Result::Err -
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
-
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
-
pinpoint
Crate for pinned references
-
closure
A macro for capturing variables on a per variable basis
-
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…
-
ternop
A tiny macro that implements a ternary operator for Rust
-
zkp-macros-decl
Procedural macros
-
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
-
pathsep
a small macro to enable easy path construction in other macro calls
-
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
-
wrap
Generic function wrapping
-
any-error
When you just want to use
?in peace -
approx
Approximate floating point equality comparisons and assertions
-
derive_is_enum_variant
Automatically derives
is_dogandis_catmethods forenum Pet { Dog, Cat } -
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
-
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
-
mem_macros
align_of and size_of as a macro, to avoid turbofish notation
-
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
-
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
-
multi-structs
Macro for generating a merged struct from multiple sub-structs