diff --git a/src/morphism_sugared.rs b/src/morphism_sugared.rs
index 4d6a521..55e531c 100644
--- a/src/morphism_sugared.rs
+++ b/src/morphism_sugared.rs
@@ -15,7 +15,7 @@ pub struct SugaredMorphismType {
 
 impl SugaredMorphismType {
     pub fn strip_halo(&self) -> SugaredMorphismType {
-        match (&self.src_type, &self.dst_type) {
+        match (&self.src_type.clone().strip(), &self.dst_type.clone().strip()) {
             (SugaredTypeTerm::Ladder(rungs_lhs), SugaredTypeTerm::Ladder(rungs_rhs)) => {
 
                 let mut lhs_iter = rungs_lhs.iter();
@@ -63,7 +63,9 @@ impl SugaredMorphismType {
                 }
             }
 
-            (SugaredTypeTerm::Seq { seq_repr:seq_repr_lhs, items:items_lhs }, SugaredTypeTerm::Seq { seq_repr: seq_repr_rhs, items:items_rhs }) => {
+            (SugaredTypeTerm::Seq { seq_repr:seq_repr_lhs, items:items_lhs },
+                SugaredTypeTerm::Seq { seq_repr: seq_repr_rhs, items:items_rhs })
+            => {
                 let (rl, rr) = items_lhs.iter().zip(items_rhs.iter()).map(
                     |(al,ar)| SugaredMorphismType{ src_type: al.clone(), dst_type: ar.clone() }.strip_halo()
                 )
@@ -78,12 +80,15 @@ impl SugaredMorphismType {
                 }
             }
 
-            (SugaredTypeTerm::Struct { struct_repr:seq_repr_lhs, members:items_lhs }, SugaredTypeTerm::Struct { struct_repr: seq_repr_rhs, members:items_rhs }) => {
+            (SugaredTypeTerm::Struct { struct_repr:struct_repr_lhs, members:members_lhs },
+                SugaredTypeTerm::Struct { struct_repr: struct_repr_rhs, members:members_rhs })
+            => {
                 let mut rl = Vec::new();
                 let mut rr = Vec::new();
 
-                for ar in items_rhs.iter() {
-                    for al in items_lhs.iter() {
+                for ar in members_rhs.iter() {
+                    let mut found = false;
+                    for al in members_lhs.iter() {
                         if al.symbol == ar.symbol {
                             let x = SugaredMorphismType{ src_type: al.ty.clone(), dst_type: ar.ty.clone() }.strip_halo();
                             rl.push( SugaredStructMember{
@@ -94,24 +99,34 @@ impl SugaredMorphismType {
                                 symbol: ar.symbol.clone(),
                                 ty: x.dst_type
                             });
+                            found = true;
                             break;
                         }
                     }
+
+                    if !found {
+                        return SugaredMorphismType {
+                            src_type: SugaredTypeTerm::Struct { struct_repr: struct_repr_lhs.clone(), members:members_lhs.clone() },
+                            dst_type: SugaredTypeTerm::Struct { struct_repr: struct_repr_rhs.clone(), members:members_rhs.clone() }
+                        };
+                    }
                 }
 
                 SugaredMorphismType  {
-                    src_type: SugaredTypeTerm::Struct{ struct_repr: seq_repr_lhs.clone(), members: rl },
-                    dst_type: SugaredTypeTerm::Struct{ struct_repr: seq_repr_rhs.clone(), members: rr }
+                    src_type: SugaredTypeTerm::Struct{ struct_repr: struct_repr_lhs.clone(), members: rl },
+                    dst_type: SugaredTypeTerm::Struct{ struct_repr: struct_repr_rhs.clone(), members: rr }
                 }
             }
 
-            (SugaredTypeTerm::Enum { enum_repr:seq_repr_lhs, variants:items_lhs }, SugaredTypeTerm::Enum { enum_repr: seq_repr_rhs, variants:items_rhs }) => {
-
+            (SugaredTypeTerm::Enum { enum_repr:enum_repr_lhs, variants:variants_lhs },
+                SugaredTypeTerm::Enum { enum_repr: enum_repr_rhs, variants:variants_rhs })
+            => {
                 let mut rl = Vec::new();
                 let mut rr = Vec::new();
 
-                for ar in items_rhs.iter() {
-                    for al in items_lhs.iter() {
+                for ar in variants_rhs.iter() {
+                    let mut found = false;
+                    for al in variants_lhs.iter() {
                         if al.symbol == ar.symbol {
                             let x = SugaredMorphismType{ src_type: al.ty.clone(), dst_type: ar.ty.clone() }.strip_halo();
                             rl.push( SugaredEnumVariant{
@@ -122,13 +137,22 @@ impl SugaredMorphismType {
                                 symbol: ar.symbol.clone(),
                                 ty: x.dst_type
                             });
+                            found = true;
+                            break;
                         }
                     }
+
+                    if !found {
+                        return SugaredMorphismType {
+                            src_type: SugaredTypeTerm::Enum { enum_repr: enum_repr_lhs.clone(), variants:variants_lhs.clone() },
+                            dst_type: SugaredTypeTerm::Enum { enum_repr: enum_repr_rhs.clone(), variants:variants_rhs.clone() }
+                        };
+                    }
                 }
 
                 SugaredMorphismType  {
-                    src_type: SugaredTypeTerm::Enum{ enum_repr: seq_repr_lhs.clone(), variants: rl },
-                    dst_type: SugaredTypeTerm::Enum { enum_repr: seq_repr_rhs.clone(), variants: rr }
+                    src_type: SugaredTypeTerm::Enum{ enum_repr: enum_repr_lhs.clone(), variants: rl },
+                    dst_type: SugaredTypeTerm::Enum { enum_repr: enum_repr_rhs.clone(), variants: rr }
                 }
             }
 
@@ -151,7 +175,7 @@ pub trait SugaredMorphism : Sized {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, PartialEq, Debug)]
 pub enum MorphismInstance2<M: SugaredMorphism + Clone> {
     Primitive{
         ψ: SugaredTypeTerm,