lol indexed parser
diff --git a/src/Init/Lean/Parser/Level.lean b/src/Init/Lean/Parser/Level.lean
index 3c5ccd4..bf95f92 100644
--- a/src/Init/Lean/Parser/Level.lean
+++ b/src/Init/Lean/Parser/Level.lean
@@ -17,7 +17,7 @@
 
 namespace Level
 
-@[builtinLevelParser] def paren  := parser! symbol "(" appPrec >> levelParser >> ")"
+@[builtinLevelParser] def paren  := parser! symbol "(" appPrec >> levelParser >> symbolAux ")"
 @[builtinLevelParser] def max    := parser! nonReservedSymbol "max " true  >> many1 (levelParser appPrec)
 @[builtinLevelParser] def imax   := parser! nonReservedSymbol "imax " true >> many1 (levelParser appPrec)
 @[builtinLevelParser] def hole   := parser! symbol "_" appPrec
diff --git a/src/Init/Lean/Parser/Parser.lean b/src/Init/Lean/Parser/Parser.lean
index 5b1511e..5ac9d61 100644
--- a/src/Init/Lean/Parser/Parser.lean
+++ b/src/Init/Lean/Parser/Parser.lean
@@ -262,11 +262,15 @@
 (collectKinds  : SyntaxNodeKindSet → SyntaxNodeKindSet := id)
 (firstTokens   : FirstTokens                           := FirstTokens.unknown)
 
-structure Parser :=
+structure BasicParser :=
 (info : ParserInfo := {})
 (fn   : ParserFn)
 
-instance Parser.inhabited : Inhabited Parser :=
+structure Parser (arity : Nat := 1) extends BasicParser
+
+variable {a : Nat}
+
+instance Parser.inhabited : Inhabited (Parser a) :=
 ⟨{ fn := fun _ s => s }⟩
 
 abbrev TrailingParser := Parser
@@ -279,7 +283,7 @@
   if p s.stxStack.back then s
   else s.mkUnexpectedError "invalid leading token"
 
-@[inline] def checkStackTop (p : Syntax → Bool) : Parser :=
+@[inline] def checkStackTop (p : Syntax → Bool) : Parser 0 :=
 { info := epsilonInfo,
   fn   := checkStackTopFn p }
 
@@ -293,12 +297,14 @@
   collectKinds  := p.collectKinds ∘ q.collectKinds,
   firstTokens   := p.firstTokens.seq q.firstTokens }
 
-@[inline] def andthen (p q : Parser) : Parser :=
+@[inline] def andthenCore (p : BasicParser) (q : BasicParser) : BasicParser :=
 { info := andthenInfo p.info q.info,
   fn   := andthenFn p.fn q.fn }
 
-instance hasAndthen : HasAndthen Parser :=
-⟨andthen⟩
+@[inline] def andthen {a₁ a₂ : Nat} (p : Parser a₁) (q : Parser a₂) : Parser (a₁ + a₂) :=
+{ .. andthenCore p.toBasicParser q.toBasicParser }
+
+infixr >> := andthen
 
 @[inline] def nodeFn (n : SyntaxNodeKind) (p : ParserFn) : ParserFn
 | c, s =>
@@ -317,18 +323,18 @@
   collectKinds  := fun s => (p.collectKinds s).insert n,
   firstTokens   := p.firstTokens }
 
-@[inline] def node (n : SyntaxNodeKind) (p : Parser) : Parser :=
+@[inline] def node (n : SyntaxNodeKind) (p : Parser a) : Parser :=
 { info := nodeInfo n p.info,
   fn   := nodeFn n p.fn }
 
-@[inline] def leadingNode (n : SyntaxNodeKind) (p : Parser) : Parser :=
+@[inline] def leadingNode (n : SyntaxNodeKind) (p : Parser a) : Parser :=
 node n p
 
-@[inline] def trailingNode (n : SyntaxNodeKind) (p : Parser) : TrailingParser :=
+@[inline] def trailingNode (n : SyntaxNodeKind) (p : Parser a) : TrailingParser :=
 { info := nodeInfo n p.info,
   fn   := trailingNodeFn n p.fn }
 
-@[inline] def group (p : Parser) : Parser :=
+@[inline] def group (p : Parser a) : Parser :=
 node nullKind p
 
 def mergeOrElseErrors (s : ParserState) (error1 : Error) (iniPos : Nat) : ParserState :=
@@ -356,11 +362,11 @@
   collectKinds  := p.collectKinds ∘ q.collectKinds,
   firstTokens   := p.firstTokens.merge q.firstTokens }
 
-@[inline] def orelse (p q : Parser) : Parser :=
+@[inline] def orelse (p q : Parser a) : Parser a :=
 { info := orelseInfo p.info q.info,
   fn   := orelseFn p.fn q.fn }
 
-instance hashOrelse : HasOrelse Parser :=
+instance hashOrelse : HasOrelse (Parser a) :=
 ⟨orelse⟩
 
 @[noinline] def noFirstTokenInfo (info : ParserInfo) : ParserInfo :=
@@ -375,7 +381,7 @@
   | ⟨stack, _, cache, some msg⟩ => ⟨stack.shrink iniSz, iniPos, cache, some msg⟩
   | other                       => other
 
-@[inline] def try (p : Parser) : Parser :=
+@[inline] def try (p : Parser a) : Parser a :=
 { info := p.info,
   fn   := tryFn p.fn }
 
@@ -392,7 +398,7 @@
   collectKinds  := p.collectKinds,
   firstTokens   := p.firstTokens.toOptional }
 
-@[inline] def optional (p : Parser) : Parser :=
+@[inline] def optional (p : Parser a) : Parser :=
 { info := optionaInfo p.info,
   fn   := optionalFn p.fn }
 
@@ -981,7 +987,7 @@
   let prev := s.stxStack.back;
   if checkTailWs prev then s else s.mkError errorMsg
 
-def checkWsBefore (errorMsg : String) : Parser :=
+def checkWsBefore (errorMsg : String) : Parser 0 :=
 { info := epsilonInfo,
   fn   := checkWsBeforeFn errorMsg }
 
@@ -1000,7 +1006,7 @@
   let prev := pickNonNone s.stxStack;
   if checkTailNoWs prev then s else s.mkError errorMsg
 
-def checkNoWsBefore (errorMsg : String) : Parser :=
+def checkNoWsBefore (errorMsg : String) : Parser 0 :=
 { info := epsilonInfo,
   fn   := checkNoWsBeforeFn errorMsg }
 
@@ -1059,7 +1065,7 @@
   if c.rbp > lower then s.mkUnexpectedError errorMsg
   else s
 
-def checkRBPGreater (lower : Nat) (errorMsg : String) : Parser :=
+def checkRBPGreater (lower : Nat) (errorMsg : String) : Parser 0 :=
 { info := epsilonInfo,
   fn   := checkRBPGreaterFn lower errorMsg }
 
@@ -1261,7 +1267,7 @@
   if pos.column ≥ col then s
   else s.mkError errorMsg
 
-@[inline] def checkColGe (col : Nat) (errorMsg : String) : Parser :=
+@[inline] def checkColGe (col : Nat) (errorMsg : String) : Parser 0 :=
 { fn := checkColGeFn col errorMsg }
 
 @[inline] def withPosition (p : Position → Parser) : Parser :=
@@ -1271,7 +1277,7 @@
    (p pos).fn c s }
 
 @[inline] def many1Indent (p : Parser) (errorMsg : String) : Parser :=
-withPosition $ fun pos => many1 (checkColGe pos.column errorMsg >> p)
+withPosition $ fun pos => many1 (andthen (checkColGe pos.column errorMsg) p)
 
 /-- A multimap indexed by tokens. Used for indexing parsers by their leading token. -/
 def TokenMap (α : Type) := RBMap Name (List α) Name.quickLt
@@ -1396,7 +1402,7 @@
 def dollarSymbol : Parser := symbol "$" 1
 
 /-- Fail if previous token is immediately followed by ':'. -/
-private def noImmediateColon : Parser :=
+private def noImmediateColon : Parser 0 :=
 { fn := fun c s =>
   let prev := s.stxStack.back;
   if checkTailNoWs prev then
@@ -1423,7 +1429,7 @@
 { fn := fun c s => s.pushSyntax mkNullNode }
 
 -- We support two kinds of antiquotations: `$id` and `$(t)`, where `id` is a term identifier and `t` is a term.
-private def antiquotNestedExpr : Parser := node `antiquotNestedExpr ("(" >> termParser >> ")")
+private def antiquotNestedExpr : Parser := node `antiquotNestedExpr (symbolAux "(" >> termParser >> symbolAux ")")
 private def antiquotExpr : Parser       := identNoAntiquot <|> antiquotNestedExpr
 
 /--
@@ -1441,10 +1447,10 @@
 -- antiquotations are not part of the "standard" syntax, so hide "expected '$'" on error
 node kind $ try $
   setExpected [] dollarSymbol >>
-  many (checkNoWsBefore "" >> dollarSymbol) >>
+  many (andthen (checkNoWsBefore "") dollarSymbol) >>
   checkNoWsBefore "no space before spliced term" >> antiquotExpr >>
   nameP >>
-  optional (checkNoWsBefore "" >> "*")
+  optional (checkNoWsBefore "" >> symbolAux "*")
 
 def tryAnti (c : ParserContext) (s : ParserState) : Bool :=
 let (s, stx?) := peekToken c s;
@@ -1713,7 +1719,7 @@
   | _ => unreachable!
 
 def compileParserDescr (categories : ParserCategories) : ParserDescr → Except String (Parser)
-| ParserDescr.andthen d₁ d₂                       => andthen <$> compileParserDescr d₁ <*> compileParserDescr d₂
+| ParserDescr.andthen d₁ d₂                       => (fun (p q : Parser) => { .. andthen p q }) <$> compileParserDescr d₁ <*> compileParserDescr d₂
 | ParserDescr.orelse d₁ d₂                        => orelse <$> compileParserDescr d₁ <*> compileParserDescr d₂
 | ParserDescr.optional d                          => optional <$> compileParserDescr d
 | ParserDescr.lookahead d                         => lookahead <$> compileParserDescr d
diff --git a/src/Init/Lean/Parser/Term.lean b/src/Init/Lean/Parser/Term.lean
index 3e0f559..199f60e 100644
--- a/src/Init/Lean/Parser/Term.lean
+++ b/src/Init/Lean/Parser/Term.lean
@@ -29,16 +29,16 @@
 
 /- Helper functions for defining simple parsers -/
 
-def unicodeInfixR (sym : String) (asciiSym : String) (lbp : Nat) : TrailingParser :=
+def unicodeInfixR (sym : String) (asciiSym : String) (lbp : Nat) : Parser 2 :=
 unicodeSymbol sym asciiSym lbp >> termParser (lbp - 1)
 
-def infixR (sym : String) (lbp : Nat) : TrailingParser :=
+def infixR (sym : String) (lbp : Nat) : Parser 2 :=
 symbol sym lbp >> termParser (lbp - 1)
 
-def unicodeInfixL (sym : String) (asciiSym : String) (lbp : Nat) : TrailingParser :=
+def unicodeInfixL (sym : String) (asciiSym : String) (lbp : Nat) : Parser 2 :=
 unicodeSymbol sym asciiSym lbp >> termParser lbp
 
-def infixL (sym : String) (lbp : Nat) : TrailingParser :=
+def infixL (sym : String) (lbp : Nat) : Parser 2 :=
 symbol sym lbp >> termParser lbp
 
 def leadPrec := appPrec - 1
@@ -46,8 +46,8 @@
 /- Built-in parsers -/
 -- NOTE: `checkNoWsBefore` should be used *before* `parser!` so that it is also applied to the generated
 -- antiquotation.
-def explicitUniv := checkNoWsBefore "no space before '.{'" >> parser! ".{" >> sepBy1 levelParser ", " >> "}"
-def namedPattern := checkNoWsBefore "no space before '@'" >> parser! "@" >> termParser appPrec
+def explicitUniv := checkNoWsBefore "no space before '.{'" >> parser! symbolAux ".{" >> sepBy1 levelParser ", " >> symbolAux "}"
+def namedPattern := checkNoWsBefore "no space before '@'" >> parser! symbolAux "@" >> termParser appPrec
 @[builtinTermParser] def id := parser! ident >> optional (explicitUniv <|> namedPattern)
 @[builtinTermParser] def num : Parser := parser! numLit
 @[builtinTermParser] def str : Parser := parser! strLit
@@ -60,16 +60,16 @@
 @[builtinTermParser] def «sorry» := parser! symbol "sorry" appPrec
 @[builtinTermParser] def cdot   := parser! symbol "·" appPrec
 @[builtinTermParser] def emptyC := parser! symbol "∅" appPrec
-def typeAscription := parser! " : " >> termParser
-def tupleTail      := parser! ", " >> sepBy1 termParser ", "
+def typeAscription := parser! symbolAux " : " >> termParser
+def tupleTail      := parser! symbolAux ", " >> sepBy1 termParser ", "
 def parenSpecial : Parser := optional (tupleTail <|> typeAscription)
-@[builtinTermParser] def paren := parser! symbol "(" appPrec >> optional (termParser >> parenSpecial) >> ")"
-@[builtinTermParser] def anonymousCtor := parser! symbol "⟨" appPrec >> sepBy termParser ", " >> "⟩"
-def optIdent : Parser := optional (try (ident >> " : "))
-@[builtinTermParser] def «if»  := parser! symbol "if " leadPrec >> optIdent >> termParser >> " then " >> termParser >> " else " >> termParser
-def fromTerm   := parser! " from " >> termParser
-def haveAssign := parser! " := " >> termParser
-@[builtinTermParser] def «have» := parser! symbol "have " leadPrec >> optIdent >> termParser >> (haveAssign <|> fromTerm) >> "; " >> termParser
+@[builtinTermParser] def paren := parser! symbol "(" appPrec >> optional (termParser >> parenSpecial) >> symbolAux ")"
+@[builtinTermParser] def anonymousCtor := parser! symbol "⟨" appPrec >> sepBy termParser ", " >> symbolAux "⟩"
+def optIdent : Parser := optional (try (ident >> symbolAux " : "))
+@[builtinTermParser] def «if»  := parser! symbol "if " leadPrec >> optIdent >> termParser >> symbolAux " then " >> termParser >> symbolAux " else " >> termParser
+def fromTerm   := parser! symbolAux " from " >> termParser
+def haveAssign := parser! symbolAux " := " >> termParser
+@[builtinTermParser] def «have» := parser! symbol "have " leadPrec >> optIdent >> termParser >> (haveAssign <|> fromTerm) >> symbolAux "; " >> termParser
 @[builtinTermParser] def «suffices» := parser! symbol "suffices " leadPrec >> optIdent >> termParser >> fromTerm >> "; " >> termParser
 @[builtinTermParser] def «show»     := parser! symbol "show " leadPrec >> termParser >> fromTerm
 def structInstArrayRef := parser! "[" >> termParser >>"]"