MultiType

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

MultiType provideds 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

Note that all traits provided by this crate are sealed and cannot be implemented by third-party crates (at least currently).

Examples

A generic Fibonacci sequence:

use multitype::Uint;

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

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

        y_m2 = y_m1;
        y_m1 = y;

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

    y
}

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

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

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

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

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
nightly_backports: Enables backports for nightly items
unstable_docs: Enables unstable documentation features

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

SemVer policy

Nightly backports will match the current, nightly interfaces provided by rustc. A change in rustc will thus be reflected here along with a bump in the minor version.

Conversely, when a nightly item is stabilised in rustc, the corresponding nightly backport will be released from the feature gate in a minor version bump.

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

MultiType is distributed under either an MIT licence (see LICENCE-MIT) or version 2.0 of the Apache License (see LICENCE-APACHE), at your option.