Crate id_derive

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.