     a: (InputPosition) -> (A, InputPosition)?,
     b: (InputPosition) -> (B, InputPosition)?,
     c: (InputPosition) -> (C, InputPosition)?,
-    d: (InputPosition) -> (D, InputPosition)?) -> ((A, B, C, D), InputPosition)?
+    d: (InputPosition) -> (D, InputPosition)?) -> (A, B, C, D, InputPosition)?
 {
     if let (a, afterA) = a(position) {
         if let (b, afterB) = b(afterA) {
             if let (c, afterC) = c(afterB) {
                 if let (d, afterD) = d(afterC) {
-                    return ((a, b, c, d), afterD)
+                    return (a, b, c, d, afterD)
                 }
             }
         }


        // "IF" lhs relop rhs "THEN" statement
        // "IF" lhs relop rhs statement
        if let ((IF, lhs, op, rhs, THEN, stmt), nextPos) =
            parse(pos, lit(T_IF), expression, relop, expression, optLit(T_THEN), statement)
        {
            return (.If(lhs, op, rhs, Box(stmt)), nextPos)
        }

        // "GOTO" expression
        if let ((GOTO, expr), nextPos) =
            parse(pos, oneOfLit(T_GOTO, T_GT), expression)
        {
            return (.Goto(expr), nextPos)
        }

        // "GOSUB" expression
        if let ((GOSUB, expr), nextPos) =
            parse(pos, oneOfLit(T_GOSUB, T_GS), expression)
        {
            return (.Gosub(expr), nextPos)

        }

        // "+" number
        if let (PLUS, num, nextPos) = parse(pos, lit(T_Plus), numberLiteral) {
            return (num, nextPos)
        }

        // "-" number
        if let (MINUS, num, nextPos) = parse(pos, lit(T_Minus), numberLiteral) {
            return (-num, nextPos)
        }

