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

        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

    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
        }
