File: .lake/packages/lean4/src/lean/lake/Lake/Toml/ParserUtil.lean

full_name: Lake.Toml.isBinDigit
code: def isBinDigit (c : Char) : Bool 
goal: Bool

full_name: Lake.Toml.isOctDigit
code: def isOctDigit (c : Char) : Bool 
goal: Bool

full_name: Lake.Toml.isHexDigit
code: def isHexDigit (c : Char) : Bool 
goal: Bool

full_name: Lake.Toml.skipFn
code: def skipFn : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.«instAndThenParserFn_.lake»
code: scoped instance : AndThen ParserFn 
goal: AndThen Lean.Parser.ParserFn

full_name: Lake.Toml.usePosFn
code: /-- `ParserFn` combinator that runs `f` with the current position. -/
@[always_inline, inline] def usePosFn (f : String.Pos → ParserFn) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.optFn
code: /-- Match an arbitrary parser or do nothing. -/
def optFn (p : ParserFn) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.repeatFn.loop
code: /-- A sequence of `n` repetitions of a parser function. -/
@[inline] def repeatFn (n : Nat) (p : ParserFn) : ParserFn 
goal: Nat → Lean.Parser.ParserState → Lean.Parser.ParserState

full_name: Lake.Toml.repeatFn
code: /-- A sequence of `n` repetitions of a parser function. -/
@[inline] def repeatFn (n : Nat) (p : ParserFn) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.mkUnexpectedCharError
code: def mkUnexpectedCharError (s : ParserState) (c : Char)  (expected : List String := []) (pushMissing := true) : ParserState 
goal: Lean.Parser.ParserState

full_name: Lake.Toml.satisfyFn
code: @[inline] def satisfyFn (p : Char → Bool) (expected : List String := [])  : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.takeWhile1Fn
code: def takeWhile1Fn (p : Char → Bool) (expected : List String := []) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.digitFn
code: /-- Consume a single digit (i.e., `Char.isDigit`). -/
def digitFn (expected : List String := ["digit"]) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.digitPairFn
code: /-- Consume a two digits (i.e., `Char.isDigit`). -/
def digitPairFn (expected := ["digit"]) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.chFn
code: /-- Consume a single matching character. -/
def chFn (c : Char) (expected : List String := [s!"'{c}'"]) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.strAuxFn
code: partial def strAuxFn (str : String) (expected : List String) (strPos : String.Pos) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.strFn
code: /-- Consume a matching string atomically. -/
def strFn (str : String) (expected : List String := [s!"'{str}'"]) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.pushAtom
code: /-- Push a new atom onto the syntax stack. -/
def pushAtom (startPos : String.Pos) (trailingFn := skipFn) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.atomFn
code: /-- Match an arbitrary `ParserFn` and return the consumed String in a `Syntax.atom`. -/
def atomFn (p : ParserFn) (trailingFn := skipFn) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.atom
code: def atom (p : ParserFn) (trailingFn := skipFn) : Parser 
goal: Lean.Parser.Parser

full_name: Lake.Toml.getInfoExprPos?
code: def getInfoExprPos? : SourceInfo → Option String.Pos
  
goal: Lean.SourceInfo → Option String.Pos

full_name: Lake.Toml.getSyntaxExprPos?
code: def getSyntaxExprPos? : Syntax → Option String.Pos
  
goal: Lean.Syntax → Option String.Pos

full_name: Lake.Toml.atom.formatter
code: @[combinator_formatter atom] def atom.formatter (_ _ : ParserFn) : Formatter 
goal: Lean.Parser.ParserFn → Lean.Parser.ParserFn → Lean.PrettyPrinter.Formatter

full_name: Lake.Toml.atom.parenthesizer
code: @[combinator_parenthesizer atom]
def atom.parenthesizer (_  _ : ParserFn) : Parenthesizer 
goal: Lean.Parser.ParserFn → Lean.Parser.ParserFn → Lean.PrettyPrinter.Parenthesizer

full_name: Lake.Toml.chAtom
code: /-- Parse a single character as an atom. -/
def chAtom (c : Char) (expected := [s!"'{c}'"]) (trailingFn := skipFn) : Parser 
goal: Lean.Parser.Parser

full_name: Lake.Toml.chAtom.formatter
code: @[combinator_formatter chAtom]
def chAtom.formatter (c : Char) (_ : List String) (_ : ParserFn) : Formatter 
goal: List String → Lean.Parser.ParserFn → Lean.PrettyPrinter.Formatter

full_name: Lake.Toml.chAtom.parenthesizer
code: @[combinator_parenthesizer chAtom]
def chAtom.parenthesizer (_ : Char) (_  : List String) (_ : ParserFn) : Parenthesizer 
goal: Char → List String → Lean.Parser.ParserFn → Lean.PrettyPrinter.Parenthesizer

full_name: Lake.Toml.strAtom
code: /-- Parse the trimmed string as an atom (but use the full string for formatting). -/
def strAtom (s : String) (expected := [s!"'{s}'"]) (trailingFn := skipFn) : Parser 
goal: Lean.Parser.Parser

full_name: Lake.Toml.strAtom.formatter
code: @[combinator_formatter strAtom]
def strAtom.formatter (s : String) (_ : List String) (_ : ParserFn) : Formatter 
goal: List String → Lean.Parser.ParserFn → Lean.PrettyPrinter.Formatter

full_name: Lake.Toml.strAtom.parenthesizer
code: @[combinator_parenthesizer strAtom]
def strAtom.parenthesizer (_ : String) (_  : List String) (_ : ParserFn) : Parenthesizer 
goal: String → List String → Lean.Parser.ParserFn → Lean.PrettyPrinter.Parenthesizer

full_name: Lake.Toml.pushLit
code: /-- Push `(Syntax.node kind <new-atom>)` onto the syntax stack. -/
def pushLit (kind : SyntaxNodeKind) (startPos : String.Pos) (trailingFn := skipFn) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.litFn
code: def litFn (kind : SyntaxNodeKind) (p : ParserFn) (trailingFn := skipFn) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.lit
code: def lit (kind : SyntaxNodeKind) (p : ParserFn) (trailingFn := skipFn) : Parser 
goal: Lean.Parser.Parser

full_name: Lake.Toml.lit.formatter
code: @[combinator_formatter lit]
def lit.formatter (kind : SyntaxNodeKind) (_ _ : ParserFn) : Formatter 
goal: Lean.Parser.ParserFn → Lean.Parser.ParserFn → Lean.PrettyPrinter.Formatter

full_name: Lake.Toml.lit.parenthesizer
code: @[combinator_parenthesizer lit]
def lit.parenthesizer (_ : SyntaxNodeKind) (_ _ : ParserFn) : Parenthesizer 
goal: Lean.SyntaxNodeKind → Lean.Parser.ParserFn → Lean.Parser.ParserFn → Lean.PrettyPrinter.Parenthesizer

full_name: Lake.Toml.litWithAntiquot
code: def litWithAntiquot (name : String) (kind : SyntaxNodeKind) (p : ParserFn) (trailingFn := skipFn) (anonymous := false) : Parser 
goal: Lean.Parser.Parser

full_name: Lake.Toml.epsilon
code: @[inline] def epsilon (fn : ParserFn) : Parser 
goal: Lean.Parser.Parser

full_name: Lake.Toml.epsilon.formatter
code: @[combinator_formatter epsilon]
def epsilon.formatter (_ : ParserFn) : Formatter 
goal: Lean.Parser.ParserFn → Lean.PrettyPrinter.Formatter

full_name: Lake.Toml.epsilon.parenthesizer
code: @[combinator_parenthesizer epsilon]
def epsilon.parenthesizer (_ : ParserFn) : Parenthesizer 
goal: Lean.Parser.ParserFn → Lean.PrettyPrinter.Parenthesizer

full_name: Lake.Toml.SourceInfo.updateTrailing
code: def SourceInfo.updateTrailing (trailing : Substring) : SourceInfo → SourceInfo
  
goal: Lean.SourceInfo → Lean.SourceInfo

full_name: Lake.Toml.modifyTailInfo
code: partial def modifyTailInfo (f : SourceInfo → SourceInfo) : (stx : Syntax) → Syntax
  
goal: Lean.Syntax

full_name: Lake.Toml.extendTrailingFn
code: def extendTrailingFn (p : ParserFn) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.trailing
code: def trailing (p : ParserFn) : Parser 
goal: Lean.Parser.Parser

full_name: Lake.Toml.dynamicNode
code: def dynamicNode (p : ParserFn) : Parser 
goal: Lean.Parser.Parser

full_name: Lake.Toml.dynamicNode.formatter
code: @[combinator_formatter dynamicNode]
def dynamicNode.formatter (_ : ParserFn) : Formatter 
goal: Lean.Parser.ParserFn → Lean.PrettyPrinter.Formatter

full_name: Lake.Toml.dynamicNode.parenthesizer
code: @[combinator_parenthesizer dynamicNode]
def dynamicNode.parenthesizer (_ : ParserFn) : Parenthesizer 
goal: Lean.Parser.ParserFn → Lean.PrettyPrinter.Parenthesizer

full_name: Lake.Toml.recNodeFn
code: partial def recNodeFn (f : Parser → Parser) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.ParserMapFn
code: /--
`Parser → Parser` hidden by an `abbrev`.
Prevents the formatter/parenthesizer generator from transforming it.
-/
abbrev ParserMapFn 
goal: Type

full_name: Lake.Toml.recNode
code: def recNode (f : ParserMapFn) : Parser 
goal: Lean.Parser.Parser

full_name: Lake.Toml.recNodeWithAntiquot.go
code: def recNodeWithAntiquot (name : String) (kind : SyntaxNodeKind) (f : ParserMapFn) (anonymous := false) : Parser 
goal: Lean.Parser.Parser

full_name: Lake.Toml.recNodeWithAntiquot
code: def recNodeWithAntiquot (name : String) (kind : SyntaxNodeKind) (f : ParserMapFn) (anonymous := false) : Parser 
goal: Lean.Parser.Parser

full_name: Lake.Toml.sepByLinebreak
code: @[inline] def sepByLinebreak (p : Parser) (allowTrailingLinebreak := true) : Parser 
goal: Lean.Parser.Parser

full_name: Lake.Toml.sepBy1Linebreak
code: @[inline] def sepBy1Linebreak (p : Parser) (allowTrailingLinebreak := true) : Parser 
goal: Lean.Parser.Parser

full_name: Lake.Toml.skipInsideQuotFn
code: def skipInsideQuotFn (p : ParserFn) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lake.Toml.skipInsideQuot
code: @[run_parser_attribute_hooks] def skipInsideQuot (p : Parser) : Parser 
goal: Lean.Parser.Parser