         return (.Failure, input)
         
     case let (.Match(match: headText, index: headIndex), headRemainder):
-        let (tailResult, tailRemainder) = parseSequence(headRemainder, subs: tail)
-        return combineSequenceMatch(headText, headIndex: headIndex, tailResult: tailResult, tailRemainder: tailRemainder)
+        let parsedTail = parseSequence(headRemainder, subs: tail)
+        return combineSequenceMatch(headText, headIndex: headIndex, parsedTail: parsedTail)
         
     case let (.Tagged(headTagged), headRemainder):
-        let (tailResult, tailRemainder) = parseSequence(headRemainder, subs: tail)
-        return combineSequenceTagged(headTagged, tailResult: tailResult, tailRemainder: tailRemainder)
+        let parsedTail = parseSequence(headRemainder, subs: tail)
+        return combineSequenceTagged(headTagged, parsedTail: parsedTail)
         
     case (.Series, _):
         return (.Failure, input)
     }
 }
 
-func combineSequenceMatch(headText: String, headIndex: Int, tailResult: Result, tailRemainder: Remainder) -> ResultWithRemainder {
-    
-    switch (tailResult, tailRemainder) {
-        
-    case (.Failure, _):
+func combineSequenceMatch(headText: String, headIndex: Int, parsedTail: ResultWithRemainder) -> ResultWithRemainder {
+    
+    switch parsedTail {
+        
+    case let (.Failure, tailRemainder):
         return (.Failure, tailRemainder)
         
     case let (.Match(match: tailMatch, index: tailIndex), tailRemainder):

    case (.Failure, _):
        return (.Failure, remainder)

    case let (.Match(match: _, index: _), remainder):
        return (.Tagged([name: result]), remainder)
        
    case let (.Tagged(_), remainder):
        return (.Tagged([name: result]), remainder)
        
    case (.Series, _):
        return (.Failure, remainder)

        return (.Match(match: headText + tailMatch, index: headIndex), tailRemainder)
        
    case (.Tagged, _):
        return parsedTail
        
    case let (.Series, tailRemainder):
        return (.Failure, tailRemainder)
    }
}

func combineSequenceTagged(headTagged: [String: Result], parsedTail: ResultWithRemainder) -> ResultWithRemainder {

    switch parsedTail {
        
    case let (.Failure, tailRemainder):
        return (.Failure, tailRemainder)
        
    case let (.Match(match: _, index: _), tailRemainder):
