1// We squash dead_code warnings because we define all of our methods for all
2// primitive integer types, even though we don't use each method at least once
3// on each of the integer types. It would really just be too annoying to do
4// anything different. With that said, it is very likely that there is some
5// actual dead code below that we're missing because we squash the warning.
6#![allow(dead_code, non_snake_case, non_camel_case_types)]
7
8use core::{
9 cmp::Ordering,
10 ops::{
11 Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, RemAssign,
12 Sub, SubAssign,
13 },
14};
15
16use crate::{error::Error, util::t::Constant};
17
18macro_rules! define_ranged {
19 (
20 $name:ident,
21 $repr:ty,
22 smaller { $($smaller_name:ident $smaller_repr:ty),* },
23 bigger { $($bigger_name:ident $bigger_repr:ty),* }
24 ) => {
25 #[derive(Clone, Copy)]
26 pub(crate) struct $name<const MIN: i128, const MAX: i128> {
27 /// The actual value of the integer.
28 ///
29 /// Callers should not access this directly. There are some very
30 /// rare cases where algorithms are too difficult to express on
31 /// ranged integers, and it's useful to be able to reach inside and
32 /// access the raw value directly. (For example, the conversions
33 /// between Unix epoch day and Gregorian date.)
34 pub(crate) val: $repr,
35 /// The minimum possible value computed so far.
36 ///
37 /// This value is only present when `debug_assertions` are enabled.
38 /// In that case, it is used to ensure the minimum possible value
39 /// when the integer is actually observed (or converted) is still
40 /// within the legal range.
41 ///
42 /// Callers should not access this directly. There are some very
43 /// rare cases where algorithms are too difficult to express on
44 /// ranged integers, and it's useful to be able to reach inside and
45 /// access the raw value directly. (For example, the conversions
46 /// between Unix epoch day and Gregorian date.)
47 #[cfg(debug_assertions)]
48 pub(crate) min: $repr,
49 /// The maximum possible value computed so far.
50 ///
51 /// This value is only present when `debug_assertions` are enabled.
52 /// In that case, it is used to ensure the maximum possible value
53 /// when the integer is actually observed (or converted) is still
54 /// within the legal range.
55 ///
56 /// Callers should not access this directly. There are some very
57 /// rare cases where algorithms are too difficult to express on
58 /// ranged integers, and it's useful to be able to reach inside and
59 /// access the raw value directly. (For example, the conversions
60 /// between Unix epoch day and Gregorian date.)
61 #[cfg(debug_assertions)]
62 pub(crate) max: $repr,
63 }
64
65 impl<const MIN: i128, const MAX: i128> $name<MIN, MAX> {
66 /// These are the absolute min/max values for the integer type
67 /// being used.
68 const PRIMITIVE_MIN: i128 = <$repr>::MIN as i128;
69 const PRIMITIVE_MAX: i128 = <$repr>::MAX as i128;
70
71 /// When true, this range integer has bounds precisely equivalent
72 /// to its underlying primitive representation.
73 const IS_PRIMITIVE: bool = Self::MIN_REPR == <$repr>::MIN
74 && Self::MAX_REPR == <$repr>::MAX;
75
76 /// The min/max values as given by our type parameters.
77 pub(crate) const MIN: i128 = MIN;
78 pub(crate) const MAX: i128 = MAX;
79
80 /// The number of distinct elements in this type's range.
81 pub(crate) const LEN: i128 = {
82 assert!(Self::PRIMITIVE_MIN < Self::PRIMITIVE_MAX);
83 MAX - MIN + 1
84 };
85
86 /// The min/max values of this type, represented in their
87 /// primitive form for easy comparisons with incoming values.
88 pub(crate) const MIN_REPR: $repr = {
89 assert!(
90 Self::PRIMITIVE_MIN <= MIN && MIN <= Self::PRIMITIVE_MAX
91 );
92 MIN as $repr
93 };
94 pub(crate) const MAX_REPR: $repr = {
95 assert!(
96 Self::PRIMITIVE_MIN <= MAX && MAX <= Self::PRIMITIVE_MAX
97 );
98 MAX as $repr
99 };
100
101 /// The min/max values of this type as a ranged type.
102 pub(crate) const MIN_SELF: Self =
103 Self::new_unchecked(Self::MIN_REPR);
104 pub(crate) const MAX_SELF: Self =
105 Self::new_unchecked(Self::MAX_REPR);
106
107 /// The min/max values of this type as a constant.
108 pub(crate) const MIN_CONST: Constant =
109 Constant(Self::MIN_REPR as i64);
110 pub(crate) const MAX_CONST: Constant =
111 Constant(Self::MAX_REPR as i64);
112
113 #[inline]
114 pub(crate) fn error(
115 what: &'static str,
116 given: $repr,
117 ) -> Error {
118 Error::range(what, given, Self::MIN_REPR, Self::MAX_REPR)
119 }
120
121 #[inline]
122 pub(crate) fn new(val: impl TryInto<$repr>) -> Option<Self> {
123 let val = val.try_into().ok()?;
124 if !Self::contains(val) {
125 return None;
126 }
127 #[cfg(not(debug_assertions))]
128 {
129 Some(Self { val })
130 }
131 #[cfg(debug_assertions)]
132 {
133 Some(Self {
134 val,
135 min: Self::MIN_REPR,
136 max: Self::MAX_REPR,
137 })
138 }
139 }
140
141 /// Like `new`, but monomorphic and works in a `const` context.
142 #[inline]
143 pub(crate) const fn new_const(val: $repr) -> Option<Self> {
144 if !Self::contains(val) {
145 return None;
146 }
147 #[cfg(not(debug_assertions))]
148 {
149 Some(Self { val })
150 }
151 #[cfg(debug_assertions)]
152 {
153 Some(Self {
154 val,
155 min: Self::MIN_REPR,
156 max: Self::MAX_REPR,
157 })
158 }
159 }
160
161 #[inline]
162 pub(crate) fn try_new(
163 what: &'static str,
164 val: impl Into<i64>,
165 ) -> Result<Self, Error> {
166 let val = val.into();
167 #[allow(irrefutable_let_patterns)]
168 let Ok(val) = <$repr>::try_from(val) else {
169 return Err(Error::range(
170 what,
171 val,
172 Self::MIN_REPR,
173 Self::MAX_REPR,
174 ));
175 };
176 Self::new(val).ok_or_else(|| Self::error(what, val))
177 }
178
179 #[inline]
180 pub(crate) fn try_new128(
181 what: &'static str,
182 val: impl Into<i128>,
183 ) -> Result<Self, Error> {
184 let val = val.into();
185 #[allow(irrefutable_let_patterns)]
186 let Ok(val) = <$repr>::try_from(val) else {
187 return Err(Error::range(
188 what,
189 val,
190 Self::MIN_REPR,
191 Self::MAX_REPR,
192 ));
193 };
194 Self::new(val).ok_or_else(|| Self::error(what, val))
195 }
196
197 #[inline]
198 pub(crate) fn constrain(val: impl Into<$repr>) -> Self {
199 let val = val.into().clamp(Self::MIN_REPR, Self::MAX_REPR);
200 Self::new_unchecked(val)
201 }
202
203 #[inline]
204 pub(crate) const fn new_unchecked(val: $repr) -> Self {
205 #[cfg(not(debug_assertions))]
206 {
207 Self { val }
208 }
209 #[cfg(debug_assertions)]
210 {
211 assert!(Self::contains(val), "val is not in range");
212 Self { val, min: Self::MIN_REPR, max: Self::MAX_REPR }
213 }
214 }
215
216 #[inline]
217 pub(crate) const fn N<const VAL: $repr>() -> Self {
218 #[cfg(not(debug_assertions))]
219 {
220 Self { val: VAL }
221 }
222 #[cfg(debug_assertions)]
223 {
224 Self { val: VAL, min: VAL, max: VAL }
225 }
226 }
227
228 #[inline]
229 pub(crate) const fn N128<const VAL: i128>() -> Self {
230 #[cfg(not(debug_assertions))]
231 {
232 Self { val: VAL as $repr }
233 }
234 #[cfg(debug_assertions)]
235 {
236 if !(MIN <= VAL && VAL <= MAX) {
237 panic!("constant out of range");
238 }
239 let val = VAL as $repr;
240 Self { val, min: val, max: val }
241 }
242 }
243
244 #[inline]
245 pub(crate) const fn V<
246 const VAL: $repr,
247 const START: $repr,
248 const END: $repr,
249 >() -> Self {
250 #[cfg(not(debug_assertions))]
251 {
252 Self { val: VAL }
253 }
254 #[cfg(debug_assertions)]
255 {
256 Self { val: VAL, min: START, max: END }
257 }
258 }
259
260 #[inline]
261 pub(crate) const fn contains(val: $repr) -> bool {
262 Self::MIN_REPR <= val && val <= Self::MAX_REPR
263 }
264
265 #[inline]
266 pub(crate) fn vary<
267 const N: usize,
268 const MIN2: i128,
269 const MAX2: i128,
270 >(
271 numbers: [Self; N],
272 with: impl Fn([Self; N]) -> $name<MIN2, MAX2>,
273 ) -> $name<MIN2, MAX2> {
274 let [result] =
275 Self::vary_many(numbers, |numbers| [with(numbers)]);
276 result
277 }
278
279 #[inline]
280 pub(crate) fn vary_many<
281 const N: usize,
282 const M: usize,
283 const MIN2: i128,
284 const MAX2: i128,
285 >(
286 numbers: [Self; N],
287 with: impl Fn([Self; N]) -> [$name<MIN2, MAX2>; M],
288 ) -> [$name<MIN2, MAX2>; M] {
289 #[cfg(not(debug_assertions))]
290 {
291 with(numbers)
292 }
293 #[cfg(debug_assertions)]
294 {
295 let vals = with(numbers);
296 let mins = with(numbers.map(|n| Self {
297 val: n.min,
298 min: n.min,
299 max: n.max,
300 }));
301 let maxs = with(numbers.map(|n| Self {
302 val: n.max,
303 min: n.min,
304 max: n.max,
305 }));
306 let mut result = [$name::MIN_SELF; M];
307 let it = vals.into_iter().zip(mins).zip(maxs).enumerate();
308 for (i, ((val, min), max)) in it {
309 result[i] =
310 $name { val: val.val, min: min.val, max: max.val };
311 }
312 result
313 }
314 }
315
316 #[inline]
317 pub(crate) fn get(self) -> $repr {
318 #[cfg(not(debug_assertions))]
319 {
320 self.val
321 }
322 #[cfg(debug_assertions)]
323 {
324 assert!(
325 Self::contains(self.val),
326 concat!(
327 stringify!($name),
328 " val {val:?} is not in range {MIN:?}..={MAX:?}"
329 ),
330 val = self.val,
331 MIN = MIN,
332 MAX = MAX,
333 );
334 assert!(
335 Self::contains(self.min),
336 concat!(
337 stringify!($name),
338 " min {min:?} is not in range {MIN:?}..={MAX:?}"
339 ),
340 min = self.min,
341 MIN = MIN,
342 MAX = MAX,
343 );
344 assert!(
345 Self::contains(self.max),
346 concat!(
347 stringify!($name),
348 " max {max:?} is not in range {MIN:?}..={MAX:?}"
349 ),
350 max = self.max,
351 MIN = MIN,
352 MAX = MAX,
353 );
354 self.val
355 }
356 }
357
358 /// Returns the underlying value without checking whether it's
359 /// in bounds or not.
360 ///
361 /// This should generally be avoided as it circumvents the
362 /// protections of this type. It is sometimes useful in cases
363 /// where the bounds are known not to matter. For example, in
364 /// producing an error message for checked arithmetic. It's also
365 /// good to use this in `Debug` impls for higher level types,
366 /// otherwise printing the debug representation of a type will fail
367 /// if a ranged integer is out of bounds. (And this is annoying.)
368 #[inline]
369 pub(crate) const fn get_unchecked(self) -> $repr {
370 self.val
371 }
372
373 /// Turns this integer into an error.
374 ///
375 /// This is useful because it will use the integer's value even if
376 /// it falls outside of the bounds of this type.
377 ///
378 /// Callers can also use this routine to set custom context
379 /// dependent bounds. For example, when the day of the month is out
380 /// of bounds. The maximum value can vary based on the month (and
381 /// year).
382 #[inline]
383 pub(crate) fn to_error_with_bounds(
384 self,
385 what: &'static str,
386 min: impl Into<i128>,
387 max: impl Into<i128>,
388 ) -> Error {
389 Error::range(
390 what,
391 self.get_unchecked(),
392 min.into(),
393 max.into(),
394 )
395 }
396
397 #[inline]
398 pub(crate) fn abs(self) -> Self {
399 #[cfg(not(debug_assertions))]
400 {
401 $name { val: self.val.abs() }
402 }
403 #[cfg(debug_assertions)]
404 {
405 let val = self.val.checked_abs().expect(concat!(
406 "absolute value of ",
407 stringify!($name),
408 " value overflowed",
409 ));
410 let min = self.min.checked_abs().expect(concat!(
411 "absolute value of ",
412 stringify!($name),
413 " minimum overflowed",
414 ));
415 let max = self.max.checked_abs().expect(concat!(
416 "absolute value of ",
417 stringify!($name),
418 " maximum overflowed",
419 ));
420 $name { val, min, max }
421 }
422 }
423
424 #[inline]
425 pub(crate) fn signum(self) -> $name<-1, 1> {
426 #[cfg(not(debug_assertions))]
427 {
428 $name { val: self.val.signum() }
429 }
430 #[cfg(debug_assertions)]
431 {
432 let val = self.val.signum();
433 let min = self.min.signum();
434 let max = self.max.signum();
435 $name { val, min, max }
436 }
437 }
438
439 #[inline]
440 pub(crate) fn min(self, other: impl RInto<Self>) -> Self {
441 let other = other.rinto();
442 #[cfg(not(debug_assertions))]
443 {
444 Self { val: self.val.min(other.val) }
445 }
446 #[cfg(debug_assertions)]
447 {
448 let val = self.val.min(other.val);
449 let min = self.val.min(other.min);
450 let max = self.max.min(other.max);
451 Self { val, min, max }
452 }
453 }
454
455 #[inline]
456 pub(crate) fn max(self, other: impl RInto<Self>) -> Self {
457 let other = other.rinto();
458 #[cfg(not(debug_assertions))]
459 {
460 Self { val: self.val.max(other.val) }
461 }
462 #[cfg(debug_assertions)]
463 {
464 let val = self.val.max(other.val);
465 let min = self.val.max(other.min);
466 let max = self.max.max(other.max);
467 Self { val, min, max }
468 }
469 }
470
471 #[inline]
472 pub(crate) fn clamp(
473 self,
474 min: impl RInto<Self>,
475 max: impl RInto<Self>,
476 ) -> Self {
477 self.min(max).max(min)
478 }
479
480 #[inline]
481 pub(crate) fn div_ceil(self, rhs: impl RInto<Self>) -> Self {
482 let rhs = rhs.rinto();
483 #[cfg(not(debug_assertions))]
484 {
485 let val = self.val.wrapping_div(rhs.val);
486 Self { val }
487 }
488 #[cfg(debug_assertions)]
489 {
490 let val = self.val.checked_div(rhs.val).expect(concat!(
491 "dividing(ceil) ",
492 stringify!($name),
493 " values overflowed"
494 ));
495 let min = self.min.checked_div(rhs.min).expect(concat!(
496 "dividing(ceil) ",
497 stringify!($name),
498 " minimums overflowed"
499 ));
500 let max = self.max.checked_div(rhs.max).expect(concat!(
501 "dividing(ceil) ",
502 stringify!($name),
503 " maximums overflowed"
504 ));
505 Self { val, min, max }
506 }
507 }
508
509 #[inline]
510 pub(crate) fn div_floor(self, rhs: impl RInto<Self>) -> Self {
511 let rhs = rhs.rinto();
512 #[cfg(not(debug_assertions))]
513 {
514 let val = self.val.wrapping_div_euclid(rhs.val);
515 Self { val }
516 }
517 #[cfg(debug_assertions)]
518 {
519 let val =
520 self.val.checked_div_euclid(rhs.val).expect(concat!(
521 "dividing(ceil) ",
522 stringify!($name),
523 " values overflowed"
524 ));
525 let min =
526 self.min.checked_div_euclid(rhs.min).expect(concat!(
527 "dividing(ceil) ",
528 stringify!($name),
529 " minimums overflowed"
530 ));
531 let max =
532 self.max.checked_div_euclid(rhs.max).expect(concat!(
533 "dividing(ceil) ",
534 stringify!($name),
535 " maximums overflowed"
536 ));
537 Self { val, min, max }
538 }
539 }
540
541 #[inline]
542 pub(crate) fn rem_ceil(self, rhs: impl RInto<Self>) -> Self {
543 let rhs = rhs.rinto();
544 #[cfg(not(debug_assertions))]
545 {
546 let val = self.val.wrapping_rem(rhs.val);
547 Self { val }
548 }
549 #[cfg(debug_assertions)]
550 {
551 let val = self.val.checked_rem(rhs.val).expect(concat!(
552 "modulo(ceil) ",
553 stringify!($name),
554 " values overflowed"
555 ));
556 let min = self.min.checked_rem(rhs.min).expect(concat!(
557 "modulo(ceil) ",
558 stringify!($name),
559 " minimums overflowed"
560 ));
561 let max = self.max.checked_rem(rhs.max).expect(concat!(
562 "modulo(ceil) ",
563 stringify!($name),
564 " maximums overflowed"
565 ));
566 Self { val, min, max }
567 }
568 }
569
570 #[inline]
571 pub(crate) fn rem_floor(self, rhs: impl RInto<Self>) -> Self {
572 let rhs = rhs.rinto();
573 #[cfg(not(debug_assertions))]
574 {
575 let val = self.val.wrapping_rem_euclid(rhs.val);
576 Self { val }
577 }
578 #[cfg(debug_assertions)]
579 {
580 let val =
581 self.val.checked_rem_euclid(rhs.val).expect(concat!(
582 "modulo(ceil) ",
583 stringify!($name),
584 " values overflowed"
585 ));
586 let min =
587 self.min.checked_rem_euclid(rhs.min).expect(concat!(
588 "modulo(ceil) ",
589 stringify!($name),
590 " minimums overflowed"
591 ));
592 let max =
593 self.max.checked_rem_euclid(rhs.max).expect(concat!(
594 "modulo(ceil) ",
595 stringify!($name),
596 " maximums overflowed"
597 ));
598 Self { val, min, max }
599 }
600 }
601
602 #[inline]
603 pub(crate) fn try_checked_add(
604 self,
605 what: &'static str,
606 rhs: impl RInto<Self>,
607 ) -> Result<Self, Error> {
608 let rhs = rhs.rinto();
609 self.checked_add(rhs)
610 .ok_or_else(|| Self::error(what, rhs.get_unchecked()))
611 }
612
613 #[inline]
614 pub(crate) fn try_checked_sub(
615 self,
616 what: &'static str,
617 rhs: impl RInto<Self>,
618 ) -> Result<Self, Error> {
619 let rhs = rhs.rinto();
620 self.checked_sub(rhs)
621 .ok_or_else(|| Self::error(what, rhs.get_unchecked()))
622 }
623
624 #[inline]
625 pub(crate) fn try_checked_mul(
626 self,
627 what: &'static str,
628 rhs: impl RInto<Self>,
629 ) -> Result<Self, Error> {
630 let rhs = rhs.rinto();
631 self.checked_mul(rhs)
632 .ok_or_else(|| Self::error(what, rhs.get_unchecked()))
633 }
634
635 #[inline]
636 pub(crate) fn checked_add(
637 self,
638 rhs: impl RInto<Self>,
639 ) -> Option<Self> {
640 let rhs = rhs.rinto();
641 #[cfg(not(debug_assertions))]
642 {
643 let val = self.val.checked_add(rhs.val)?;
644 Self::new(val)
645 }
646 #[cfg(debug_assertions)]
647 {
648 let val = self.val.checked_add(rhs.val)?;
649 if !Self::contains(val) {
650 return None;
651 }
652 // We specifically clamp min/max at the boundaries because
653 // the checked arithmetic above implies we will catch
654 // overflow. If we didn't do this, min/max arithmetic
655 // could overflow even when the checked arithmetic above
656 // did not. That is, under normal and expected operation,
657 // we expect the min/max to eventually overflow even when
658 // val does not.
659 let min = self
660 .min
661 .saturating_add(rhs.min)
662 .clamp(Self::MIN_REPR, Self::MAX_REPR);
663 let max = self
664 .max
665 .saturating_add(rhs.max)
666 .clamp(Self::MIN_REPR, Self::MAX_REPR);
667 Some(Self { val, min, max })
668 }
669 }
670
671 #[inline]
672 pub(crate) fn checked_sub(
673 self,
674 rhs: impl RInto<Self>,
675 ) -> Option<Self> {
676 let rhs = rhs.rinto();
677 #[cfg(not(debug_assertions))]
678 {
679 let val = self.val.checked_sub(rhs.val)?;
680 Self::new(val)
681 }
682 #[cfg(debug_assertions)]
683 {
684 let val = self.val.checked_sub(rhs.val)?;
685 if !Self::contains(val) {
686 return None;
687 }
688 // See comment in `checked_add`.
689 let min = self
690 .min
691 .saturating_sub(rhs.min)
692 .clamp(Self::MIN_REPR, Self::MAX_REPR);
693 let max = self
694 .max
695 .saturating_sub(rhs.max)
696 .clamp(Self::MIN_REPR, Self::MAX_REPR);
697 Some(Self { val, min, max })
698 }
699 }
700
701 #[inline]
702 pub(crate) fn checked_mul(
703 self,
704 rhs: impl RInto<Self>,
705 ) -> Option<Self> {
706 let rhs = rhs.rinto();
707 #[cfg(not(debug_assertions))]
708 {
709 let val = self.val.checked_mul(rhs.val)?;
710 Self::new(val)
711 }
712 #[cfg(debug_assertions)]
713 {
714 let val = self.val.checked_mul(rhs.val)?;
715 if !Self::contains(val) {
716 return None;
717 }
718 // See comment in `checked_add`.
719 let min = self
720 .min
721 .saturating_mul(rhs.min)
722 .clamp(Self::MIN_REPR, Self::MAX_REPR);
723 let max = self
724 .max
725 .saturating_mul(rhs.max)
726 .clamp(Self::MIN_REPR, Self::MAX_REPR);
727 Some(Self { val, min, max })
728 }
729 }
730
731 #[inline]
732 pub(crate) fn wrapping_add(self, rhs: impl RInto<Self>) -> Self {
733 let rhs = rhs.rinto();
734 #[cfg(not(debug_assertions))]
735 {
736 // When the min/max bounds match our primitive type, then
737 // standard wrapping arithmetic will work fine. This is
738 // likely a benefit for perf, but it's also required
739 // for correctness since we don't support anything else
740 // at the moment.
741 if Self::IS_PRIMITIVE {
742 Self { val: self.val.wrapping_add(rhs.val) }
743 } else {
744 unimplemented!(
745 "wrapping arithmetic for non-primitive \
746 ranged integers is not implemented yet",
747 );
748 }
749 }
750 #[cfg(debug_assertions)]
751 {
752 if Self::IS_PRIMITIVE {
753 let val = self.val.wrapping_add(rhs.val);
754 let min = self.min.wrapping_add(rhs.min);
755 let max = self.max.wrapping_add(rhs.max);
756 Self { val, min, max }
757 } else {
758 unimplemented!(
759 "wrapping arithmetic for non-primitive \
760 ranged integers is not implemented yet",
761 );
762 }
763 }
764 }
765
766 #[inline]
767 pub(crate) fn wrapping_sub(self, rhs: impl RInto<Self>) -> Self {
768 let rhs = rhs.rinto();
769 #[cfg(not(debug_assertions))]
770 {
771 // When the min/max bounds match our primitive type, then
772 // standard wrapping arithmetic will work fine. This is
773 // likely a benefit for perf, but it's also required
774 // for correctness since we don't support anything else
775 // at the moment.
776 if Self::IS_PRIMITIVE {
777 Self { val: self.val.wrapping_sub(rhs.val) }
778 } else {
779 unimplemented!(
780 "wrapping arithmetic for non-primitive \
781 ranged integers is not implemented yet",
782 );
783 }
784 }
785 #[cfg(debug_assertions)]
786 {
787 if Self::IS_PRIMITIVE {
788 let val = self.val.wrapping_sub(rhs.val);
789 let min = self.min.wrapping_sub(rhs.min);
790 let max = self.max.wrapping_sub(rhs.max);
791 Self { val, min, max }
792 } else {
793 unimplemented!(
794 "wrapping arithmetic for non-primitive \
795 ranged integers is not implemented yet",
796 );
797 }
798 }
799 }
800
801 #[inline]
802 pub(crate) fn wrapping_mul(self, rhs: impl RInto<Self>) -> Self {
803 let rhs = rhs.rinto();
804 #[cfg(not(debug_assertions))]
805 {
806 // When the min/max bounds match our primitive type, then
807 // standard wrapping arithmetic will work fine. This is
808 // likely a benefit for perf, but it's also required
809 // for correctness since we don't support anything else
810 // at the moment.
811 if Self::IS_PRIMITIVE {
812 Self { val: self.val.wrapping_mul(rhs.val) }
813 } else {
814 unimplemented!(
815 "wrapping arithmetic for non-primitive \
816 ranged integers is not implemented yet",
817 );
818 }
819 }
820 #[cfg(debug_assertions)]
821 {
822 if Self::IS_PRIMITIVE {
823 let val = self.val.wrapping_mul(rhs.val);
824 let min = self.min.wrapping_mul(rhs.min);
825 let max = self.max.wrapping_mul(rhs.max);
826 Self { val, min, max }
827 } else {
828 unimplemented!(
829 "wrapping arithmetic for non-primitive \
830 ranged integers is not implemented yet",
831 );
832 }
833 }
834 }
835
836 #[inline]
837 pub(crate) fn saturating_add(self, rhs: impl RInto<Self>) -> Self {
838 let rhs = rhs.rinto();
839 #[cfg(not(debug_assertions))]
840 {
841 let val = self
842 .val
843 .saturating_add(rhs.val)
844 .clamp(Self::MIN_REPR, Self::MAX_REPR);
845 Self { val }
846 }
847 #[cfg(debug_assertions)]
848 {
849 let val = self
850 .val
851 .saturating_add(rhs.val)
852 .clamp(Self::MIN_REPR, Self::MAX_REPR);
853 let min = self
854 .min
855 .saturating_add(rhs.val)
856 .clamp(Self::MIN_REPR, Self::MAX_REPR);
857 let max = self
858 .max
859 .saturating_add(rhs.val)
860 .clamp(Self::MIN_REPR, Self::MAX_REPR);
861 Self { val, min, max }
862 }
863 }
864
865 #[inline]
866 pub(crate) fn saturating_sub(self, rhs: impl RInto<Self>) -> Self {
867 let rhs = rhs.rinto();
868 #[cfg(not(debug_assertions))]
869 {
870 let val = self
871 .val
872 .saturating_sub(rhs.val)
873 .clamp(Self::MIN_REPR, Self::MAX_REPR);
874 Self { val }
875 }
876 #[cfg(debug_assertions)]
877 {
878 let val = self
879 .val
880 .saturating_sub(rhs.val)
881 .clamp(Self::MIN_REPR, Self::MAX_REPR);
882 let min = self
883 .min
884 .saturating_sub(rhs.val)
885 .clamp(Self::MIN_REPR, Self::MAX_REPR);
886 let max = self
887 .max
888 .saturating_sub(rhs.val)
889 .clamp(Self::MIN_REPR, Self::MAX_REPR);
890 Self { val, min, max }
891 }
892 }
893
894 #[inline]
895 pub(crate) fn saturating_mul(self, rhs: impl RInto<Self>) -> Self {
896 let rhs = rhs.rinto();
897 #[cfg(not(debug_assertions))]
898 {
899 let val = self
900 .val
901 .saturating_mul(rhs.val)
902 .clamp(Self::MIN_REPR, Self::MAX_REPR);
903 Self { val }
904 }
905 #[cfg(debug_assertions)]
906 {
907 let val = self
908 .val
909 .saturating_mul(rhs.val)
910 .clamp(Self::MIN_REPR, Self::MAX_REPR);
911 let min = self
912 .min
913 .saturating_mul(rhs.val)
914 .clamp(Self::MIN_REPR, Self::MAX_REPR);
915 let max = self
916 .max
917 .saturating_mul(rhs.val)
918 .clamp(Self::MIN_REPR, Self::MAX_REPR);
919 Self { val, min, max }
920 }
921 }
922
923 pub(crate) fn debug(self) -> RangedDebug<MIN, MAX> {
924 RangedDebug { rint: self.rinto() }
925 }
926 }
927
928 // We hand-write the `Hash` impl to avoid the min/max values
929 // influencing the hash. Only the actual value should be hashed.
930 //
931 // See: https://github.com/BurntSushi/jiff/issues/330
932 impl<const MIN: i128, const MAX: i128> core::hash::Hash for $name<MIN, MAX> {
933 fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
934 self.val.hash(state);
935 }
936 }
937
938 impl<
939 const MIN1: i128,
940 const MAX1: i128,
941 const MIN2: i128,
942 const MAX2: i128,
943 > RFrom<$name<MIN1, MAX1>> for $name<MIN2, MAX2>
944 {
945 #[inline]
946 fn rfrom(r: $name<MIN1, MAX1>) -> Self {
947 #[cfg(not(debug_assertions))]
948 {
949 $name { val: r.val }
950 }
951 #[cfg(debug_assertions)]
952 {
953 $name { val: r.val, min: r.min, max: r.max }
954 }
955 }
956 }
957
958 impl<const MIN: i128, const MAX: i128> RFrom<$name<MIN, MAX>>
959 for $repr
960 {
961 #[inline]
962 fn rfrom(r: $name<MIN, MAX>) -> $repr {
963 r.get()
964 }
965 }
966
967 impl<const MIN: i128, const MAX: i128> From<$name<MIN, MAX>>
968 for $repr
969 {
970 #[inline]
971 fn from(r: $name<MIN, MAX>) -> $repr {
972 r.get()
973 }
974 }
975
976 impl<const MIN: i128, const MAX: i128> RFrom<Constant>
977 for $name<MIN, MAX>
978 {
979 #[inline]
980 fn rfrom(c: Constant) -> Self {
981 #[cfg(not(debug_assertions))]
982 {
983 Self { val: c.value() as $repr }
984 }
985 #[cfg(debug_assertions)]
986 {
987 // We specifically allow constants that don't fit in the
988 // bounds of the integer type, but we don't allow constans
989 // that can't fit in the actual integer representation.
990 // This makes doing things like `number % one-plus-max`
991 // much more convenient.
992 #[allow(irrefutable_let_patterns)]
993 let Ok(val) = <$repr>::try_from(c.value()) else {
994 panic!(
995 "{c:?} does not fit in {name:?}",
996 name = stringify!($name),
997 )
998 };
999 Self { val, min: val, max: val }
1000 }
1001 }
1002 }
1003
1004 impl<
1005 const MIN1: i128,
1006 const MAX1: i128,
1007 const MIN2: i128,
1008 const MAX2: i128,
1009 > TryRFrom<$name<MIN1, MAX1>> for $name<MIN2, MAX2>
1010 {
1011 #[inline]
1012 fn try_rfrom(
1013 what: &'static str, r: $name<MIN1, MAX1>,
1014 ) -> Result<Self, Error> {
1015 #[cfg(not(debug_assertions))]
1016 {
1017 if !Self::contains(r.val) {
1018 return Err(Self::error(what, r.val));
1019 }
1020 Ok($name { val: r.val })
1021 }
1022 #[cfg(debug_assertions)]
1023 {
1024 if !Self::contains(r.val) {
1025 return Err(Self::error(what, r.val));
1026 }
1027 Ok($name {
1028 val: r.val,
1029 min: r.min.clamp(Self::MIN_REPR, Self::MAX_REPR),
1030 max: r.max.clamp(Self::MIN_REPR, Self::MAX_REPR),
1031 })
1032 }
1033 }
1034 }
1035
1036 $(
1037 impl<
1038 const MIN1: i128,
1039 const MAX1: i128,
1040 const MIN2: i128,
1041 const MAX2: i128,
1042 > RFrom<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1043 {
1044 #[inline]
1045 fn rfrom(r: $smaller_name<MIN1, MAX1>) -> Self {
1046 #[cfg(not(debug_assertions))]
1047 {
1048 Self { val: <$repr>::from(r.val) }
1049 }
1050 #[cfg(debug_assertions)]
1051 {
1052 Self {
1053 val: <$repr>::from(r.val),
1054 min: <$repr>::from(r.min),
1055 max: <$repr>::from(r.max),
1056 }
1057 }
1058 }
1059 }
1060
1061 impl<
1062 const MIN: i128,
1063 const MAX: i128,
1064 > RFrom<$name<MIN, MAX>> for $smaller_repr
1065 {
1066 #[inline]
1067 fn rfrom(r: $name<MIN, MAX>) -> $smaller_repr {
1068 #[cfg(not(debug_assertions))]
1069 {
1070 r.val as $smaller_repr
1071 }
1072 #[cfg(debug_assertions)]
1073 {
1074 let Ok(val) = <$smaller_repr>::try_from(r.val) else {
1075 panic!(
1076 "{from} value {val} does not fit in {to}",
1077 from = stringify!($name),
1078 val = r.val,
1079 to = stringify!($smaller_name),
1080 );
1081 };
1082 if <$smaller_repr>::try_from(r.min).is_err() {
1083 panic!(
1084 "{from} min value {val} does not fit in {to}",
1085 from = stringify!($name),
1086 val = r.min,
1087 to = stringify!($smaller_name),
1088 );
1089 }
1090 if <$smaller_repr>::try_from(r.max).is_err() {
1091 panic!(
1092 "{from} max value {val} does not fit in {to}",
1093 from = stringify!($name),
1094 val = r.max,
1095 to = stringify!($smaller_name),
1096 );
1097 }
1098 val
1099 }
1100 }
1101 }
1102
1103 impl<
1104 const MIN: i128,
1105 const MAX: i128,
1106 > From<$name<MIN, MAX>> for $smaller_repr
1107 {
1108 #[inline]
1109 fn from(r: $name<MIN, MAX>) -> $smaller_repr {
1110 <$smaller_repr>::rfrom(r)
1111 }
1112 }
1113
1114 impl<
1115 const MIN1: i128,
1116 const MAX1: i128,
1117 const MIN2: i128,
1118 const MAX2: i128,
1119 > TryRFrom<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1120 {
1121 #[inline]
1122 fn try_rfrom(
1123 what: &'static str, r: $smaller_name<MIN1, MAX1>,
1124 ) -> Result<Self, Error> {
1125 #[cfg(not(debug_assertions))]
1126 {
1127 let val = <$repr>::from(r.val);
1128 if !Self::contains(val) {
1129 return Err(Self::error(what, val));
1130 }
1131 Ok(Self { val })
1132 }
1133 #[cfg(debug_assertions)]
1134 {
1135 let val = <$repr>::from(r.val);
1136 if !Self::contains(val) {
1137 return Err(Self::error(what, val));
1138 }
1139 Ok(Self {
1140 val: val,
1141 min: <$repr>::from(r.min)
1142 .clamp(Self::MIN_REPR, Self::MAX_REPR),
1143 max: <$repr>::from(r.max)
1144 .clamp(Self::MIN_REPR, Self::MAX_REPR),
1145 })
1146 }
1147 }
1148 }
1149
1150 impl<
1151 const MIN1: i128,
1152 const MAX1: i128,
1153 const MIN2: i128,
1154 const MAX2: i128,
1155 > PartialEq<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1156 {
1157 #[inline]
1158 fn eq(&self, other: &$smaller_name<MIN1, MAX1>) -> bool {
1159 self.eq(&Self::rfrom(*other))
1160 }
1161 }
1162
1163 impl<
1164 const MIN1: i128,
1165 const MAX1: i128,
1166 const MIN2: i128,
1167 const MAX2: i128,
1168 > PartialOrd<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1169 {
1170 #[inline]
1171 fn partial_cmp(
1172 &self,
1173 other: &$smaller_name<MIN1, MAX1>,
1174 ) -> Option<Ordering> {
1175 self.partial_cmp(&Self::rfrom(*other))
1176 }
1177 }
1178
1179 impl<
1180 const MIN1: i128,
1181 const MAX1: i128,
1182 const MIN2: i128,
1183 const MAX2: i128,
1184 > Add<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1185 {
1186 type Output = Self;
1187
1188 #[inline]
1189 fn add(self, rhs: $smaller_name<MIN1, MAX1>) -> Self::Output {
1190 self.add(Self::rfrom(rhs))
1191 }
1192 }
1193
1194 impl<
1195 const MIN1: i128,
1196 const MAX1: i128,
1197 const MIN2: i128,
1198 const MAX2: i128,
1199 > AddAssign<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1200 {
1201 #[inline]
1202 fn add_assign(&mut self, rhs: $smaller_name<MIN1, MAX1>) {
1203 self.add_assign(Self::rfrom(rhs))
1204 }
1205 }
1206
1207 impl<
1208 const MIN1: i128,
1209 const MAX1: i128,
1210 const MIN2: i128,
1211 const MAX2: i128,
1212 > Sub<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1213 {
1214 type Output = Self;
1215
1216 #[inline]
1217 fn sub(self, rhs: $smaller_name<MIN1, MAX1>) -> Self::Output {
1218 self.sub(Self::rfrom(rhs))
1219 }
1220 }
1221
1222 impl<
1223 const MIN1: i128,
1224 const MAX1: i128,
1225 const MIN2: i128,
1226 const MAX2: i128,
1227 > SubAssign<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1228 {
1229 #[inline]
1230 fn sub_assign(&mut self, rhs: $smaller_name<MIN1, MAX1>) {
1231 self.sub_assign(Self::rfrom(rhs))
1232 }
1233 }
1234
1235 impl<
1236 const MIN1: i128,
1237 const MAX1: i128,
1238 const MIN2: i128,
1239 const MAX2: i128,
1240 > Mul<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1241 {
1242 type Output = Self;
1243
1244 #[inline]
1245 fn mul(self, rhs: $smaller_name<MIN1, MAX1>) -> Self::Output {
1246 self.mul(Self::rfrom(rhs))
1247 }
1248 }
1249
1250 impl<
1251 const MIN1: i128,
1252 const MAX1: i128,
1253 const MIN2: i128,
1254 const MAX2: i128,
1255 > MulAssign<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1256 {
1257 #[inline]
1258 fn mul_assign(&mut self, rhs: $smaller_name<MIN1, MAX1>) {
1259 self.mul_assign(Self::rfrom(rhs))
1260 }
1261 }
1262
1263 impl<
1264 const MIN1: i128,
1265 const MAX1: i128,
1266 const MIN2: i128,
1267 const MAX2: i128,
1268 > Div<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1269 {
1270 type Output = Self;
1271
1272 #[inline]
1273 fn div(self, rhs: $smaller_name<MIN1, MAX1>) -> Self::Output {
1274 self.div(Self::rfrom(rhs))
1275 }
1276 }
1277
1278 impl<
1279 const MIN1: i128,
1280 const MAX1: i128,
1281 const MIN2: i128,
1282 const MAX2: i128,
1283 > DivAssign<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1284 {
1285 #[inline]
1286 fn div_assign(&mut self, rhs: $smaller_name<MIN1, MAX1>) {
1287 self.div_assign(Self::rfrom(rhs))
1288 }
1289 }
1290
1291 impl<
1292 const MIN1: i128,
1293 const MAX1: i128,
1294 const MIN2: i128,
1295 const MAX2: i128,
1296 > Rem<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1297 {
1298 type Output = Self;
1299
1300 #[inline]
1301 fn rem(self, rhs: $smaller_name<MIN1, MAX1>) -> Self::Output {
1302 self.rem(Self::rfrom(rhs))
1303 }
1304 }
1305
1306 impl<
1307 const MIN1: i128,
1308 const MAX1: i128,
1309 const MIN2: i128,
1310 const MAX2: i128,
1311 > RemAssign<$smaller_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1312 {
1313 #[inline]
1314 fn rem_assign(&mut self, rhs: $smaller_name<MIN1, MAX1>) {
1315 self.rem_assign(Self::rfrom(rhs))
1316 }
1317 }
1318 )*
1319
1320 $(
1321 impl<
1322 const MIN1: i128,
1323 const MAX1: i128,
1324 const MIN2: i128,
1325 const MAX2: i128,
1326 > RFrom<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1327 {
1328 #[inline]
1329 fn rfrom(r: $bigger_name<MIN1, MAX1>) -> Self {
1330 #[cfg(not(debug_assertions))]
1331 {
1332 Self { val: r.val as $repr }
1333 }
1334 #[cfg(debug_assertions)]
1335 {
1336 let Ok(val) = <$repr>::try_from(r.val) else {
1337 panic!(
1338 "{from} value {val} does not fit in {to}",
1339 from = stringify!($bigger_name),
1340 val = r.val,
1341 to = stringify!($name),
1342 );
1343 };
1344 let Ok(min) = <$repr>::try_from(r.min) else {
1345 panic!(
1346 "{from} min value {val} does not fit in {to}",
1347 from = stringify!($bigger_name),
1348 val = r.min,
1349 to = stringify!($name),
1350 );
1351 };
1352 let Ok(max) = <$repr>::try_from(r.max) else {
1353 panic!(
1354 "{from} max value {val} does not fit in {to}",
1355 from = stringify!($bigger_name),
1356 val = r.max,
1357 to = stringify!($name),
1358 );
1359 };
1360 Self { val, min, max }
1361 }
1362 }
1363 }
1364
1365 impl<
1366 const MIN: i128,
1367 const MAX: i128,
1368 > RFrom<$name<MIN, MAX>> for $bigger_repr
1369 {
1370 #[inline]
1371 fn rfrom(r: $name<MIN, MAX>) -> $bigger_repr {
1372 <$bigger_repr>::from(r.get())
1373 }
1374 }
1375
1376 impl<
1377 const MIN: i128,
1378 const MAX: i128,
1379 > From<$name<MIN, MAX>> for $bigger_repr
1380 {
1381 #[inline]
1382 fn from(r: $name<MIN, MAX>) -> $bigger_repr {
1383 <$bigger_repr>::rfrom(r)
1384 }
1385 }
1386
1387 impl<
1388 const MIN1: i128,
1389 const MAX1: i128,
1390 const MIN2: i128,
1391 const MAX2: i128,
1392 > TryRFrom<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1393 {
1394 #[inline]
1395 fn try_rfrom(
1396 what: &'static str, r: $bigger_name<MIN1, MAX1>,
1397 ) -> Result<Self, Error> {
1398 #[cfg(not(debug_assertions))]
1399 {
1400 let val = <$repr>::try_from(r.val).map_err(|_| {
1401 Error::range(what, r.val, MIN2, MAX2)
1402 })?;
1403 if !Self::contains(val) {
1404 return Err(Self::error(what, val));
1405 }
1406 Ok(Self { val })
1407 }
1408 #[cfg(debug_assertions)]
1409 {
1410 let val = <$repr>::try_from(r.val).map_err(|_| {
1411 Error::range(what, r.val, MIN2, MAX2)
1412 })?;
1413 if !Self::contains(val) {
1414 return Err(Self::error(what, val));
1415 }
1416 let min = <$repr>::try_from(r.min).unwrap_or_else(|_| {
1417 if (r.min as i128) < MIN2 {
1418 Self::MIN_REPR
1419 } else {
1420 assert!(r.min as i128 > MAX2);
1421 Self::MAX_REPR
1422 }
1423 });
1424 let max = <$repr>::try_from(r.max).unwrap_or_else(|_| {
1425 if (r.max as i128) < MIN2 {
1426 Self::MIN_REPR
1427 } else {
1428 assert!(r.max as i128 > MAX2);
1429 Self::MAX_REPR
1430 }
1431 });
1432 Ok(Self {
1433 val,
1434 min: min.clamp(Self::MIN_REPR, Self::MAX_REPR),
1435 max: max.clamp(Self::MIN_REPR, Self::MAX_REPR),
1436 })
1437 }
1438 }
1439 }
1440
1441 impl<
1442 const MIN1: i128,
1443 const MAX1: i128,
1444 const MIN2: i128,
1445 const MAX2: i128,
1446 > PartialEq<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1447 {
1448 #[inline]
1449 fn eq(&self, other: &$bigger_name<MIN1, MAX1>) -> bool {
1450 <$bigger_name<MIN1, MAX1>>::rfrom(*self).eq(other)
1451 }
1452 }
1453
1454 impl<
1455 const MIN1: i128,
1456 const MAX1: i128,
1457 const MIN2: i128,
1458 const MAX2: i128,
1459 > PartialOrd<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1460 {
1461 #[inline]
1462 fn partial_cmp(
1463 &self,
1464 other: &$bigger_name<MIN1, MAX1>,
1465 ) -> Option<Ordering> {
1466 <$bigger_name<MIN1, MAX1>>::rfrom(*self).partial_cmp(other)
1467 }
1468 }
1469
1470 impl<
1471 const MIN1: i128,
1472 const MAX1: i128,
1473 const MIN2: i128,
1474 const MAX2: i128,
1475 > Add<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1476 {
1477 type Output = Self;
1478
1479 #[inline]
1480 fn add(self, rhs: $bigger_name<MIN1, MAX1>) -> Self::Output {
1481 self.add(Self::rfrom(rhs))
1482 }
1483 }
1484
1485 impl<
1486 const MIN1: i128,
1487 const MAX1: i128,
1488 const MIN2: i128,
1489 const MAX2: i128,
1490 > AddAssign<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1491 {
1492 #[inline]
1493 fn add_assign(&mut self, rhs: $bigger_name<MIN1, MAX1>) {
1494 self.add_assign(Self::rfrom(rhs))
1495 }
1496 }
1497
1498 impl<
1499 const MIN1: i128,
1500 const MAX1: i128,
1501 const MIN2: i128,
1502 const MAX2: i128,
1503 > Sub<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1504 {
1505 type Output = Self;
1506
1507 #[inline]
1508 fn sub(self, rhs: $bigger_name<MIN1, MAX1>) -> Self::Output {
1509 self.sub(Self::rfrom(rhs))
1510 }
1511 }
1512
1513 impl<
1514 const MIN1: i128,
1515 const MAX1: i128,
1516 const MIN2: i128,
1517 const MAX2: i128,
1518 > SubAssign<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1519 {
1520 #[inline]
1521 fn sub_assign(&mut self, rhs: $bigger_name<MIN1, MAX1>) {
1522 self.sub_assign(Self::rfrom(rhs))
1523 }
1524 }
1525
1526 impl<
1527 const MIN1: i128,
1528 const MAX1: i128,
1529 const MIN2: i128,
1530 const MAX2: i128,
1531 > Mul<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1532 {
1533 type Output = Self;
1534
1535 #[inline]
1536 fn mul(self, rhs: $bigger_name<MIN1, MAX1>) -> Self::Output {
1537 self.mul(Self::rfrom(rhs))
1538 }
1539 }
1540
1541 impl<
1542 const MIN1: i128,
1543 const MAX1: i128,
1544 const MIN2: i128,
1545 const MAX2: i128,
1546 > MulAssign<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1547 {
1548 #[inline]
1549 fn mul_assign(&mut self, rhs: $bigger_name<MIN1, MAX1>) {
1550 self.mul_assign(Self::rfrom(rhs))
1551 }
1552 }
1553
1554 impl<
1555 const MIN1: i128,
1556 const MAX1: i128,
1557 const MIN2: i128,
1558 const MAX2: i128,
1559 > Div<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1560 {
1561 type Output = Self;
1562
1563 #[inline]
1564 fn div(self, rhs: $bigger_name<MIN1, MAX1>) -> Self::Output {
1565 self.div(Self::rfrom(rhs))
1566 }
1567 }
1568
1569 impl<
1570 const MIN1: i128,
1571 const MAX1: i128,
1572 const MIN2: i128,
1573 const MAX2: i128,
1574 > DivAssign<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1575 {
1576 #[inline]
1577 fn div_assign(&mut self, rhs: $bigger_name<MIN1, MAX1>) {
1578 self.div_assign(Self::rfrom(rhs))
1579 }
1580 }
1581
1582 impl<
1583 const MIN1: i128,
1584 const MAX1: i128,
1585 const MIN2: i128,
1586 const MAX2: i128,
1587 > Rem<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1588 {
1589 type Output = Self;
1590
1591 #[inline]
1592 fn rem(self, rhs: $bigger_name<MIN1, MAX1>) -> Self::Output {
1593 self.rem(Self::rfrom(rhs))
1594 }
1595 }
1596
1597 impl<
1598 const MIN1: i128,
1599 const MAX1: i128,
1600 const MIN2: i128,
1601 const MAX2: i128,
1602 > RemAssign<$bigger_name<MIN1, MAX1>> for $name<MIN2, MAX2>
1603 {
1604 #[inline]
1605 fn rem_assign(&mut self, rhs: $bigger_name<MIN1, MAX1>) {
1606 self.rem_assign(Self::rfrom(rhs))
1607 }
1608 }
1609 )*
1610
1611 impl<const MIN: i128, const MAX: i128> Neg for $name<MIN, MAX> {
1612 type Output = Self;
1613
1614 #[inline]
1615 fn neg(self) -> Self {
1616 #[cfg(not(debug_assertions))]
1617 {
1618 let val = self.val.wrapping_neg();
1619 Self { val }
1620 }
1621 #[cfg(debug_assertions)]
1622 {
1623 let val = self.val.checked_neg().expect(concat!(
1624 "negating ",
1625 stringify!($name),
1626 " values overflowed"
1627 ));
1628 let min = self.min.checked_neg().expect(concat!(
1629 "negating ",
1630 stringify!($name),
1631 " minimums overflowed"
1632 ));
1633 let max = self.max.checked_neg().expect(concat!(
1634 "negating ",
1635 stringify!($name),
1636 " maximums overflowed"
1637 ));
1638 Self { val, min, max }
1639 }
1640 }
1641 }
1642
1643 impl<
1644 const MIN1: i128,
1645 const MAX1: i128,
1646 const MIN2: i128,
1647 const MAX2: i128,
1648 > Add<$name<MIN2, MAX2>> for $name<MIN1, MAX1> {
1649 type Output = Self;
1650
1651 #[inline]
1652 fn add(self, rhs: $name<MIN2, MAX2>) -> Self::Output {
1653 #[cfg(not(debug_assertions))]
1654 {
1655 let val = self.val.wrapping_add(rhs.val);
1656 Self { val }
1657 }
1658 #[cfg(debug_assertions)]
1659 {
1660 let val = self.val.checked_add(rhs.val).expect(concat!(
1661 "adding ",
1662 stringify!($name),
1663 " values overflowed"
1664 ));
1665 let min = self.min.checked_add(rhs.min).expect(concat!(
1666 "adding ",
1667 stringify!($name),
1668 " minimums overflowed"
1669 ));
1670 let max = self.max.checked_add(rhs.max).expect(concat!(
1671 "adding ",
1672 stringify!($name),
1673 " maximums overflowed"
1674 ));
1675 Self { val, min, max }
1676 }
1677 }
1678 }
1679
1680 impl<
1681 const MIN1: i128,
1682 const MAX1: i128,
1683 const MIN2: i128,
1684 const MAX2: i128,
1685 > AddAssign<$name<MIN2, MAX2>> for $name<MIN1, MAX1> {
1686 #[inline]
1687 fn add_assign(&mut self, rhs: $name<MIN2, MAX2>) {
1688 *self = self.add(rhs);
1689 }
1690 }
1691
1692 impl<
1693 const MIN1: i128,
1694 const MAX1: i128,
1695 const MIN2: i128,
1696 const MAX2: i128,
1697 > Sub<$name<MIN2, MAX2>> for $name<MIN1, MAX1> {
1698 type Output = Self;
1699
1700 #[inline]
1701 fn sub(self, rhs: $name<MIN2, MAX2>) -> Self::Output {
1702 #[cfg(not(debug_assertions))]
1703 {
1704 let val = self.val.wrapping_sub(rhs.val);
1705 Self { val }
1706 }
1707 #[cfg(debug_assertions)]
1708 {
1709 let val = self.val.checked_sub(rhs.val).expect(concat!(
1710 "subtracting ",
1711 stringify!($name),
1712 " values overflowed"
1713 ));
1714 let min = self.min.checked_sub(rhs.min).expect(concat!(
1715 "subtracting ",
1716 stringify!($name),
1717 " minimums overflowed"
1718 ));
1719 let max = self.max.checked_sub(rhs.max).expect(concat!(
1720 "subtracting ",
1721 stringify!($name),
1722 " maximums overflowed"
1723 ));
1724 Self { val, min, max }
1725 }
1726 }
1727 }
1728
1729 impl<
1730 const MIN1: i128,
1731 const MAX1: i128,
1732 const MIN2: i128,
1733 const MAX2: i128,
1734 > SubAssign<$name<MIN2, MAX2>> for $name<MIN1, MAX1> {
1735 #[inline]
1736 fn sub_assign(&mut self, rhs: $name<MIN2, MAX2>) {
1737 *self = self.sub(rhs);
1738 }
1739 }
1740
1741 impl<
1742 const MIN1: i128,
1743 const MAX1: i128,
1744 const MIN2: i128,
1745 const MAX2: i128,
1746 > Mul<$name<MIN2, MAX2>> for $name<MIN1, MAX1> {
1747 type Output = Self;
1748
1749 #[inline]
1750 fn mul(self, rhs: $name<MIN2, MAX2>) -> Self::Output {
1751 #[cfg(not(debug_assertions))]
1752 {
1753 let val = self.val.wrapping_mul(rhs.val);
1754 Self { val }
1755 }
1756 #[cfg(debug_assertions)]
1757 {
1758 let val = self.val.checked_mul(rhs.val).expect(concat!(
1759 "multiplying ",
1760 stringify!($name),
1761 " values overflowed"
1762 ));
1763 let min = self.min.checked_mul(rhs.min).expect(concat!(
1764 "multiplying ",
1765 stringify!($name),
1766 " minimums overflowed"
1767 ));
1768 let max = self.max.checked_mul(rhs.max).expect(concat!(
1769 "multiplying ",
1770 stringify!($name),
1771 " maximums overflowed"
1772 ));
1773 Self { val, min, max }
1774 }
1775 }
1776 }
1777
1778 impl<
1779 const MIN1: i128,
1780 const MAX1: i128,
1781 const MIN2: i128,
1782 const MAX2: i128,
1783 > MulAssign<$name<MIN2, MAX2>> for $name<MIN1, MAX1> {
1784 #[inline]
1785 fn mul_assign(&mut self, rhs: $name<MIN2, MAX2>) {
1786 *self = self.mul(rhs);
1787 }
1788 }
1789
1790 impl<
1791 const MIN1: i128,
1792 const MAX1: i128,
1793 const MIN2: i128,
1794 const MAX2: i128,
1795 > Div<$name<MIN2, MAX2>> for $name<MIN1, MAX1> {
1796 type Output = Self;
1797
1798 #[inline]
1799 fn div(self, rhs: $name<MIN2, MAX2>) -> Self::Output {
1800 #[cfg(not(debug_assertions))]
1801 {
1802 let val = self.val.wrapping_div_euclid(rhs.val);
1803 Self { val }
1804 }
1805 #[cfg(debug_assertions)]
1806 {
1807 let val =
1808 self.val.checked_div_euclid(rhs.val).expect(concat!(
1809 "dividing ",
1810 stringify!($name),
1811 " values overflowed"
1812 ));
1813 let min =
1814 self.min.checked_div_euclid(rhs.min).expect(concat!(
1815 "dividing ",
1816 stringify!($name),
1817 " minimums overflowed"
1818 ));
1819 let max =
1820 self.max.checked_div_euclid(rhs.max).expect(concat!(
1821 "dividing ",
1822 stringify!($name),
1823 " maximums overflowed"
1824 ));
1825 Self { val, min, max }
1826 }
1827 }
1828 }
1829
1830 impl<
1831 const MIN1: i128,
1832 const MAX1: i128,
1833 const MIN2: i128,
1834 const MAX2: i128,
1835 > DivAssign<$name<MIN2, MAX2>> for $name<MIN1, MAX1> {
1836 #[inline]
1837 fn div_assign(&mut self, rhs: $name<MIN2, MAX2>) {
1838 *self = self.div(rhs);
1839 }
1840 }
1841
1842 impl<
1843 const MIN1: i128,
1844 const MAX1: i128,
1845 const MIN2: i128,
1846 const MAX2: i128,
1847 > Rem<$name<MIN2, MAX2>> for $name<MIN1, MAX1> {
1848 type Output = Self;
1849
1850 #[inline]
1851 fn rem(self, rhs: $name<MIN2, MAX2>) -> Self::Output {
1852 #[cfg(not(debug_assertions))]
1853 {
1854 let val = self.val.wrapping_rem_euclid(rhs.val);
1855 Self { val }
1856 }
1857 #[cfg(debug_assertions)]
1858 {
1859 let val =
1860 self.val.checked_rem_euclid(rhs.val).expect(concat!(
1861 "modulo ",
1862 stringify!($name),
1863 " values overflowed"
1864 ));
1865 let min =
1866 self.min.checked_rem_euclid(rhs.min).expect(concat!(
1867 "modulo ",
1868 stringify!($name),
1869 " minimums overflowed"
1870 ));
1871 let max =
1872 self.max.checked_rem_euclid(rhs.max).expect(concat!(
1873 "modulo ",
1874 stringify!($name),
1875 " maximums overflowed"
1876 ));
1877 Self { val, min, max }
1878 }
1879 }
1880 }
1881
1882 impl<
1883 const MIN1: i128,
1884 const MAX1: i128,
1885 const MIN2: i128,
1886 const MAX2: i128,
1887 > RemAssign<$name<MIN2, MAX2>> for $name<MIN1, MAX1> {
1888 #[inline]
1889 fn rem_assign(&mut self, rhs: $name<MIN2, MAX2>) {
1890 *self = self.rem(rhs);
1891 }
1892 }
1893
1894 impl<const MIN: i128, const MAX: i128> Add<$name<MIN, MAX>>
1895 for Constant
1896 {
1897 type Output = $name<MIN, MAX>;
1898
1899 #[inline]
1900 fn add(self, rhs: $name<MIN, MAX>) -> Self::Output {
1901 $name::rfrom(self).add(rhs)
1902 }
1903 }
1904
1905 impl<const MIN: i128, const MAX: i128> Add<Constant> for $name<MIN, MAX> {
1906 type Output = $name<MIN, MAX>;
1907
1908 #[inline]
1909 fn add(self, rhs: Constant) -> Self::Output {
1910 self.add(Self::rfrom(rhs))
1911 }
1912 }
1913
1914 impl<const MIN: i128, const MAX: i128> AddAssign<Constant> for $name<MIN, MAX> {
1915 #[inline]
1916 fn add_assign(&mut self, rhs: Constant) {
1917 self.add_assign(Self::rfrom(rhs))
1918 }
1919 }
1920
1921 impl<const MIN: i128, const MAX: i128> Sub<$name<MIN, MAX>> for Constant {
1922 type Output = $name<MIN, MAX>;
1923
1924 #[inline]
1925 fn sub(self, rhs: $name<MIN, MAX>) -> Self::Output {
1926 $name::rfrom(self).sub(rhs)
1927 }
1928 }
1929
1930 impl<const MIN: i128, const MAX: i128> Sub<Constant> for $name<MIN, MAX> {
1931 type Output = $name<MIN, MAX>;
1932
1933 #[inline]
1934 fn sub(self, rhs: Constant) -> Self::Output {
1935 self.sub(Self::rfrom(rhs))
1936 }
1937 }
1938
1939 impl<const MIN: i128, const MAX: i128> SubAssign<Constant> for $name<MIN, MAX> {
1940 #[inline]
1941 fn sub_assign(&mut self, rhs: Constant) {
1942 self.sub_assign(Self::rfrom(rhs))
1943 }
1944 }
1945
1946 impl<const MIN: i128, const MAX: i128> Mul<$name<MIN, MAX>> for Constant {
1947 type Output = $name<MIN, MAX>;
1948
1949 #[inline]
1950 fn mul(self, rhs: $name<MIN, MAX>) -> Self::Output {
1951 $name::rfrom(self).mul(rhs)
1952 }
1953 }
1954
1955 impl<const MIN: i128, const MAX: i128> Mul<Constant> for $name<MIN, MAX> {
1956 type Output = $name<MIN, MAX>;
1957
1958 #[inline]
1959 fn mul(self, rhs: Constant) -> Self::Output {
1960 self.mul(Self::rfrom(rhs))
1961 }
1962 }
1963
1964 impl<const MIN: i128, const MAX: i128> MulAssign<Constant> for $name<MIN, MAX> {
1965 #[inline]
1966 fn mul_assign(&mut self, rhs: Constant) {
1967 self.mul_assign(Self::rfrom(rhs))
1968 }
1969 }
1970
1971 impl<const MIN: i128, const MAX: i128> Div<$name<MIN, MAX>> for Constant {
1972 type Output = $name<MIN, MAX>;
1973
1974 #[inline]
1975 fn div(self, rhs: $name<MIN, MAX>) -> Self::Output {
1976 $name::rfrom(self).div(rhs)
1977 }
1978 }
1979
1980 impl<const MIN: i128, const MAX: i128> Div<Constant> for $name<MIN, MAX> {
1981 type Output = $name<MIN, MAX>;
1982
1983 #[inline]
1984 fn div(self, rhs: Constant) -> Self::Output {
1985 self.div(Self::rfrom(rhs))
1986 }
1987 }
1988 impl<const MIN: i128, const MAX: i128> DivAssign<Constant> for $name<MIN, MAX> {
1989 #[inline]
1990 fn div_assign(&mut self, rhs: Constant) {
1991 self.div_assign(Self::rfrom(rhs))
1992 }
1993 }
1994
1995 impl<const MIN: i128, const MAX: i128> Rem<$name<MIN, MAX>> for Constant {
1996 type Output = $name<MIN, MAX>;
1997
1998 #[inline]
1999 fn rem(self, rhs: $name<MIN, MAX>) -> Self::Output {
2000 $name::rfrom(self).rem(rhs)
2001 }
2002 }
2003
2004 impl<const MIN: i128, const MAX: i128> Rem<Constant> for $name<MIN, MAX> {
2005 type Output = $name<MIN, MAX>;
2006
2007 #[inline]
2008 fn rem(self, rhs: Constant) -> Self::Output {
2009 self.rem(Self::rfrom(rhs))
2010 }
2011 }
2012 impl<const MIN: i128, const MAX: i128> RemAssign<Constant> for $name<MIN, MAX> {
2013 #[inline]
2014 fn rem_assign(&mut self, rhs: Constant) {
2015 self.rem_assign(Self::rfrom(rhs))
2016 }
2017 }
2018
2019 impl<const MIN: i128, const MAX: i128> Eq for $name<MIN, MAX> {}
2020
2021 impl<
2022 const MIN1: i128,
2023 const MAX1: i128,
2024 const MIN2: i128,
2025 const MAX2: i128,
2026 > PartialEq<$name<MIN2, MAX2>> for $name<MIN1, MAX1> {
2027 #[inline]
2028 fn eq(&self, other: &$name<MIN2, MAX2>) -> bool {
2029 self.val.eq(&other.val)
2030 }
2031 }
2032
2033 impl<const MIN: i128, const MAX: i128> PartialEq<Constant> for $name<MIN, MAX> {
2034 #[inline]
2035 fn eq(&self, other: &Constant) -> bool {
2036 self.val.eq(&<$repr>::from(*other))
2037 }
2038 }
2039
2040 impl<const MIN: i128, const MAX: i128> PartialEq<$name<MIN, MAX>> for Constant {
2041 #[inline]
2042 fn eq(&self, other: &$name<MIN, MAX>) -> bool {
2043 <$repr>::from(*self).eq(&other.val)
2044 }
2045 }
2046
2047 impl<const MIN: i128, const MAX: i128> Ord for $name<MIN, MAX> {
2048 #[inline]
2049 fn cmp(&self, other: &Self) -> core::cmp::Ordering {
2050 self.val.cmp(&other.val)
2051 }
2052 }
2053
2054 impl<
2055 const MIN1: i128,
2056 const MAX1: i128,
2057 const MIN2: i128,
2058 const MAX2: i128,
2059 > PartialOrd<$name<MIN2, MAX2>> for $name<MIN1, MAX1> {
2060 #[inline]
2061 fn partial_cmp(
2062 &self,
2063 other: &$name<MIN2, MAX2>,
2064 ) -> Option<core::cmp::Ordering> {
2065 self.val.partial_cmp(&other.val)
2066 }
2067 }
2068
2069 impl<const MIN: i128, const MAX: i128> PartialOrd<Constant> for $name<MIN, MAX> {
2070 #[inline]
2071 fn partial_cmp(
2072 &self,
2073 other: &Constant,
2074 ) -> Option<core::cmp::Ordering> {
2075 self.val.partial_cmp(&<$repr>::from(*other))
2076 }
2077 }
2078
2079 impl<const MIN: i128, const MAX: i128> PartialOrd<$name<MIN, MAX>> for Constant {
2080 #[inline]
2081 fn partial_cmp(
2082 &self,
2083 other: &$name<MIN, MAX>,
2084 ) -> Option<core::cmp::Ordering> {
2085 <$repr>::from(*self).partial_cmp(&other.val)
2086 }
2087 }
2088
2089 impl<const MIN: i128, const MAX: i128> core::fmt::Display for $name<MIN, MAX> {
2090 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2091 // We do this dance here because a Display impl is often used
2092 // when formatting a panic message, and panicking in this
2093 // context is supremely annoying because it causes an instant
2094 // abort. So if this value is not in bounds, then we write out
2095 // its debug repr which should show some nice output.
2096 match self.checked_add(Self::N::<0>()) {
2097 Some(val) => core::fmt::Display::fmt(&val.get(), f),
2098 None => write!(f, "{:?}", self),
2099 }
2100 }
2101 }
2102
2103 impl<const MIN: i128, const MAX: i128> core::fmt::Debug for $name<MIN, MAX> {
2104 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2105 self.debug().fmt(f)
2106 /*
2107 if !f.alternate() {
2108 self.debug().fmt(f)
2109 } else {
2110 #[cfg(not(debug_assertions))]
2111 {
2112 f.debug_struct(stringify!($name))
2113 .field("val", &self.val)
2114 .field("MIN", &MIN)
2115 .field("MAX", &MAX)
2116 .finish()
2117 }
2118 #[cfg(debug_assertions)]
2119 {
2120 f.debug_struct(stringify!($name))
2121 .field("val", &self.val)
2122 .field("MIN", &MIN)
2123 .field("MAX", &MAX)
2124 .field("computed_min", &self.min)
2125 .field("computed_max", &self.max)
2126 .finish()
2127 }
2128 }
2129 */
2130 }
2131 }
2132
2133 #[cfg(test)]
2134 impl<const MIN: i128, const MAX: i128> quickcheck::Arbitrary for $name<MIN, MAX> {
2135 fn arbitrary(g: &mut quickcheck::Gen) -> Self {
2136 let mut n: $repr = <$repr>::arbitrary(g);
2137 if !Self::IS_PRIMITIVE {
2138 n = n.wrapping_rem_euclid(Self::LEN as $repr);
2139 n += Self::MIN_REPR;
2140 }
2141 Self::new(n).unwrap()
2142 }
2143
2144 fn shrink(&self) -> alloc::boxed::Box<dyn Iterator<Item = Self>> {
2145 alloc::boxed::Box::new(self.val.shrink().filter_map(Self::new))
2146 }
2147 }
2148 };
2149}
2150
2151define_ranged!(ri8, i8, smaller {}, bigger { ri16 i16, ri32 i32, ri64 i64, ri128 i128 });
2152define_ranged!(ri16, i16, smaller { ri8 i8 }, bigger { ri32 i32, ri64 i64, ri128 i128 });
2153define_ranged!(ri32, i32, smaller { ri8 i8, ri16 i16 }, bigger { ri64 i64, ri128 i128 });
2154define_ranged!(ri64, i64, smaller { ri8 i8, ri16 i16, ri32 i32 }, bigger { ri128 i128 });
2155define_ranged!(ri128, i128, smaller { ri8 i8, ri16 i16, ri32 i32, ri64 i64 }, bigger {});
2156
2157impl<const MIN: i128, const MAX: i128> ri8<MIN, MAX> {
2158 #[inline]
2159 pub(crate) fn without_bounds(
2160 self,
2161 ) -> ri64<{ i64::MIN as i128 }, { i64::MAX as i128 }> {
2162 ri64::rfrom(self)
2163 }
2164}
2165
2166impl<const MIN: i128, const MAX: i128> ri16<MIN, MAX> {
2167 #[inline]
2168 pub(crate) fn without_bounds(
2169 self,
2170 ) -> ri64<{ i64::MIN as i128 }, { i64::MAX as i128 }> {
2171 ri64::rfrom(self)
2172 }
2173}
2174
2175impl<const MIN: i128, const MAX: i128> ri32<MIN, MAX> {
2176 #[inline]
2177 pub(crate) fn without_bounds(
2178 self,
2179 ) -> ri64<{ i64::MIN as i128 }, { i64::MAX as i128 }> {
2180 ri64::rfrom(self)
2181 }
2182}
2183
2184impl<const MIN: i128, const MAX: i128> ri64<MIN, MAX> {
2185 #[inline]
2186 pub(crate) fn without_bounds(
2187 self,
2188 ) -> ri64<{ i64::MIN as i128 }, { i64::MAX as i128 }> {
2189 ri64::rfrom(self)
2190 }
2191}
2192
2193impl<const MIN: i128, const MAX: i128> ri128<MIN, MAX> {
2194 #[inline]
2195 pub(crate) fn without_bounds(self) -> ri128<{ i128::MIN }, { i128::MAX }> {
2196 ri128::rfrom(self)
2197 }
2198}
2199
2200pub(crate) struct RangedDebug<const MIN: i128, const MAX: i128> {
2201 rint: ri128<MIN, MAX>,
2202}
2203
2204impl<const MIN: i128, const MAX: i128> core::fmt::Debug
2205 for RangedDebug<MIN, MAX>
2206{
2207 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2208 #[cfg(not(debug_assertions))]
2209 {
2210 let val = self.rint.get_unchecked();
2211 if <ri128<MIN, MAX>>::contains(val) {
2212 val.fmt(f)
2213 } else {
2214 write!(f, "#{val:?} [out of range: {MIN}..={MAX}]#")
2215 }
2216 }
2217 #[cfg(debug_assertions)]
2218 {
2219 let val = self.rint.get_unchecked();
2220 let min = self.rint.min;
2221 let max = self.rint.max;
2222 if <ri128<MIN, MAX>>::contains(val)
2223 && <ri128<MIN, MAX>>::contains(min)
2224 && <ri128<MIN, MAX>>::contains(max)
2225 {
2226 val.fmt(f)
2227 } else {
2228 write!(
2229 f,
2230 "#{val:?} \
2231 [out of range: {MIN}..={MAX}] \
2232 [possible range: {min}..={max}]#",
2233 )
2234 }
2235 }
2236 }
2237}
2238
2239/// A trait for losslessly converting between ranged integers.
2240///
2241/// This trait exists despite the fact that the standard library `From` trait
2242/// is defined in precisely the same way. Indeed, the `From` trait _almost_
2243/// works for our use case. The problem arises from the fact that we want
2244/// to be able to write this trait impl:
2245///
2246/// ```ignore
2247/// impl<
2248/// const MIN1: i128,
2249/// const MAX1: i128,
2250/// const MIN2: i128,
2251/// const MAX2: i128,
2252/// > From<ri64<MIN1, MAX1>> for ri64<MIN2, MAX2> {
2253/// // ...
2254/// }
2255/// ```
2256///
2257/// (We want this impl because we want to be able to freely convert between any
2258/// kind of ranged integers, including ranged integers with the same primitive
2259/// representation but different bounds.)
2260///
2261/// But this trait impl can't exist because it overlaps with the blanket
2262/// `impl From<T> for T`. Indeed, here, we do not provide that blanket impl,
2263/// which lets us add the trait impl above for `RFrom`.
2264///
2265/// This would normally be a no-go because it's too important for library
2266/// crates to provide types that work with `From` as you might expect, but
2267/// range integers are thankfully a crate internal abstraction. So we just need
2268/// to write `impl RFrom<T>` and do `t.rinto()` instead of `impl From<T>` and
2269/// `t.into()`.
2270pub(crate) trait RFrom<T>: Sized {
2271 fn rfrom(value: T) -> Self;
2272}
2273
2274/// A trait for losslessly converting to ranged integers.
2275///
2276/// This goes along with `RFrom` and exists to make things like `t.rinto()`
2277/// work without the need to do `T::rfrom(..)`. Like the standard library
2278/// `Into` trait, a blanket impl is provided based on impls of `RFrom`. Callers
2279/// are not expected to implement this trait directly.
2280pub(crate) trait RInto<T>: Sized {
2281 fn rinto(self) -> T;
2282}
2283
2284impl<T, U> RInto<U> for T
2285where
2286 U: RFrom<T>,
2287{
2288 fn rinto(self) -> U {
2289 RFrom::rfrom(self)
2290 }
2291}
2292
2293pub(crate) trait TryRFrom<T>: Sized {
2294 fn try_rfrom(what: &'static str, value: T) -> Result<Self, Error>;
2295}
2296
2297pub(crate) trait TryRInto<T>: Sized {
2298 fn try_rinto(self, what: &'static str) -> Result<T, Error>;
2299}
2300
2301impl<T, U> TryRInto<U> for T
2302where
2303 U: TryRFrom<T>,
2304{
2305 #[inline]
2306 fn try_rinto(self, what: &'static str) -> Result<U, Error> {
2307 U::try_rfrom(what, self)
2308 }
2309}
2310
2311macro_rules! composite {
2312 (($($name:ident),* $(,)?) => $with:expr) => {{
2313 crate::util::rangeint::composite!(($($name = $name),*) => $with)
2314 }};
2315 (($($name:ident = $rangeint:expr),* $(,)?) => $with:expr) => {{
2316 #[cfg(not(debug_assertions))]
2317 {
2318 $(
2319 let $name = $rangeint.val;
2320 )*
2321 let val = $with;
2322 crate::util::rangeint::Composite { val }
2323 }
2324 #[cfg(debug_assertions)]
2325 {
2326 let val = {
2327 $(
2328 let $name = $rangeint.val;
2329 )*
2330 $with
2331 };
2332 let min = {
2333 $(
2334 let $name = $rangeint.min;
2335 )*
2336 $with
2337 };
2338 let max = {
2339 $(
2340 let $name = $rangeint.max;
2341 )*
2342 $with
2343 };
2344 crate::util::rangeint::Composite { val, min, max }
2345 }
2346 }};
2347}
2348
2349macro_rules! uncomposite {
2350 ($composite:expr, $val:ident => ($($get:expr),* $(,)?) $(,)?) => {{
2351 #[cfg(not(debug_assertions))]
2352 {
2353 ($({
2354 let val = {
2355 let $val = $composite.val;
2356 $get
2357 };
2358 crate::util::rangeint::Composite { val }
2359 }),*)
2360 }
2361 #[cfg(debug_assertions)]
2362 {
2363 ($({
2364 let val = {
2365 let $val = $composite.val;
2366 $get
2367 };
2368 let min = {
2369 let $val = $composite.min;
2370 $get
2371 };
2372 let max = {
2373 let $val = $composite.max;
2374 $get
2375 };
2376 crate::util::rangeint::Composite { val, min, max }
2377 }),*)
2378 }
2379 }};
2380}
2381
2382pub(crate) use {composite, uncomposite};
2383
2384#[derive(Clone, Debug, Eq, PartialEq)]
2385pub(crate) struct Composite<T> {
2386 pub(crate) val: T,
2387 #[cfg(debug_assertions)]
2388 pub(crate) min: T,
2389 #[cfg(debug_assertions)]
2390 pub(crate) max: T,
2391}
2392
2393impl<T> Composite<T> {
2394 #[inline]
2395 pub(crate) fn map<U>(self, map: impl Fn(T) -> U) -> Composite<U> {
2396 #[cfg(not(debug_assertions))]
2397 {
2398 Composite { val: map(self.val) }
2399 }
2400 #[cfg(debug_assertions)]
2401 {
2402 Composite {
2403 val: map(self.val),
2404 min: map(self.min),
2405 max: map(self.max),
2406 }
2407 }
2408 }
2409
2410 #[inline]
2411 pub(crate) fn zip2<U>(self, other: Composite<U>) -> Composite<(T, U)> {
2412 #[cfg(not(debug_assertions))]
2413 {
2414 Composite { val: (self.val, other.val) }
2415 }
2416 #[cfg(debug_assertions)]
2417 {
2418 Composite {
2419 val: (self.val, other.val),
2420 min: (self.min, other.min),
2421 max: (self.max, other.max),
2422 }
2423 }
2424 }
2425}
2426
2427impl<T, U> Composite<(T, U)> {
2428 #[inline]
2429 pub(crate) fn unzip2(self) -> (Composite<T>, Composite<U>) {
2430 #[cfg(not(debug_assertions))]
2431 {
2432 (Composite { val: self.val.0 }, Composite { val: self.val.1 })
2433 }
2434 #[cfg(debug_assertions)]
2435 {
2436 (
2437 Composite {
2438 val: self.val.0,
2439 min: self.min.0,
2440 max: self.max.0,
2441 },
2442 Composite {
2443 val: self.val.1,
2444 min: self.min.1,
2445 max: self.max.1,
2446 },
2447 )
2448 }
2449 }
2450}
2451
2452impl Composite<i8> {
2453 pub(crate) const fn to_rint<const MIN: i128, const MAX: i128>(
2454 self,
2455 ) -> ri8<MIN, MAX> {
2456 #[cfg(not(debug_assertions))]
2457 {
2458 ri8 { val: self.val }
2459 }
2460 #[cfg(debug_assertions)]
2461 {
2462 ri8 { val: self.val, min: self.min, max: self.max }
2463 }
2464 }
2465}
2466
2467impl Composite<i16> {
2468 pub(crate) const fn to_rint<const MIN: i128, const MAX: i128>(
2469 self,
2470 ) -> ri16<MIN, MAX> {
2471 #[cfg(not(debug_assertions))]
2472 {
2473 ri16 { val: self.val }
2474 }
2475 #[cfg(debug_assertions)]
2476 {
2477 ri16 { val: self.val, min: self.min, max: self.max }
2478 }
2479 }
2480}
2481
2482impl Composite<i32> {
2483 pub(crate) const fn to_rint<const MIN: i128, const MAX: i128>(
2484 self,
2485 ) -> ri32<MIN, MAX> {
2486 #[cfg(not(debug_assertions))]
2487 {
2488 ri32 { val: self.val }
2489 }
2490 #[cfg(debug_assertions)]
2491 {
2492 ri32 { val: self.val, min: self.min, max: self.max }
2493 }
2494 }
2495}
2496
2497impl Composite<i64> {
2498 pub(crate) const fn to_rint<const MIN: i128, const MAX: i128>(
2499 self,
2500 ) -> ri64<MIN, MAX> {
2501 #[cfg(not(debug_assertions))]
2502 {
2503 ri64 { val: self.val }
2504 }
2505 #[cfg(debug_assertions)]
2506 {
2507 ri64 { val: self.val, min: self.min, max: self.max }
2508 }
2509 }
2510
2511 pub(crate) fn try_to_rint<const MIN: i128, const MAX: i128>(
2512 self,
2513 what: &'static str,
2514 ) -> Result<ri64<MIN, MAX>, Error> {
2515 #[cfg(not(debug_assertions))]
2516 {
2517 if !ri64::<MIN, MAX>::contains(self.val) {
2518 return Err(ri64::<MIN, MAX>::error(what, self.val));
2519 }
2520 Ok(ri64 { val: self.val })
2521 }
2522 #[cfg(debug_assertions)]
2523 {
2524 if !ri64::<MIN, MAX>::contains(self.val) {
2525 return Err(ri64::<MIN, MAX>::error(what, self.val));
2526 }
2527 Ok(ri64 {
2528 val: self.val,
2529 min: self.min.clamp(MIN as i64, MAX as i64),
2530 max: self.max.clamp(MIN as i64, MAX as i64),
2531 })
2532 }
2533 }
2534}
2535
2536#[cfg(test)]
2537mod tests {
2538 // use super::*;
2539
2540 // What follows below are some tests I wrote for my attempt at implementing
2541 // Ada-style modular/cyclic arithmetic on ranged integers. I found it to
2542 // be incredibly challenging. I decided that I could make do with only
2543 // using wrapping arithmetic on primitive-ranged integers and gave up.
2544 //
2545 // I did briefly look at GNAT to see if it could be of help, but I found
2546 // the source overwhelming and didn't find anything. I also could find any
2547 // help on the broader web for how to implement this correctly.
2548 //
2549 // Probably the next step here is to sit down with a pen & paper and work
2550 // out how this should be done, assuming we need/want it. One thing I ran
2551 // into was doing modular arithmetic when the range was bigger than the
2552 // underlying primitive representation. I could see how to do it if we
2553 // allowed casting up to a bigger integer representation, but I really
2554 // wanted to avoid doing that.
2555 /*
2556 type PrimitiveInt = ri8<{ i8::MIN as i128 }, { i8::MAX as i128 }>;
2557 type SmallInt = ri8<-20, 20>;
2558 type AlmostPrimitiveInt =
2559 ri8<{ i8::MIN as i128 }, { (i8::MAX - 1) as i128 }>;
2560
2561 #[test]
2562 fn wrapping_add_small() {
2563 let int = |n| SmallInt::new(n).unwrap();
2564
2565 assert_eq!(int(15).wrapping_add(int(5)), 20);
2566 assert_eq!(int(15).wrapping_add(int(6)), -20);
2567 assert_eq!(int(15).wrapping_add(int(-6)), 9);
2568 assert_eq!(int(-5).wrapping_add(int(5)), 0);
2569 assert_eq!(int(-5).wrapping_add(int(6)), 1);
2570 assert_eq!(int(-5).wrapping_add(int(3)), -2);
2571 assert_eq!(int(-5).wrapping_add(int(-3)), -8);
2572 assert_eq!(int(-5).wrapping_add(int(-13)), -18);
2573 assert_eq!(int(-5).wrapping_add(int(-15)), -20);
2574 assert_eq!(int(-5).wrapping_add(int(-16)), 20);
2575
2576 // These tests get SmallInts that are out-of-bounds (which is legal as
2577 // an intermediate value) and then try to do wrapping arithmetic on
2578 // them.
2579 let a: SmallInt = PrimitiveInt::new(127).unwrap();
2580 assert_eq!(a.wrapping_add(int(1)), 5);
2581 let a: SmallInt = PrimitiveInt::new(-128).unwrap();
2582 assert_eq!(a.wrapping_add(int(-1)), -6);
2583
2584 let a: SmallInt = PrimitiveInt::new(127).unwrap();
2585 let b: SmallInt = PrimitiveInt::new(127).unwrap();
2586 assert_eq!(a.wrapping_add(b), 8);
2587
2588 let a: SmallInt = PrimitiveInt::new(-128).unwrap();
2589 let b: SmallInt = PrimitiveInt::new(-128).unwrap();
2590 assert_eq!(a.wrapping_add(b), -10);
2591
2592 let a: SmallInt = PrimitiveInt::new(127).unwrap();
2593 let b: SmallInt = PrimitiveInt::new(-128).unwrap();
2594 assert_eq!(a.wrapping_add(b), -1);
2595
2596 let a: SmallInt = PrimitiveInt::new(-128).unwrap();
2597 let b: SmallInt = PrimitiveInt::new(127).unwrap();
2598 assert_eq!(a.wrapping_add(b), -1);
2599 }
2600
2601 #[test]
2602 fn wrapping_add_almost_primitive() {
2603 let int = |n| AlmostPrimitiveInt::new(n).unwrap();
2604
2605 assert_eq!(int(126).wrapping_add(int(126)), 0);
2606 }
2607
2608 quickcheck::quickcheck! {
2609 fn prop_wrapping_add_always_in_bounds(
2610 n1: SmallInt,
2611 n2: SmallInt
2612 ) -> bool {
2613 let sum = n1.wrapping_add(n2).get();
2614 SmallInt::contains(sum)
2615 }
2616
2617 fn prop_wrapping_add_always_in_bounds_primitive(
2618 n1: PrimitiveInt,
2619 n2: PrimitiveInt
2620 ) -> bool {
2621 let sum = n1.wrapping_add(n2).get();
2622 PrimitiveInt::contains(sum)
2623 }
2624 }
2625 */
2626}
2627

Provided by KDAB

Privacy Policy