Crate amplify

Expand description

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

Minimum supported rust compiler version (MSRV): 1.46 (stable channel)

Re-exports§

num: Custom-sized numeric types
strategy: This is a trick for rust compiler helping to distinguish types implementing mutually-exclusive traits (required until negative trait impls will be there) Implemented after concept by Martin Habovštiak martin.habovstiak@gmail.com

default: Shorthand for Default::default()
dumb: Shorthand for Dumb::dumb()
empty: This macro allows more semantically-clear code (which can be used especially with structure initialization), indicating that instead of type value we are generating empty collection types
none: This macro allows more semantically-clear code (which can be used especially with structure initialization), indicating that instead of type value we are generating no value at all (empty collection or data structure filled with information indicating absence of data)
s: Macro for quick & simple &str -> String conversion:
zero: This macro allows more semantically-clear code (which can be used especially with structure initialization), indicating that instead of type value we are generating zero values (int types or byte slices filled with zeros)

Array: Wrapper type for all fixed arrays implementing many important traits, so types based on it can simply derive their implementations.
FromSliceError: Error when slice size mismatches array length.

AsAny: Trait AsAny allows simple conversion of any type into a generic “thick” pointer &dyn Any (see Any), that can be later converted back to the original type with a graceful failing for all other conversions. For simple conversions it is recommended to use #[derive(AsAny)] macro from amplify_derive crate (see amplify_derive::AsAny).
ByteArray: Trait which does a blanket implementation for all types wrapping Arrays
Dumb: Used as an alternative to default for test and prototyping purposes, when a type can’t have a default value, but you need to generate some dumb data.
JoinSplit: Trait for splittable streams and other types, which can be separated into some two types (JoinSplit::A, JoinSplit::B), like a reader and writer streams.
RawArrayDeprecated: Trait which does a blanket implementation for all types wrapping Arrays
Wrapper: Trait defining wrapped types (“newtypes” in rust terminology). Wrapped types are used for allowing implemeting foreign traits to foreign types: https://doc.rust-lang.org/stable/rust-by-example/generics/new_types.html
WrapperMut: Trait allowing mutable reference borrowing for the wrapped inner type.

Bytes: Wrapper type for all array-based bytes implementing many important traits, so types based on it can simply derive their implementations.
Bytes4: Wrapper type for all array-based 32-bit types implementing many important traits, so types based on it can simply derive their implementations.
Bytes16: Wrapper type for all array-based 128-bit types implementing many important traits, so types based on it can simply derive their implementations.
Bytes20: Wrapper type for all array-based 160-bit types implementing many important traits, so types based on it can simply derive their implementations.
Bytes32: Wrapper type for all array-based 256-bit types implementing many important traits, so types based on it can simply derive their implementations.
Bytes64: Wrapper type for all array-based 512-bit types implementing many important traits, so types based on it can simply derive their implementations.
Bytes32StrRev: Wrapper type for all array-based 256-bit types implementing many important traits, so types based on it can simply derive their implementations.

AsAny: Trait amplify::AsAny allows simple conversion of any type into a generic “thick” pointer &dyn Any (see [::core::any::Any]), that can be later converted back to the original type with a graceful failing for all other conversions. AsAny derive macro allows to implement this trait for arbitrary time without much hussle:
Display: Usage
Error: Error derive macro works to the full extend only when other derive macros are used. With #[derive(Display)] and [display(doc_comments)] it uses doc comments for generating error descriptions; with #[derive(From)] it may automatically implement transofrations from other error types.
From: Implements From trait for the whole entity and/or its separate fields. Works well with #[derive(Error)] and, in many cases may require [Default] implementation (for details, pls see Examples below)
Getters: Derives getter methods for structures. The return type and naming of the methods depends on the provided attribute arguments.
Wrapper: Creates rust new type wrapping existing type. Can be used in structures containing multiple named or unnamed fields; in this case the field you’d like to wrap should be marked with #[wrap] attribute; otherwise the first field is assumed to be the wrapped one.
WrapperMut: Derives WrapperMut and allows deriving other traits accessing the wrapped type which require mutable access to the inner type. Requires that the type already implements amplify::Wrapper.