tawasuyu/taffy

1use core::ops::{Add, Div, Mul, Sub};
2
3#[derive(Copy, Clone, PartialEq, Debug)]
4#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
5pub enum Number {
6    Defined(f32),
7    Undefined,
8}
9
10pub trait OrElse<T> {
11    fn or_else(self, other: T) -> T;
12}
13
14impl Default for Number {
15    fn default() -> Self {
16        Self::Undefined
17    }
18}
19
20impl OrElse<f32> for Number {
21    fn or_else(self, other: f32) -> f32 {
22        match self {
23            Number::Defined(val) => val,
24            Number::Undefined => other,
25        }
26    }
27}
28
29impl OrElse<Self> for Number {
30    fn or_else(self, other: Self) -> Self {
31        match self {
32            Number::Defined(_) => self,
33            Number::Undefined => other,
34        }
35    }
36}
37
38impl Number {
39    pub fn is_defined(self) -> bool {
40        match self {
41            Number::Defined(_) => true,
42            Number::Undefined => false,
43        }
44    }
45
46    pub fn is_undefined(self) -> bool {
47        match self {
48            Number::Defined(_) => false,
49            Number::Undefined => true,
50        }
51    }
52}
53
54pub trait MinMax<In, Out> {
55    fn maybe_min(self, rhs: In) -> Out;
56    fn maybe_max(self, rhs: In) -> Out;
57}
58
59impl MinMax<Self, Self> for Number {
60    fn maybe_min(self, rhs: Self) -> Self {
61        match (self, rhs) {
62            (Number::Defined(l), Number::Defined(r)) => Number::Defined(l.min(r)),
63            (Number::Defined(_), _) => self,
64            _ => Number::Undefined,
65        }
66    }
67
68    fn maybe_max(self, rhs: Self) -> Self {
69        match (self, rhs) {
70            (Number::Defined(l), Number::Defined(r)) => Number::Defined(l.max(r)),
71            (Number::Defined(_), _) => self,
72            _ => Number::Undefined,
73        }
74    }
75}
76
77impl MinMax<f32, Number> for Number {
78    fn maybe_min(self, rhs: f32) -> Self {
79        match self {
80            Number::Defined(val) => Number::Defined(val.min(rhs)),
81            Number::Undefined => Number::Undefined,
82        }
83    }
84
85    fn maybe_max(self, rhs: f32) -> Self {
86        match self {
87            Number::Defined(val) => Number::Defined(val.max(rhs)),
88            Number::Undefined => Number::Undefined,
89        }
90    }
91}
92
93impl MinMax<Number, f32> for f32 {
94    fn maybe_min(self, rhs: Number) -> f32 {
95        match rhs {
96            Number::Defined(val) => self.min(val),
97            Number::Undefined => self,
98        }
99    }
100
101    fn maybe_max(self, rhs: Number) -> f32 {
102        match rhs {
103            Number::Defined(val) => self.max(val),
104            Number::Undefined => self,
105        }
106    }
107}
108
109impl From<f32> for Number {
110    fn from(v: f32) -> Self {
111        Self::Defined(v)
112    }
113}
114
115impl Add<f32> for Number {
116    type Output = Number;
117
118    fn add(self, rhs: f32) -> Self {
119        match self {
120            Number::Defined(val) => Number::Defined(val + rhs),
121            Number::Undefined => Number::Undefined,
122        }
123    }
124}
125
126impl Add<Number> for Number {
127    type Output = Number;
128
129    fn add(self, rhs: Self) -> Self {
130        match (self, rhs) {
131            (Number::Defined(l), Number::Defined(r)) => Number::Defined(l + r),
132            (Number::Defined(_), _) => self,
133            _ => Number::Undefined,
134        }
135    }
136}
137
138impl Sub<f32> for Number {
139    type Output = Number;
140
141    fn sub(self, rhs: f32) -> Self {
142        match self {
143            Number::Defined(val) => Number::Defined(val - rhs),
144            Number::Undefined => Number::Undefined,
145        }
146    }
147}
148
149impl Sub<Number> for Number {
150    type Output = Number;
151
152    fn sub(self, rhs: Self) -> Self {
153        match (self, rhs) {
154            (Number::Defined(l), Number::Defined(r)) => Number::Defined(l - r),
155            (Number::Defined(_), _) => self,
156            _ => Number::Undefined,
157        }
158    }
159}
160
161impl Mul<f32> for Number {
162    type Output = Number;
163
164    fn mul(self, rhs: f32) -> Self {
165        match self {
166            Number::Defined(val) => Number::Defined(val * rhs),
167            Number::Undefined => Number::Undefined,
168        }
169    }
170}
171
172impl Mul<Number> for Number {
173    type Output = Number;
174
175    fn mul(self, rhs: Self) -> Self {
176        match (self, rhs) {
177            (Number::Defined(l), Number::Defined(r)) => Number::Defined(l * r),
178            (Number::Defined(_), _) => self,
179            _ => Number::Undefined,
180        }
181    }
182}
183
184impl Div<f32> for Number {
185    type Output = Number;
186
187    fn div(self, rhs: f32) -> Self {
188        match self {
189            Number::Defined(val) => Number::Defined(val / rhs),
190            Number::Undefined => Number::Undefined,
191        }
192    }
193}
194
195impl Div<Number> for Number {
196    type Output = Number;
197
198    fn div(self, rhs: Self) -> Self {
199        match (self, rhs) {
200            (Number::Defined(l), Number::Defined(r)) => Number::Defined(l / r),
201            (Number::Defined(_), _) => self,
202            _ => Number::Undefined,
203        }
204    }
205}