konvert 0.3.1

unit converter without any dependencies
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

use konvert::{Calculation, Conversion, find_conversion_path};
use std::collections::HashSet;
use std::{env, process};

fn build_conversions() -> Vec<Conversion> {
    let conversions: Vec<(&str, Calculation, &str)> = vec![
        ("kg", Calculation::Rate(2.20462262), "lbs"),
        ("kg", Calculation::Rate(1000.0), "g"),
        ("km", Calculation::Rate(0.62137119), "mi"),
        ("km", Calculation::Rate(1000.0), "m"),
        ("m", Calculation::Rate(3.2808399), "ft"),
        ("ft", Calculation::Rate(12.0), "in"),
        ("yd", Calculation::Rate(3.0), "ft"),
        ("oz", Calculation::Rate(28.4130625), "ml"),
        ("pt", Calculation::Rate(568.26125), "ml"),
        ("l", Calculation::Rate(1000.0), "ml"),
        ("l", Calculation::Rate(10.0), "dl"),
        ("gal", Calculation::Rate(8.0), "pt"),
        (
            "C",
            Calculation::Func {
                forward: |c| c * 9.0 / 5.0 + 32.0,
                reverse: |f| (f - 32.0) * 5.0 / 9.0,
            },
            "F",
        ),
        (
            "C",
            Calculation::Func {
                forward: |c| c + 273.15,
                reverse: |k| k - 273.15,
            },
            "K",
        ),
    ];
    conversions
        .iter()
        .flat_map(|(s, c, t)| {
            let c = Conversion::new(s, c.clone(), t);
            let r = c.invert();
            [c, r]
        })
        .collect()
}

fn fail_usage() -> ! {
    eprintln!("usage: konverter VALUE SOURCE_UNIT TARGET_UNIT");
    process::exit(1);
}

fn fail_unsupported_unit(unit: &str) -> ! {
    eprintln!("unit '{unit}' not supported");
    process::exit(1);
}

enum Command {
    List,
    Conversion(f64, String, String),
}

fn parse_cli_args() -> Command {
    let mut args = env::args();
    args.next(); // "konverter"
    let value = match args.next() {
        Some(s) => match s.parse::<f64>() {
            Ok(v) => v,
            Err(_) => fail_usage(),
        },
        None => {
            return Command::List;
        }
    };
    let source_unit = match args.next() {
        Some(s) => s,
        None => fail_usage(),
    };
    let target_unit = match args.next() {
        Some(s) => s,
        None => fail_usage(),
    };
    Command::Conversion(value, source_unit, target_unit)
}

fn main() {
    let conversions = build_conversions();
    let all_units: HashSet<&String> = conversions
        .iter()
        .flat_map(|c| [&c.source_unit, &c.target_unit])
        .collect();

    match parse_cli_args() {
        Command::List => {
            let mut units: Vec<&String> = all_units.into_iter().collect();
            units.sort();
            for unit in units {
                println!("{unit}");
            }
        }
        Command::Conversion(value, source_unit, target_unit) => {
            if !all_units.contains(&source_unit) {
                fail_unsupported_unit(&source_unit);
            }
            if !all_units.contains(&target_unit) {
                fail_unsupported_unit(&target_unit);
            }

            match find_conversion_path(&source_unit, &target_unit, &conversions) {
                Some(path) => {
                    let result = path.iter().fold(value, |acc, e| match &e.calculation {
                        Calculation::Rate(r) => acc * r,
                        Calculation::Func { forward, .. } => forward(acc),
                    });
                    println!("{result}");
                }
                None => {
                    eprintln!("conversion from '{source_unit}' to '{target_unit}' undefined");
                }
            }
        }
    }
}