devault

A more flexible alternative to deriving Default.

Deriving Devault behaves the same as deriving Default, but includes some added benefits.

Added Benefits

devault allows for specifying specific default values for fields, even if Default is not implemented for their respective type.

```rust use devault::Devault;

const C: u32 = 10;

[derive(Debug, Devault, PartialEq)]

struct Foo { a: u8, #[devault("1.0")] b: f32, #[devault("C")] c: u32, #[devault("Bar(0.5)")] d: Bar, }

[derive(Debug, PartialEq)]

struct Bar(f32);

fn main() { let foo = Foo::default(); asserteq!(foo.a, 0); asserteq!(foo.b, 1.0); asserteq!(foo.c, C); asserteq!(foo.d, Bar(0.5)); } ```

It can be derived for enums too, with the requirement that a default value is provided.

```rust use devault::Devault;

[derive(Debug, Devault, PartialEq)]

[devault("Foo::B(128)")]

enum Foo { A, B(u8), }

fn main() { assert_eq!(Foo::default(), Foo::B(128)); } ```

devault can generate associated constants and/or functions for constructing a field's default value outside of the Default implementation.

```rust use devault::Devault;

[derive(Debug, Devault, PartialEq)]

struct Foo { #[devault("1.0", constant)] a: f32, #[devault("10", function)] b: u32, #[devault("0.5", constant = "INITC", function = "startc")] c: f32, }

[derive(Debug, Devault, PartialEq)]

[devault("Bar::B(42)", constant)]

enum Bar { A, B(u8), }

fn main() { asserteq!(Foo::DEFAULTA, 1.0); asserteq!(Foo::defaultb(), 10); asserteq!(Foo::INITC, 0.5); asserteq!(Foo::startc(), 0.5); assert_eq!(Bar::DEFAULT, Bar::B(42)); } ```

TODO

• Support generic types.