Crate id_derive

Source
Expand description

The goal of this crate is to provide an easy newtype implementation for different types of strongly-typed identifiers.

§Motivation

Very often, I find myself utilizing many integer-based IDs. In effort to make it strongly typed, one typically uses a “newtype” pattern.

struct MyId(usize);

let id = MyId(1);
assert_eq!(id.0, 1);
assert_eq!(MyId(id.0 + 10).0, MyId(11).0);

Notice how you have to access the tuple element with .0 any time you want to perform any type of operations on the actual integer. One could approach this by implementing Deref trait but this is strongly discouraged; see: Rust Docs, API Guidelines.

This crate introduces a set of macros implementing certain operations on an ID.

§Examples

In the simplest case, you only need to a single derive Id.

#[derive(Id, Debug, PartialEq, Copy, Clone)]
struct MyId(usize);
// Construct from the inner type.
let mut id = MyId::from(1);
// Construct inner type from `MyId`.
assert_eq!(usize::from(id), 1);
// Display.
assert_eq!(&id.to_string(), "1");
// Add two IDs or inner to ID.
assert_eq!(id + MyId(1), MyId(2));
assert_eq!(id + 1, MyId(2));
id += 1;
id += MyId(1);
assert_eq!(id, MyId(3));
// Subtract
assert_eq!(id - MyId(1), MyId(2));
assert_eq!(id - 1, MyId(2));
id -= 1;
id -= MyId(1);
assert_eq!(id, MyId(1));
// Multiply
assert_eq!(id * MyId(2), MyId(2));
assert_eq!(id * 2, MyId(2));
id *= 2;
id *= MyId(2);
assert_eq!(id, MyId(4));
// Divide
assert_eq!(id / MyId(2), MyId(2));
assert_eq!(id / 2, MyId(2));
id /= 2;
id /= MyId(2);
assert_eq!(id, MyId(1));

Alternatively, you may devine only a subset of available derives:

#[derive(Display, FromInner, IntoInner, Add, AddInner)]
struct MyId(usize);

Derive Macros§

Add
Implements Add<Self>.
AddAssign
Implements AddAssign<Self>.
AddAssignInner
Implements AddAssign<T> where T is the type of identifier.
AddInner
Implements Add<T> where T is the type of identifier.
Convert
Equivalent to derive(IntoInner, FromInner).
Display
Implements Display.
Div
Implements Div<Self>.
DivAssign
Implements DivAssign<Self>.
DivAssignInner
Implements DivAssign<T> where T is the type of identifier.
DivInner
Implements Div<T> where T is the type of identifier.
FromInner
Implements From<T> where T is the type of identifier.
Id
Implement all available traits.
IntoInner
Implements From<Self> for T where T is the type of identifier.
Mul
Implements Mul<Self>.
MulAssign
Implements MulAssign<Self>.
MulAssignInner
Implements MulAssign<T> where T is the type of identifier.
MulInner
Implements Mul<T> where T is the type of identifier.
Sub
Implements Sub<Self>.
SubAssign
Implements SubAssign<Self>.
SubAssignInner
Implements SubAssign<T> where T is the type of identifier.
SubInner
Implements Sub<T> where T is the type of identifier.