morphism type: add apply_subst()

src/morphism_path_sugared.rs

@@ -54,10 +54,7 @@ impl<'a, M:SugaredMorphism+Clone> SugaredShortestPathProblem<'a, M> {
         let mut creates_loop = false;
 
         let mut new_path = prev_path.clone();
-        for n in new_path.morphisms.iter_mut() {
-            n.apply_subst(&morph_inst.get_subst());
-        }
-
+        new_path.apply_subst(&morph_inst.get_subst());
         for m in new_path.morphisms.iter() {
             if m.get_type().src_type == dst_type {
                 creates_loop = true;

src/morphism_sugared.rs

@@ -135,6 +135,13 @@ impl SugaredMorphismType {
             (x,y) => SugaredMorphismType { src_type: x.clone(), dst_type: y.clone() }
         }
     }
+
+    pub fn apply_subst(&self, σ: &impl SugaredSubstitution) -> SugaredMorphismType {
+        SugaredMorphismType {
+            src_type: self.src_type.clone().apply_subst(σ).clone(),
+            dst_type: self.dst_type.clone().apply_subst(σ).clone()
+        }
+    }
 }
 
 pub trait SugaredMorphism : Sized {

src/sugar.rs

@@ -247,11 +247,29 @@ impl SugaredTypeTerm {
                     members.into_iter().map(|t| t.desugar(dict))
                 ).collect()),
             SugaredTypeTerm::Enum{ enum_repr, variants } => TypeTerm::App(
-                std::iter::once( dict.parse("Enum").unwrap() ).chain(
+                std::iter::once(
+                    if let Some(sr) = enum_repr {
+                        TypeTerm::Ladder(vec![
+                            dict.parse("Enum").unwrap(),
+                            sr.desugar(dict)
+                        ])
+                    } else {
+                        dict.parse("Enum").unwrap()
+                    }
+                ).chain(
                     variants.into_iter().map(|t| t.desugar(dict))
                 ).collect()),
             SugaredTypeTerm::Seq{ seq_repr, items } => TypeTerm::App(
-                std::iter::once( dict.parse("Seq").unwrap() ).chain(
+                std::iter::once(
+                    if let Some(sr) = seq_repr {
+                        TypeTerm::Ladder(vec![
+                            dict.parse("Seq").unwrap(),
+                            sr.desugar(dict)
+                        ])
+                    } else {
+                        dict.parse("Seq").unwrap()
+                    }
+                ).chain(
                     items.into_iter().map(|t| t.desugar(dict))
                 ).collect()),
         }