MultiType

MultiType is Rust a crate for generalising fundamental types via traits.

MultiType provides traits such as Unsigned and FloatingPoint to abstract over a set of equivalent primitive types. These traits are intended to provide one-to-one copies of the primary interfaces that the primitive types define.

Overview

The complete list of abstraction traits is:

Arithmetic
- Integral
  - Signed
  - Unsigned
- FloatingPoint

Examples

A generic Fibonacci sequence:

use multitype::Uint;

fn f<T: Uint>(x: T) -> T {
    let mut y    = T::from(0_u8);
    let mut y_m1 = T::from(0_u8);
    let mut y_m2 = T::from(1_u8);

    let mut i = T::from(0_u8);
    while i < x {
        y = y_m1 + y_m2;

        y_m2 = y_m1;
        y_m1 = y;

        i += T::from(1_u8);
    }

    y
}

assert_eq!(f(0_u8),    0);
assert_eq!(f(1_u8),    1);

assert_eq!(f(2_u16),   1);
assert_eq!(f(3_u16),   2);

assert_eq!(f(4_u32),   3);
assert_eq!(f(5_u32),   5);

assert_eq!(f(6_u64),   8);
assert_eq!(f(7_u64),  13);

assert_eq!(f(8_u128), 21);
assert_eq!(f(9_u128), 34);

Feature gates

Default features:

alloc
std

Dependency features:

alloc: Enables compatibility with alloc facilities
std: Enables compatibility with std facilities

Unstable features:

f16: Enables support for f16
f128: Enables support for f128
unstable_docs: Enables unstable documentation features

Unstable gates can be expected to be removed as their facilities stabilise.

MSRV policy

The goal of MultiType is to provide generic traits that bind as much of the standard interfaces as possible. Items that are added after the MSRV will be backported.

Copyright and licence