     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 let (.Match, remainder):
+        return (.Tagged([tag: result]), remainder)
+        
+    case let (.Tagged, remainder):
+        return (.Tagged([tag: result]), remainder)
         
     case (.Series, _):
         return (.Failure, remainder)

        case let .Sequence(first, second):
            return parseSequence(input, subs: [first, second])
            
        case let .Tag(name, sub):
            return parseName(input, name: name, sub: sub)
            
        case let .Deferred(deferred):
            return parseDeferred(input, deferred: deferred)

    case let (.Tagged(tailTagged), tailRemainder):
        return (.Tagged(headTagged + tailTagged), tailRemainder)
        
    case let (.Series, tailRemainder):
        return (.Failure, tailRemainder)
    }
}

func parseTag(input: Remainder, tag: String, sub: Parser) -> ResultWithRemainder {

    let (result, remainder) = sub.parse(input)
    
