typenum 1.3.2

Typenum is a Rust library for type-level numbers evaluated at compile time. It currently supports bits, unsigned integers, and signed integers.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use std::env;
use std::fs::File;
use std::io::Write;
use std::path::Path;
use std::fmt;

pub enum UIntCode {
    Term,
    Zero(Box<UIntCode>),
    One(Box<UIntCode>),
}

pub enum IntCode {
    Zero,
    Pos(Box<UIntCode>),
    Neg(Box<UIntCode>),
}

impl fmt::Display for UIntCode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UIntCode::Term => write!(f, "UTerm"),
            UIntCode::Zero(ref inner) => write!(f, "UInt<{}, B0>", inner),
            UIntCode::One(ref inner) => write!(f, "UInt<{}, B1>", inner),
        }
    }
}

impl fmt::Display for IntCode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            IntCode::Zero => write!(f, "Z0"),
            IntCode::Pos(ref inner) => write!(f, "PInt<{}>", inner),
            IntCode::Neg(ref inner) => write!(f, "NInt<{}>", inner),
        }
    }
}

pub fn gen_uint(u: u64) -> UIntCode {
    let mut result = UIntCode::Term;
    let mut x = 1u64 << 63;
    while x > u {
        x = x >> 1
    }
    while x > 0 {
        result = if x & u > 0 {
            UIntCode::One(Box::new(result))
        } else {
            UIntCode::Zero(Box::new(result))
        };
        x = x >> 1;
    }
    result
}

pub fn gen_int(i: i64) -> IntCode {
    if i > 0 {
        IntCode::Pos(Box::new(gen_uint(i as u64)))
    } else if i < 0 {
        IntCode::Neg(Box::new(gen_uint(i.abs() as u64)))
    } else {
        IntCode::Zero
    }
}

#[cfg_attr(feature="no_std", deprecated(
    since="1.3.0",
    note="the `no_std` flag is no longer necessary and will be removed in the future"))]
pub fn no_std() {}

// fixme: get a warning when testing without this
#[allow(dead_code)]
fn main() {
    // If you change this, change also the comments in src/consts.rs
    let highest: u64 = 1024;


    let first2: u32 = (highest as f64).log(2.0) as u32 + 1;
    let first10: u32 = (highest as f64).log(10.0) as u32 + 1;
    let uints = (0..(highest + 1))
                    .chain((first2..64).map(|i| 2u64.pow(i)))
                    .chain((first10..20).map(|i| 10u64.pow(i)));


    let out_dir = env::var("OUT_DIR").unwrap();
    let dest = Path::new(&out_dir).join("consts.rs");

    let mut f = File::create(&dest).unwrap();

    no_std();

    // Header stuff here!
    f.write(b"
use uint::{UInt, UTerm};
use int::{PInt, NInt};

pub use bit::{B0, B1};
pub use int::Z0; // re-export for convenience.
")
     .unwrap();

    for u in uints {
        write!(f, "pub type U{} = {};\n", u, gen_uint(u)).unwrap();
        if u <= ::std::i64::MAX as u64 && u != 0 {
            let i = u as i64;
            write!(f, "pub type P{} = {};\n", i, gen_int(i)).unwrap();
            write!(f, "pub type N{} = {};\n", i, gen_int(-i)).unwrap();
        }
    }
}