septem 1.1.0

A library for parsing and working with Roman numerals
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

#![feature(try_from)]
use std::convert::{TryFrom};
use std::fmt::{Display, Formatter, Result as FmtResult};

#[derive(Clone, Copy)]
enum Numeral {
    I,
    V,
    X,
    L,
    C,
    D,
    M
}

impl TryFrom<u32> for Numeral {
    type Error = ();

    fn try_from(num: u32) -> Result<Numeral, ()> {
        use crate::Numeral::*;
        match num {
            1 => Ok(I),
            5 => Ok(V),
            10 => Ok(X),
            50 => Ok(L),
            100 => Ok(C),
            500 => Ok(D),
            1000 => Ok(M),
            _ => Err(())
        }
    }
}

impl From<Numeral> for u32 {
    fn from(numeral: Numeral) -> u32 {
        use crate::Numeral::*;
        match numeral {
            I => 1,
            V => 5,
            X => 10,
            L => 50,
            C => 100,
            D => 500,
            M => 1000
        }
    }
}

impl From<&Numeral> for char {
    fn from(numeral: &Numeral) -> char {
        use crate::Numeral::*;
        match *numeral {
            I => 'I',
            V => 'V',
            X => 'X',
            L => 'L',
            C => 'C',
            D => 'D',
            M => 'M'
        }
    }
}

impl Display for Numeral {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        write!(f, "{}", char::from(self))
    }
}


pub struct Roman {
    numerals: Vec<Numeral>
}

impl Display for Roman {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        let nums = self.numerals
            .iter()
            .map(|n| char::from(n))
            .collect::<String>();
        write!(f, "{}", nums)
    }
}

impl From<u32> for Roman {
    fn from(mut num: u32) -> Self {
        let numerals = [Numeral::M, Numeral::C, Numeral::X, Numeral::I]
            .iter()
            .fold(vec![], |mut acc, &step| {
                let num_step: u32 = step.into();
                if num >= num_step {
                    let current = num - (num % num_step);
                    acc.extend(Roman::partial_convert(current, step));
                    num -= current;
                }
                acc
            });

        Roman {
            numerals
        }
    }
}

impl Roman {
    fn partial_convert(mut num: u32, base: Numeral) -> Vec<Numeral> {
        let mut numerals = vec![];
        let step: u32 = base.into();

        while num > 0 {
            match Numeral::try_from(num) {
                Ok(n) => {
                    numerals.push(n);
                    num = 0;
                },
                Err(_) => {
                    match Numeral::try_from(num + step) {
                        Ok(n) => {
                            numerals.push(n);
                            numerals.push(base);
                            num = 0;
                        },
                        Err(_) => {
                            numerals.push(base);
                            num -= step;
                        }
                    }
                }
            }
        }
        numerals.reverse();
        numerals
    }
}