Struct CompiledMigration 

pub struct CompiledMigration {
    pub surviving_verts: HashSet<Name>,
    pub surviving_edges: HashSet<Edge>,
    pub vertex_remap: HashMap<Name, Name>,
    pub edge_remap: HashMap<Edge, Edge>,
    pub resolver: HashMap<(Name, Name), Edge>,
    pub hyper_resolver: HashMap<Name, (Name, HashMap<Name, Name>)>,
    pub field_transforms: HashMap<Name, Vec<FieldTransform>>,
    pub conditional_survival: HashMap<Name, Expr>,
    pub expansion_path: HashMap<(Name, Name), Vec<Name>>,
}

A compiled migration specification (minimal version for panproto-inst).

The full CompiledMigration lives in panproto-mig. This type provides the subset of fields that wtype_restrict and functor_restrict need.

Fields

surviving_verts: HashSet<Name>

Vertices that survive the migration.

surviving_edges: HashSet<Edge>

Edges that survive the migration.

vertex_remap: HashMap<Name, Name>

Vertex remapping: source vertex ID to target vertex ID.

edge_remap: HashMap<Edge, Edge>

Edge remapping: source edge to target edge.

resolver: HashMap<(Name, Name), Edge>

Binary contraction resolver: (src_anchor, tgt_anchor) to resolved edge.

hyper_resolver: HashMap<Name, (Name, HashMap<Name, Name>)>

Hyper-edge contraction resolver.

field_transforms: HashMap<Name, Vec<FieldTransform>>

Value-level field transforms applied to surviving nodes’ extra_fields.

Keyed by source vertex anchor. Each entry is a list of field operations applied in order after the node survives and is remapped.

conditional_survival: HashMap<Name, Expr>

Value-dependent survival predicates.

During wtype_restrict, after checking that a node’s anchor vertex is in surviving_verts, the conditional survival predicate (if any) is evaluated with the node’s extra_fields bound as variables. If the predicate evaluates to false, the node is dropped despite its anchor surviving.

This enables value-dependent filtering: “keep this vertex only if attrs.level == 2” (matchAttrs), or “keep this vertex only if class contains ‘u-url’” (matchAttrsAll).

Categorically, this is a refinement of the survival predicate from a structural predicate (vertex set membership) to a value-dependent predicate (vertex set membership AND value predicate).

expansion_path: HashMap<(Name, Name), Vec<Name>>

Multi-hop expansion paths for nest-style migrations.

When a direct edge src --> tgt existed in the source schema but only a multi-hop path src --> i1 --> i2 --> ... --> tgt exists in the target (as happens after combinators::nest_field), this map records the sequence of intermediate target anchor ids to insert when walking the source arc during wtype_restrict. The value is the intermediate anchors only (endpoints excluded), ordered from parent-adjacent to child-adjacent.

Dual of the ancestor-contraction mechanism: contraction collapses a path to a direct arc (hoist), expansion fans a direct arc out into a path by materializing fresh view nodes (nest).

Implementations

impl CompiledMigration

pub fn coercion_class(&self) -> CoercionClass

Compute the composite coercion class of all field transforms in this migration.

Folds over every transform across all vertices using CoercionClass::compose, starting from Iso (the identity element).

pub fn add_field_rename(&mut self, vertex: &str, old_key: &str, new_key: &str)

Add a field rename transform for a vertex.

After the node survives and its anchor is remapped, the field old_key in extra_fields is renamed to new_key.

pub fn add_field_drop(&mut self, vertex: &str, key: &str)

Add a field drop transform for a vertex.

The field key is removed from the node’s extra_fields.

pub fn add_field_default(&mut self, vertex: &str, key: &str, value: Value)

Add a field with a default value for a vertex.

The field key is added to extra_fields with the given value if it does not already exist.

pub fn add_field_keep(&mut self, vertex: &str, keys: &[&str])

Add a keep-fields transform for a vertex.

Only the specified fields are retained in extra_fields; all others are dropped.

pub fn add_field_expr(&mut self, vertex: &str, key: &str, expr: Expr)

Add an expression transform for a field on a vertex.

The expression is evaluated with the field’s current value bound to the variable named key, and the result replaces the field value.

pub fn add_path_transform( &mut self, vertex: &str, path: &[&str], inner: FieldTransform, )

Add a path-based field transform for a vertex.

The inner transform is applied at the nested path within the node’s extra_fields tree, navigating through Value::Unknown maps at each path segment.

pub fn add_computed_field(&mut self, vertex: &str, target_key: &str, expr: Expr)

Add a computed field transform for a vertex.

The expression is evaluated with all extra_fields (and nested attrs) bound as variables, and the result is stored in target_key.

pub fn add_conditional_survival(&mut self, vertex: &str, predicate: Expr)

Add a conditional survival predicate for a vertex.

The expression is evaluated with the node’s extra_fields bound as variables. If it returns false, the node is dropped.

pub fn add_map_references( &mut self, vertex: &str, field: &str, rename_map: HashMap<String, Option<String>>, )

Add a reference map transform for a vertex’s field.

String values (or encoded array elements) in the given field are renamed or removed according to the rename_map.

pub fn add_case_transform(&mut self, vertex: &str, branches: Vec<CaseBranch>)

Add a case-analysis transform for a vertex.

The branches are evaluated in order; the first matching predicate’s transforms are applied. This is the dependent function space lift of field transforms.

Trait Implementations

impl Clone for CompiledMigration

fn clone(&self) -> CompiledMigration

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompiledMigration

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

Formats the value using the given formatter.

impl Default for CompiledMigration

fn default() -> CompiledMigration

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CompiledMigration

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CompiledMigration

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

where __S: Serializer,

Serialize this value into the given Serde serializer.