Enum GeneratorAction 

pub enum GeneratorAction {
    Functor {
        map_object: Vec<(String, String)>,
        map_morphism: Vec<(String, String)>,
    },
    NaturalTransformation {
        components: Vec<(String, String)>,
    },
    Lens {
        view: String,
        get: String,
        put: String,
    },
    Adjunction {
        left_map_object: Vec<(String, String)>,
        right_map_object: Vec<(String, String)>,
        unit: Vec<(String, String)>,
        counit: Vec<(String, String)>,
    },
}

The finite action-on-generators that is a connection. The variant names the categorical family; every table is (source-generator name → target expression), which is why one representation serves all of them.

Variants

Functor

A functor: where each source generating object and relation-kind goes.

Fields

map_object: Vec<(String, String)>

(source object name, target expression), one row per generator.

map_morphism: Vec<(String, String)>

(source relation-kind name, target kind expression).

NaturalTransformation

A natural transformation η: F ⇒ G: one component per object, η_x : F(x) → G(x).

Fields

components: Vec<(String, String)>

(object name, component-morphism expression).

Lens

A bidirectional lens (Foster et al. 2007): a view focus with get/ put morphisms. The .prx decompile round-trip is itself a lens.

Fields

view: String

get: String

put: String

Adjunction

An adjunction F ⊣ G: the two functors’ object maps plus the unit η and counit ε component families.

Fields

left_map_object: Vec<(String, String)>

right_map_object: Vec<(String, String)>

unit: Vec<(String, String)>

counit: Vec<(String, String)>

Trait Implementations

impl Clone for GeneratorAction

fn clone(&self) -> GeneratorAction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GeneratorAction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GeneratorAction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for GeneratorAction

impl PartialEq for GeneratorAction

fn eq(&self, other: &GeneratorAction) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for GeneratorAction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for GeneratorAction