lemma-engine 0.8.19

A language that means business.
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Magnitude-preserving math (`ceil`, `floor`, `round`, `abs`) on quantity operands.

use lemma::{Engine, SourceType};
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;

fn source() -> SourceType {
    SourceType::Path(Arc::new(PathBuf::from("quantity_math_ops.lemma")))
}

fn load_ok(code: &str) {
    let mut engine = Engine::new();
    engine
        .load(code, source())
        .unwrap_or_else(|errors| panic!("spec must load: {errors:?}"));
}

fn load_err(code: &str) -> String {
    let mut engine = Engine::new();
    match engine.load(code, source()) {
        Ok(()) => panic!("expected planning error"),
        Err(errors) => errors
            .iter()
            .map(|error| error.to_string())
            .collect::<Vec<_>>()
            .join("; "),
    }
}

fn eval_display(code: &str, spec: &str, rule: &str, data: HashMap<String, String>) -> String {
    let mut engine = Engine::new();
    engine.load(code, source()).expect("spec must load");
    let response = engine
        .run(None, spec, None, data, false, None)
        .expect("spec must evaluate");
    response
        .results
        .get(rule)
        .unwrap_or_else(|| panic!("rule '{rule}' missing"))
        .display
        .clone()
        .expect("rule must have display value")
}

#[test]
fn ceil_duration_as_weeks() {
    let code = r#"spec duration_math
uses lemma units
data storage_duration: 10 days
rule weeks_billed: ceil (storage_duration as weeks)"#;
    load_ok(code);
    let displayed = eval_display(code, "duration_math", "weeks_billed", HashMap::new());
    assert!(
        displayed.contains('2') && displayed.to_lowercase().contains("week"),
        "10 days as weeks ceiled must be 2 weeks, got: {displayed}"
    );
}

#[test]
fn warehousing_storage_cost_with_ceil_weeks() {
    let code = r#"spec warehousing
uses lemma units
data money: quantity -> unit eur 1
data rate: quantity -> unit eur_per_week eur/week
data storage_per_pallet_per_week: 10 eur_per_week
data storage_duration: 10 days
rule storage_cost_per_pallet:
  storage_per_pallet_per_week * ceil (storage_duration as weeks)"#;
    load_ok(code);
    let displayed = eval_display(
        code,
        "warehousing",
        "storage_cost_per_pallet",
        HashMap::new(),
    );
    assert!(
        displayed.contains("20") && displayed.to_lowercase().contains("eur"),
        "10 eur/week * ceil(10 days as weeks) must be 20 eur, got: {displayed}"
    );
}

#[test]
fn floor_round_abs_on_quantity() {
    let code = r#"spec mass_math
uses lemma units
data mass: quantity -> unit kilogram 1
data weight: 2.6 kilogram
rule floored: floor weight
rule rounded: round weight
rule absolute: abs (0 kilogram - weight)"#;
    load_ok(code);
    assert_eq!(
        eval_display(code, "mass_math", "floored", HashMap::new()),
        "2 kilogram"
    );
    assert_eq!(
        eval_display(code, "mass_math", "rounded", HashMap::new()),
        "3 kilogram"
    );
    assert_eq!(
        eval_display(code, "mass_math", "absolute", HashMap::new()),
        "2.6 kilogram"
    );
}

#[test]
fn sqrt_on_quantity_rejected_at_plan() {
    let code = r#"spec bad_math
uses lemma units
data storage_duration: 10 days
rule bad: sqrt (storage_duration as weeks)"#;
    let error = load_err(code);
    assert!(
        error.to_lowercase().contains("sqrt") && error.to_lowercase().contains("number"),
        "sqrt on quantity must fail at plan time, got: {error}"
    );
}

#[test]
fn ceil_anonymous_compound_at_rule_boundary_rejected_at_plan() {
    let code = r#"spec compound_ceil
uses lemma units
data length: quantity -> unit meter 1
data dist: 100 meter
data time: 20 seconds
rule bad:
  ceil (dist / time)"#;
    let error = load_err(code);
    assert!(
        error.to_lowercase().contains("anonymous"),
        "ceil on dist/time at rule boundary must fail at plan time, got: {error}"
    );
}

#[test]
fn ceil_negative_duration_as_weeks() {
    let code = r#"spec negative_duration
uses lemma units
data storage_duration: -10 days
rule weeks_billed: ceil (storage_duration as weeks)"#;
    load_ok(code);
    let displayed = eval_display(code, "negative_duration", "weeks_billed", HashMap::new());
    assert!(
        displayed.contains("-1") && displayed.to_lowercase().contains("week"),
        "-10 days as weeks ceiled must be -1 weeks, got: {displayed}"
    );
}