use alux_ext::ext;
#[diagnostic::on_unimplemented(
message = "`{Self}` is not stated as a product of its fields",
note = "`#[derive(Shape)]` states `Product` for a struct with named members; a skipped member is made with `Default`, and a flattened one is one field"
)]
pub trait Product: Sized {
type Fields;
const FIELDS: &'static [&'static str];
fn from_fields(fields: Self::Fields) -> Self;
fn into_fields(self) -> Self::Fields;
}
#[diagnostic::on_unimplemented(
message = "`{Self}` is not stated as a sum of its alternatives",
note = "`#[derive(Shape)]` states `Sum` for an enum of two to sixteen alternatives, each carrying one value or none"
)]
pub trait Sum: Sized {
type Alternatives;
const ALTERNATIVES: &'static [&'static str];
fn from_alternative(alternative: Self::Alternatives) -> Self;
fn into_alternative(self) -> Self::Alternatives;
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum2<A, B> {
A(A),
B(B),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum3<A, B, C> {
A(A),
B(B),
C(C),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum4<A, B, C, D> {
A(A),
B(B),
C(C),
D(D),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum5<A, B, C, D, E> {
A(A),
B(B),
C(C),
D(D),
E(E),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum6<A, B, C, D, E, F> {
A(A),
B(B),
C(C),
D(D),
E(E),
F(F),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum7<A, B, C, D, E, F, G> {
A(A),
B(B),
C(C),
D(D),
E(E),
F(F),
G(G),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum8<A, B, C, D, E, F, G, H> {
A(A),
B(B),
C(C),
D(D),
E(E),
F(F),
G(G),
H(H),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum9<A, B, C, D, E, F, G, H, I> {
A(A),
B(B),
C(C),
D(D),
E(E),
F(F),
G(G),
H(H),
I(I),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum10<A, B, C, D, E, F, G, H, I, J> {
A(A),
B(B),
C(C),
D(D),
E(E),
F(F),
G(G),
H(H),
I(I),
J(J),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum11<A, B, C, D, E, F, G, H, I, J, K> {
A(A),
B(B),
C(C),
D(D),
E(E),
F(F),
G(G),
H(H),
I(I),
J(J),
K(K),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum12<A, B, C, D, E, F, G, H, I, J, K, L> {
A(A),
B(B),
C(C),
D(D),
E(E),
F(F),
G(G),
H(H),
I(I),
J(J),
K(K),
L(L),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum13<A, B, C, D, E, F, G, H, I, J, K, L, M> {
A(A),
B(B),
C(C),
D(D),
E(E),
F(F),
G(G),
H(H),
I(I),
J(J),
K(K),
L(L),
M(M),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum14<A, B, C, D, E, F, G, H, I, J, K, L, M, N> {
A(A),
B(B),
C(C),
D(D),
E(E),
F(F),
G(G),
H(H),
I(I),
J(J),
K(K),
L(L),
M(M),
N(N),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> {
A(A),
B(B),
C(C),
D(D),
E(E),
F(F),
G(G),
H(H),
I(I),
J(J),
K(K),
L(L),
M(M),
N(N),
O(O),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Sum16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> {
A(A),
B(B),
C(C),
D(D),
E(E),
F(F),
G(G),
H(H),
I(I),
J(J),
K(K),
L(L),
M(M),
N(N),
O(O),
P(P),
}
#[ext(name = ProductLawsExt)]
pub impl<This, Fields> This
where
This: Product<Fields = Fields> + Clone,
Fields: Clone + PartialEq,
{
fn law_product_round_trip(&self) -> bool {
let fields = self.clone().into_fields();
This::from_fields(fields.clone()).into_fields() == fields
}
}
#[ext(name = SumLawsExt)]
pub impl<This> This
where
This: Sum + Clone + PartialEq,
{
fn law_sum_round_trip(&self) -> bool {
This::from_alternative(self.clone().into_alternative()) == *self
}
}