src/morphism_path_sugared.rs

@@ -54,7 +54,10 @@ impl<'a, M:SugaredMorphism+Clone> SugaredShortestPathProblem<'a, M> {
         let mut creates_loop = false;
 
         let mut new_path = prev_path.clone();
-        new_path.apply_subst(&morph_inst.get_subst());
+        for n in new_path.morphisms.iter_mut() {
+            n.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,13 +135,6 @@ 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,29 +247,11 @@ impl SugaredTypeTerm {
                     members.into_iter().map(|t| t.desugar(dict))
                 ).collect()),
             SugaredTypeTerm::Enum{ enum_repr, variants } => TypeTerm::App(
-                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(
+                std::iter::once( dict.parse("Enum").unwrap() ).chain(
                     variants.into_iter().map(|t| t.desugar(dict))
                 ).collect()),
             SugaredTypeTerm::Seq{ seq_repr, items } => TypeTerm::App(
-                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(
+                std::iter::once( dict.parse("Seq").unwrap() ).chain(
                     items.into_iter().map(|t| t.desugar(dict))
                 ).collect()),
         }