File: .lake/packages/lean4/src/lean/Lean/Parser/Do.lean

full_name: Lean.Parser.initFn._@..lake.packages.lean4.src.lean.Lean.Parser.Do._hyg.5
code: builtin_initialize registerBuiltinParserAttribute `builtin_doElem_parser ``Category.doElem
goal: IO Unit

full_name: Lean.Parser.initFn._@..lake.packages.lean4.src.lean.Lean.Parser.Do._hyg.55
code: builtin_initialize registerBuiltinDynamicParserAttribute `doElem_parser `doElem
goal: IO Unit

full_name: Lean.Parser.doElemParser
code: @[inline] def doElemParser (rbp : Nat := 0) : Parser 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.leftArrow
code: def leftArrow : Parser 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.liftMethod
code: @[builtin_term_parser] def liftMethod 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doSeqItem
code: def doSeqItem      
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doSeqIndent
code: def doSeqIndent    
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doSeqBracketed
code: def doSeqBracketed 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doSeq
code: /-- A `doSeq` is a sequence of `doElem`, the main argument after the `do` keyword and other
do elements that take blocks. It can either have the form `"{" (doElem ";"?)* "}"` or
`many1Indent (doElem ";"?)`, where `many1Indent` ensures that all the items are at
the same or higher indentation level as the first line. -/
def doSeq          
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.termBeforeDo
code: /-- `termBeforeDo` is defined as `withForbidden("do", term)`, which will parse a term but
disallows `do` outside of a bracketing construct. This is used for parsers like `for _ in t do ...`
or `unless t do ...`, where we do not want `t do ...` to be parsed as an application of `t` to a
`do` block, which would otherwise be allowed. -/
def termBeforeDo 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.initFn._@..lake.packages.lean4.src.lean.Lean.Parser.Do._hyg.253
code: builtin_initialize
  register_parser_alias doSeq
  register_parser_alias termBeforeDo
goal: IO Unit

full_name: Lean.Parser.Term.notFollowedByRedefinedTermToken
code: def notFollowedByRedefinedTermToken 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doLet
code: @[builtin_doElem_parser] def doLet      
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doLetElse
code: @[builtin_doElem_parser] def doLetElse  
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doLetExpr
code: @[builtin_doElem_parser] def doLetExpr  
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doLetMetaExpr
code: @[builtin_doElem_parser] def doLetMetaExpr  
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doLetRec
code: @[builtin_doElem_parser] def doLetRec   
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doIdDecl
code: def doIdDecl   
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doPatDecl
code: def doPatDecl  
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doLetArrow
code: @[builtin_doElem_parser] def doLetArrow      
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.letIdDeclNoBinders
code: def letIdDeclNoBinders 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doReassign
code: @[builtin_doElem_parser] def doReassign      
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doReassignArrow
code: @[builtin_doElem_parser] def doReassignArrow 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doHave
code: @[builtin_doElem_parser] def doHave     
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.elseIf
code: def elseIf 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doIfLetPure
code: def doIfLetPure 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doIfLetBind
code: def doIfLetBind 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doIfLet
code: def doIfLet     
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doIfProp
code: def doIfProp    
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doIfCond
code: def doIfCond    
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doIf
code: @[builtin_doElem_parser] def doIf 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doUnless
code: @[builtin_doElem_parser] def doUnless 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doForDecl
code: def doForDecl 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doFor
code: /--
`for x in e do s`  iterates over `e` assuming `e`'s type has an instance of the `ForIn` typeclass.
`break` and `continue` are supported inside `for` loops.
`for x in e, x2 in e2, ... do s` iterates of the given collections in parallel,
until at least one of them is exhausted.
The types of `e2` etc. must implement the `ToStream` typeclass.
-/
@[builtin_doElem_parser] def doFor    
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doMatchAlts
code: def doMatchAlts 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doMatch
code: @[builtin_doElem_parser] def doMatch 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doMatchExprAlts
code: def doMatchExprAlts 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.optMetaFalse
code: def optMetaFalse 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doMatchExpr
code: @[builtin_doElem_parser] def doMatchExpr 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doCatch
code: def doCatch      
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doCatchMatch
code: def doCatchMatch 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doFinally
code: def doFinally    
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doTry
code: @[builtin_doElem_parser] def doTry    
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doBreak
code: /-- `break` exits the surrounding `for` loop. -/
@[builtin_doElem_parser] def doBreak     
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doContinue
code: /-- `continue` skips to the next iteration of the surrounding `for` loop. -/
@[builtin_doElem_parser] def doContinue  
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doReturn
code: /--
`return e` inside of a `do` block makes the surrounding block evaluate to `pure e`,
skipping any further statements.
Note that uses of the `do` keyword in other syntax like in `for _ in _ do`
do not constitute a surrounding block in this sense;
in supported editors, the corresponding `do` keyword of the surrounding block
is highlighted when hovering over `return`.

`return` not followed by a term starting on the same line is equivalent to `return ()`.
-/
@[builtin_doElem_parser] def doReturn    
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doDbgTrace
code: /--
`dbg_trace e` prints `e` (which can be an interpolated string literal) to stderr.
It should only be used for debugging.
-/
@[builtin_doElem_parser] def doDbgTrace  
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doAssert
code: /--
`assert! cond` panics if `cond` evaluates to `false`.
-/
@[builtin_doElem_parser] def doAssert    
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doExpr
code: @[builtin_doElem_parser] def doExpr   
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.doNested
code: @[builtin_doElem_parser] def doNested 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.do
code: @[builtin_term_parser] def «do»  
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.termUnless
code: /-- `unless e do s` is a nicer way to write `if !e do s`. -/
@[builtin_term_parser] def termUnless 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.termFor
code: @[builtin_term_parser] def termFor 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.termTry
code: @[builtin_term_parser] def termTry    
goal: Lean.Parser.Parser

full_name: Lean.Parser.Term.termReturn
code: /--
`return` used outside of `do` blocks creates an implicit block around it
and thus is equivalent to `pure e`, but helps with avoiding parentheses.
-/
@[builtin_term_parser] def termReturn 
goal: Lean.Parser.Parser