Crate derive_tools

Collection of derives which extend STD.

Module :: derive_tools

Basic use-case

{
  use derive_tools::*;

  #[ derive( From, InnerFrom, Display, FromStr, PartialEq, Debug ) ]
  #[ display( "{a}-{b}" ) ]
  struct Struct1
  {
    a : i32,
    b : i32,
  }

  // derived InnerFrom
  let src = Struct1 { a : 1, b : 3 };
  let got : ( i32, i32 ) = src.into();
  let exp = ( 1, 3 );
  assert_eq!( got, exp );

  // derived From
  let src : Struct1 = ( 1, 3 ).into();
  let got : ( i32, i32 ) = src.into();
  let exp = ( 1, 3 );
  assert_eq!( got, exp );

  // derived Display
  let src = Struct1 { a : 1, b : 3 };
  let got = format!( "{}", src );
  let exp = "1-3";
  println!( "{}", got );
  assert_eq!( got, exp );

  // derived FromStr
  use std::str::FromStr;
  let src = Struct1::from_str( "1-3" );
  let exp = Ok( Struct1 { a : 1, b : 3 } );
  assert_eq!( src, exp );

}

To add to your project

cargo add derive_tools

Try out from the repository

git clone https://github.com/Wandalen/wTools
cd wTools
cd examples/derive_tools_trivial
cargo run

Re-exports

• pub use super::wtools;

Modules

• _private_phf_reexport_for_macro_if_phf_feature
  Rust-PHF is a library to generate efficient lookup tables at compile time using perfect hash functions.
• additional_attributes
  Documentation for Additional Attributes
• clone_dyn
• dependency
  Namespace with dependencies.
• exposed
  Exposed namespace of the module.
• orphan
  Orphan namespace of the module.
• prelude
  Prelude to use essentials: use my_module::prelude::*.
• protected
  Protected namespace of the module.
• wtools
  Types, which are extension of std.

Macros

• from
  Variadic constructor.

Enums

• ParseError
  The ParseError enum is a collection of all the possible reasons an enum can fail to parse from a string.

Traits

• Add
  The addition operator +.
• AddAssign
  The addition assignment operator +=.
• AsStaticRefDeprecated
  A cheap reference-to-reference conversion. Used to convert a value to a reference value with 'static lifetime within generic code.
• Div
  The division operator /.
• DivAssign
  The division assignment operator /=.
• EnumCount
  A trait for capturing the number of variants in Enum. This trait can be autoderived by strum_macros.
• EnumMessage
  Associates additional pieces of information with an Enum. This can be autoimplemented by deriving EnumMessage and annotating your variants with #[strum(message="...")].
• EnumProperty
  EnumProperty is a trait that makes it possible to store additional information with enum variants. This trait is designed to be used with the macro of the same name in the strum_macros crate. Currently, the only string literals are supported in attributes, the other methods will be implemented as additional attribute types become stabilized.
• Error
  Error is a trait representing the basic expectations for error values, i.e., values of type E in Result<T, E>.
• From_0
  Constructor without arguments. Alias of Default.
• From_1
  Constructor with single argument.
• From_2
  Constructor with two arguments.
• From_3
  Constructor with three arguments.
• Index
  Used for indexing operations (container[index]) in immutable contexts.
• IndexMut
  Used for indexing operations (container[index]) in mutable contexts.
• Into1
  value-to-value conversion that consumes the input value. Change left and rught, but keep semantic of `From_1``.
• IntoEnumIterator
  This trait designates that an Enum can be iterated over. It can be auto generated using strum_macros on your behalf.
• IntoIterator
  Conversion into an Iterator.
• Mul
  The multiplication operator *.
• MulAssign
  The multiplication assignment operator *=.
• Not
  The unary logical negation operator !.
• Sub
  The subtraction operator -.
• SubAssign
  The subtraction assignment operator -=.
• Sum
  Trait to represent types that can be created by summing up an iterator.
• TryInto
  An attempted conversion that consumes self, which may or may not be expensive.
• VariantIterator
• VariantMetadata
• VariantNames
  A trait for retrieving the names of each variant in Enum. This trait can be autoderived by strum_macros.

Functions

• _clone_boxed
  Clone boxed dyn.

Attribute Macros

• clone_dyn
  Derive macro to generate former for a structure. Former is variation of Builder Pattern.

Derive Macros

• Add
  What #[derive(Add)] generates
• AddAssign
  What #[derive(AddAssign)] generates
• AsMut
  Derive macro to implement AsMut when-ever it’s possible to do automatically.
• AsRef
  Derive macro to implement AsRef when-ever it’s possible to do automatically.
• AsRefStr
  Converts enum variants to &'static str.
• AsStaticStr
• Constructor
  What #[derive(Constructor)] generates
• Deref
  Derive macro to implement Deref when-ever it’s possible to do automatically.
• DerefMut
  Derive macro to implement Deref when-ever it’s possible to do automatically.
• Display
• Div
  What #[derive(Mul)] generates
• DivAssign
  What #[derive(MulAssign)] generates
• EnumCount
  Add a constant usize equal to the number of variants.
• EnumDiscriminants
  Generate a new type with only the discriminant names.
• EnumIs
  Generated is_*() methods for each variant. E.g. Color.is_red().
• EnumIter
  Creates a new type that iterates of the variants of an enum.
• EnumMessage
  Add a verbose message to an enum variant.
• EnumProperty
  Add custom properties to enum variants.
• EnumString
  Converts strings to enum variants based on their name.
• EnumTryAs
  Generated try_as_*() methods for all tuple-style variants. E.g. Message.try_as_write().
• EnumVariantNames
  Implements Strum::VariantNames which adds an associated constant VARIANTS which is an array of discriminant names.
• Error
  Using #[derive(Error)]
• From
  Provides an automatic From implementation for struct wrapping a single value.
• FromInner
  Alias for derive From. Provides an automatic From implementation for struct wrapping a single value.
• FromRepr
  Add a function to enum that allows accessing variants by its discriminant
• FromStr
• Index
  What #[derive(Index)] generates
• IndexMut
  What #[derive(IndexMut)] generates
• InnerFrom
  Derive macro to implement From converting outer type into inner when-ever it’s possible to do automatically.
• IntoIterator
  Using #[derive(IntoIterator)]
• IntoStaticStr
  Implements From<MyEnum> for &'static str on an enum.
• IsVariant
  What #[derive(IsVariant)] generates
• Mul
  What #[derive(Mul)] generates
• MulAssign
  What #[derive(MulAssign)] generates
• Not
  What #[derive(Not)] generates
• Sub
  What #[derive(Add)] generates
• SubAssign
  What #[derive(AddAssign)] generates
• Sum
  Using #[derive(Sum)]
• ToString
  implements std::string::ToString on an enum
• TryInto
  What #[derive(TryInto)] generates
• Unwrap
  What #[derive(Unwrap)] generates
• VariadicFrom
  Derive macro to implement default constructors From_0, From_1, From_2, From_3.