diff --git a/src/morphism_path_sugared.rs b/src/morphism_path_sugared.rs
index c2b6cf7..d6a6841 100644
--- a/src/morphism_path_sugared.rs
+++ b/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;
diff --git a/src/morphism_sugared.rs b/src/morphism_sugared.rs
index 0f63191..f9c36eb 100644
--- a/src/morphism_sugared.rs
+++ b/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 {
diff --git a/src/sugar.rs b/src/sugar.rs
index eef8dee..de9c864 100644
--- a/src/sugar.rs
+++ b/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()),
         }