     func combine(secondary: Result) -> Result {
         
         switch (self, secondary) {
+            
         case let (.Match(match: selfText, index: selfIndex), .Match(match: secondaryText, index: _)):
             return .Match(match: selfText + secondaryText, index: selfIndex)
+
         case (.Match, .Tagged):
             return secondary
+        
         case (.Tagged, .Match):
             return self
+        
         case let (.Tagged(selfTagged), .Tagged(secondaryTagged)):
             return .Tagged(selfTagged + secondaryTagged)
+        
         default:
             return .Failure
         }

        return lhsMatch == rhsMatch && lhsIndex == rhsIndex
    
    case let (.Tagged(lhsTagged), .Tagged(rhsTagged)):
        return taggedEqual(lhsTagged, rhsTagged: rhsTagged)
        
    default:
        return false
    }
}

func taggedEqual(lhsTagged: [String: Result], rhsTagged: [String: Result]) -> Bool {
    
    if lhsTagged.count != rhsTagged.count {
        return false

    return true
}

func seriesEqual(lhsSeries: [Result], _ rhsSeries: [Result]) -> Bool {
    if lhsSeries.count != rhsSeries.count {
        return false
    }
