rsdiff-core 0.0.2

This is the core library for the Acme project. It contains the core primitives that are used throughout the project.
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
95
96
97
98
99
100
101
102
103

/*
    Appellation: kinds <mod>
    Contrib: FL03 <jo3mccain@icloud.com>
*/
use crate::ops::ternary::ApplyTernary;
use crate::ops::{OpKind, Operator};
use strum::{Display, EnumCount, EnumDiscriminants, EnumIs, EnumIter, EnumString, VariantNames};

#[derive(
    Clone,
    Copy,
    Debug,
    Display,
    EnumCount,
    EnumDiscriminants,
    EnumIs,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    VariantNames,
)]
#[cfg_attr(
    feature = "serde",
    derive(serde::Deserialize, serde::Serialize,),
    serde(rename_all = "lowercase", untagged),
    strum_discriminants(derive(serde::Deserialize, serde::Serialize))
)]
#[strum(serialize_all = "lowercase")]
#[strum_discriminants(
    derive(
        Display,
        EnumCount,
        EnumIs,
        EnumIter,
        EnumString,
        Hash,
        Ord,
        PartialOrd,
        VariantNames
    ),
    name(TernaryOp),
    strum(serialize_all = "lowercase")
)]
pub enum TernaryExpr {
    Affine(Affine),
}

impl Operator for TernaryExpr {
    fn kind(&self) -> OpKind {
        OpKind::Ternary
    }

    fn name(&self) -> &str {
        match self {
            TernaryExpr::Affine(op) => op.name(),
        }
    }
}

impl Operator for TernaryOp {
    fn kind(&self) -> OpKind {
        OpKind::Ternary
    }

    fn name(&self) -> &str {
        match self {
            Self::Affine => "affine",
        }
    }
}

#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[cfg_attr(
    feature = "serde",
    derive(serde::Deserialize, serde::Serialize),
    serde(rename_all = "lowercase")
)]
#[repr(C)]
pub struct Affine;

impl Operator for Affine {
    fn kind(&self) -> OpKind {
        OpKind::Ternary
    }

    fn name(&self) -> &str {
        "affine"
    }
}

impl<A, B, C> ApplyTernary<A, B, C> for Affine
where
    A: core::ops::Mul<B, Output = C>,
    C: core::ops::Add<Output = C>,
{
    type Output = C;

    fn apply(&self, a: A, b: B, c: C) -> Self::Output {
        a * b + c
    }
}