Skip to main content

zinc_uair/
dummy_semiring.rs

1use std::{
2    fmt::{Debug, Display},
3    iter::{Product, Sum},
4    ops::{Add, AddAssign, Mul, MulAssign, Sub, SubAssign},
5};
6
7use crypto_primitives::Semiring;
8use num_traits::{CheckedAdd, CheckedMul, CheckedSub, ConstOne, ConstZero, One, Zero};
9use zinc_utils::{from_ref::FromRef, mul_by_scalar::MulByScalar};
10
11/// A dummy type implementing `FixedSemiring` trait.
12/// Used for `ConstraintCounter` to have something
13/// that implements `FixedSemiring` but has zero-cost
14/// operations. Can be used in other contexts
15/// where operations on expression should be ignored.
16#[derive(Clone, Copy, Default, Debug, PartialEq, Eq, Hash)]
17pub struct DummySemiring;
18
19impl Display for DummySemiring {
20    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21        Debug::fmt(&self, f)
22    }
23}
24
25macro_rules! impl_binary_op {
26    ($trait:ident, $op:ident) => {
27        impl $trait<&DummySemiring> for DummySemiring {
28            type Output = Self;
29
30            #[inline(always)]
31            fn $op(self, _rhs: &DummySemiring) -> Self::Output {
32                DummySemiring
33            }
34        }
35
36        impl $trait<DummySemiring> for DummySemiring {
37            type Output = Self;
38
39            #[inline(always)]
40            fn $op(self, _rhs: DummySemiring) -> Self::Output {
41                DummySemiring
42            }
43        }
44    };
45}
46
47impl_binary_op!(Add, add);
48impl_binary_op!(Sub, sub);
49impl_binary_op!(Mul, mul);
50
51macro_rules! impl_op_assign {
52    ($trait:ident, $op:ident) => {
53        impl $trait<&DummySemiring> for DummySemiring {
54            #[inline(always)]
55            fn $op(&mut self, _rhs: &DummySemiring) {}
56        }
57
58        impl $trait<DummySemiring> for DummySemiring {
59            #[inline(always)]
60            fn $op(&mut self, _rhs: DummySemiring) {}
61        }
62    };
63}
64
65impl_op_assign!(AddAssign, add_assign);
66impl_op_assign!(SubAssign, sub_assign);
67impl_op_assign!(MulAssign, mul_assign);
68
69macro_rules! impl_checked_op {
70    ($trait:ident, $op:ident) => {
71        impl $trait for DummySemiring {
72            #[inline(always)]
73            fn $op(&self, _rhs: &Self) -> Option<Self> {
74                Some(DummySemiring)
75            }
76        }
77    };
78}
79
80impl_checked_op!(CheckedAdd, checked_add);
81impl_checked_op!(CheckedSub, checked_sub);
82impl_checked_op!(CheckedMul, checked_mul);
83
84impl Sum for DummySemiring {
85    #[inline(always)]
86    fn sum<I: Iterator<Item = Self>>(_iter: I) -> Self {
87        DummySemiring
88    }
89}
90
91impl Product for DummySemiring {
92    #[inline(always)]
93    fn product<I: Iterator<Item = Self>>(_iter: I) -> Self {
94        DummySemiring
95    }
96}
97
98impl<'a> Sum<&'a DummySemiring> for DummySemiring {
99    #[inline(always)]
100    fn sum<I: Iterator<Item = &'a DummySemiring>>(_iter: I) -> Self {
101        DummySemiring
102    }
103}
104
105impl<'a> Product<&'a DummySemiring> for DummySemiring {
106    #[inline(always)]
107    fn product<I: Iterator<Item = &'a DummySemiring>>(_iter: I) -> Self {
108        DummySemiring
109    }
110}
111
112impl Zero for DummySemiring {
113    fn zero() -> Self {
114        DummySemiring
115    }
116
117    fn is_zero(&self) -> bool {
118        true
119    }
120}
121
122impl One for DummySemiring {
123    fn one() -> Self {
124        DummySemiring
125    }
126}
127
128impl ConstZero for DummySemiring {
129    const ZERO: Self = DummySemiring;
130}
131
132impl ConstOne for DummySemiring {
133    const ONE: Self = DummySemiring;
134}
135
136impl Semiring for DummySemiring {}
137
138impl<T> FromRef<T> for DummySemiring {
139    #[inline(always)]
140    fn from_ref(_value: &T) -> Self {
141        DummySemiring
142    }
143}
144
145impl<T> MulByScalar<&T> for DummySemiring {
146    #[inline(always)]
147    fn mul_by_scalar<const CHECKED: bool>(&self, _rhs: &T) -> Option<Self> {
148        Some(DummySemiring)
149    }
150}