nyandere 0.1.2

i help with keeping track of purchases. meow
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

use std::fmt;

use num_bigint::Sign;

use crate::{
    ext::{
        business::{Balance, Money, MoneyRef, Value},
        shop::Gtin,
    },
    runtime::model::{Concept, Entity, Object},
};

impl fmt::Display for Gtin {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "gtin {} ({} digits)", self.get(), self.digits())
    }
}

impl fmt::Display for Money {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        MoneyRef::from(self).fmt(f)
    }
}

impl fmt::Display for MoneyRef<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let whole = self.0 / 100u8;
        let frac = self.0 % 100u8;

        write!(f, "{whole}.{frac:02} €")
    }
}

impl fmt::Display for Value {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let sign = match self.0.sign() {
            Sign::Minus => "-",
            _ => "",
        };
        let mag = Money(self.0.magnitude().clone());

        write!(f, "{sign}{mag}")
    }
}

impl fmt::Display for Balance {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let magnitude = self.amount().abs();
        // with format_args! works on nightly 2025-08-07 but not stable. hm. well
        let standing = match self.amount().sign() {
            Sign::Minus => format!("owes {magnitude} to"),
            Sign::NoSign => "is even with".to_string(),
            Sign::Plus => format!("is owed {magnitude} by"),
        };

        write!(
            f,
            "{} {} {}",
            self.between().source(),
            standing,
            self.between().target(),
        )
    }
}

impl fmt::Display for Entity {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "entity {}", self.name())
    }
}

impl fmt::Display for Concept {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "concept {}", self.name())
    }
}

impl fmt::Display for Object {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "object ")?;

        if let Some(name) = self.name() {
            write!(f, "{name}")?;
        } else {
            write!(f, "<anonymous>")?;
        }

        if let Some(parent) = self.parent() {
            write!(f, " instance of {parent}")?;
        }

        Ok(())
    }
}