ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/lean4/src/lean/Lean/Data/Lsp/Utf16.lean

full_name: Char.utf16Size
code: def utf16Size (c : Char) : UInt32 
goal: UInt32

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.Lsp.Utf16.0.String.csize16
code: private def csize16 (c : Char) : Nat 
goal: Nat

full_name: String.utf16Length
code: def utf16Length (s : String) : Nat 
goal: Nat

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.Lsp.Utf16.0.String.codepointPosToUtf16PosFromAux
code: private def codepointPosToUtf16PosFromAux (s : String) : Nat → Pos → Nat → Nat
  
goal: Nat → String.Pos → Nat → Nat

full_name: String.codepointPosToUtf16PosFrom
code: /-- Computes the UTF-16 offset of the `n`-th Unicode codepoint
in the substring of `s` starting at UTF-8 offset `off`.
Yes, this is actually useful.-/
def codepointPosToUtf16PosFrom (s : String) (n : Nat) (off : Pos) : Nat 
goal: Nat

full_name: String.codepointPosToUtf16Pos
code: def codepointPosToUtf16Pos (s : String) (pos : Nat) : Nat 
goal: Nat

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.Lsp.Utf16.0.String.utf16PosToCodepointPosFromAux
code: private partial def utf16PosToCodepointPosFromAux (s : String) : Nat → Pos → Nat → Nat
  
goal: Nat → String.Pos → Nat → Nat

full_name: String.utf16PosToCodepointPosFrom
code: /-- Computes the position of the Unicode codepoint at UTF-16 offset
`utf16pos` in the substring of `s` starting at UTF-8 offset `off`. -/
def utf16PosToCodepointPosFrom (s : String) (utf16pos : Nat) (off : Pos) : Nat 
goal: Nat

full_name: String.utf16PosToCodepointPos
code: def utf16PosToCodepointPos (s : String) (pos : Nat) : Nat 
goal: Nat

full_name: String.codepointPosToUtf8PosFrom
code: /-- Starting at `utf8pos`, finds the UTF-8 offset of the `p`-th codepoint. -/
def codepointPosToUtf8PosFrom (s : String) : String.Pos → Nat → String.Pos
  
goal: String.Pos → Nat → String.Pos

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.Lsp.Utf16.0.Lean.FileMap.lineStartPos
code: private def lineStartPos (text : FileMap) (line : Nat) : String.Pos 
goal: String.Pos

full_name: Lean.FileMap.lspPosToUtf8Pos
code: /-- Computes an UTF-8 offset into `text.source`
from an LSP-style 0-indexed (ln, col) position. -/
def lspPosToUtf8Pos (text : FileMap) (pos : Lsp.Position) : String.Pos 
goal: String.Pos

full_name: Lean.FileMap.leanPosToLspPos
code: def leanPosToLspPos (text : FileMap) : Lean.Position → Lsp.Position
  
goal: Lean.Position → Lean.Lsp.Position

full_name: Lean.FileMap.utf8PosToLspPos
code: def utf8PosToLspPos (text : FileMap) (pos : String.Pos) : Lsp.Position 
goal: Lean.Lsp.Position

full_name: Lean.FileMap.utf8RangeToLspRange
code: /-- Gets the LSP range from a `String.Range`. -/
def utf8RangeToLspRange (text : FileMap) (range : String.Range) : Lsp.Range 
goal: Lean.Lsp.Range

full_name: Lean.DeclarationRange.toLspRange
code: /--
Convert the Lean `DeclarationRange` to an LSP `Range` by turning the 1-indexed line numbering into a
0-indexed line numbering and converting the character offset within the line to a UTF-16 indexed
offset.
-/
def Lean.DeclarationRange.toLspRange (r : Lean.DeclarationRange) : Lsp.Range 
goal: Lean.Lsp.Range
File: .lake/packages/lean4/src/lean/Lean/Data/Lsp/Window.lean

full_name: MessageType.error
code: inductive MessageType where
  | error
  | warning
  | info
  | log
goal: MessageType

full_name: MessageType.warning
code: inductive MessageType where
  | error
  | warning
  | info
  | log
goal: MessageType

full_name: MessageType.log
code: inductive MessageType where
  | error
  | warning
  | info
  | log
goal: MessageType

full_name: MessageType.info
code: inductive MessageType where
  | error
  | warning
  | info
  | log
goal: MessageType

full_name: MessageType
code: inductive MessageType where
  | error
  | warning
  | info
  | log
goal: Type

full_name: instFromJsonMessageType
code: instance : FromJson MessageType 
goal: Lean.FromJson MessageType

full_name: instToJsonMessageType
code: instance : ToJson MessageType 
goal: Lean.ToJson MessageType

full_name: ShowMessageParams.type
code: structure ShowMessageParams where
  type    : MessageType
  message : String
  deriving FromJson, ToJson
goal: MessageType

full_name: ShowMessageParams
code: structure ShowMessageParams where
  type    : MessageType
  message : String
  deriving FromJson, ToJson
goal: Type

full_name: ShowMessageParams.message
code: structure ShowMessageParams where
  type    : MessageType
  message : String
  deriving FromJson, ToJson
goal: String

full_name: instFromJsonShowMessageParams
code: FromJson
goal: Lean.FromJson ShowMessageParams

full_name: instToJsonShowMessageParams
code: ToJson
goal: Lean.ToJson ShowMessageParams

full_name: MessageActionItem.title
code: structure MessageActionItem where
  title : String
  deriving FromJson, ToJson
goal: String

full_name: MessageActionItem
code: structure MessageActionItem where
  title : String
  deriving FromJson, ToJson
goal: Type

full_name: instFromJsonMessageActionItem
code: FromJson
goal: Lean.FromJson MessageActionItem

full_name: instToJsonMessageActionItem
code: ToJson
goal: Lean.ToJson MessageActionItem

full_name: ShowMessageRequestParams.actions?
code: structure ShowMessageRequestParams where
  type     : MessageType
  message  : String
  actions? : Option (Array MessageActionItem)
  deriving FromJson, ToJson
goal: Option (Array MessageActionItem)

full_name: ShowMessageRequestParams.message
code: structure ShowMessageRequestParams where
  type     : MessageType
  message  : String
  actions? : Option (Array MessageActionItem)
  deriving FromJson, ToJson
goal: String

full_name: ShowMessageRequestParams
code: structure ShowMessageRequestParams where
  type     : MessageType
  message  : String
  actions? : Option (Array MessageActionItem)
  deriving FromJson, ToJson
goal: Type

full_name: ShowMessageRequestParams.type
code: structure ShowMessageRequestParams where
  type     : MessageType
  message  : String
  actions? : Option (Array MessageActionItem)
  deriving FromJson, ToJson
goal: MessageType

full_name: instFromJsonShowMessageRequestParams
code: FromJson
goal: Lean.FromJson ShowMessageRequestParams

full_name: instToJsonShowMessageRequestParams
code: ToJson
goal: Lean.ToJson ShowMessageRequestParams

full_name: ShowMessageResponse
code: def ShowMessageResponse 
goal: Type
File: .lake/packages/lean4/src/lean/Lean/Data/Lsp/Ipc.lean

full_name: Lean.Lsp.Ipc.ipcStdioConfig
code: def ipcStdioConfig : Process.StdioConfig 
goal: IO.Process.StdioConfig

full_name: Lean.Lsp.Ipc.IpcM
code: abbrev IpcM 
goal: Type

full_name: Lean.Lsp.Ipc.stdin
code: def stdin : IpcM FS.Stream 
goal: Lean.Lsp.Ipc.IpcM IO.FS.Stream

full_name: Lean.Lsp.Ipc.stdout
code: def stdout : IpcM FS.Stream 
goal: Lean.Lsp.Ipc.IpcM IO.FS.Stream

full_name: Lean.Lsp.Ipc.writeRequest
code: def writeRequest (r : Request α) : IpcM Unit 
goal: Lean.Lsp.Ipc.IpcM Unit

full_name: Lean.Lsp.Ipc.writeNotification
code: def writeNotification (n : Notification α) : IpcM Unit 
goal: Lean.Lsp.Ipc.IpcM Unit

full_name: Lean.Lsp.Ipc.shutdown
code: def shutdown (requestNo : Nat) : IpcM Unit 
goal: Lean.Lsp.Ipc.IpcM Unit

full_name: Lean.Lsp.Ipc.readMessage
code: def readMessage : IpcM JsonRpc.Message 
goal: Lean.Lsp.Ipc.IpcM Lean.JsonRpc.Message

full_name: Lean.Lsp.Ipc.readRequestAs
code: def readRequestAs (expectedMethod : String) (α) [FromJson α] : IpcM (Request α) 
goal: Lean.Lsp.Ipc.IpcM (Lean.JsonRpc.Request α)

full_name: Lean.Lsp.Ipc.readResponseAs
code: /--
Reads response, discarding notifications and server-to-client requests in between.
This function is meant purely for testing where we use `collectDiagnostics` explicitly
if we do care about such notifications.
-/
partial def readResponseAs (expectedID : RequestID) (α) [FromJson α] :
    IpcM (Response α) 
goal: Lean.Lsp.Ipc.IpcM (Lean.JsonRpc.Response α)

full_name: Lean.Lsp.Ipc.waitForExit
code: def waitForExit : IpcM UInt32 
goal: Lean.Lsp.Ipc.IpcM UInt32

full_name: Lean.Lsp.Ipc.collectDiagnostics
code: /--
Waits for the worker to emit all diagnostic notifications for the current document version and
returns the last notification, if any.

We used to return all notifications but with debouncing in the server, this would not be
deterministic anymore as what messages are dropped depends on wall-clock timing.
 -/
partial def collectDiagnostics (waitForDiagnosticsId : RequestID := 0) (target : DocumentUri) (version : Nat)
: IpcM (Option (Notification PublishDiagnosticsParams)) 
goal: Lean.Lsp.Ipc.IpcM (Option (Lean.JsonRpc.Notification Lean.Lsp.PublishDiagnosticsParams))

full_name: Lean.Lsp.Ipc.collectDiagnostics.loop
code: /--
Waits for the worker to emit all diagnostic notifications for the current document version and
returns the last notification, if any.

We used to return all notifications but with debouncing in the server, this would not be
deterministic anymore as what messages are dropped depends on wall-clock timing.
 -/
partial def collectDiagnostics (waitForDiagnosticsId : RequestID := 0) (target : DocumentUri) (version : Nat)
: IpcM (Option (Notification PublishDiagnosticsParams)) 
goal: Lean.Lsp.Ipc.IpcM (Option (Lean.JsonRpc.Notification Lean.Lsp.PublishDiagnosticsParams))

full_name: Lean.Lsp.Ipc.runWith
code: def runWith (lean : System.FilePath) (args : Array String := #[]) (test : IpcM α) : IO α 
goal: IO α
File: .lake/packages/lean4/src/lean/Lean/Data/Lsp/Client.lean

full_name: Lean.Lsp.Registration.id
code: structure Registration where
  id : String
  method : String
  registerOptions : Option Json
  deriving ToJson, FromJson
goal: String

full_name: Lean.Lsp.Registration
code: structure Registration where
  id : String
  method : String
  registerOptions : Option Json
  deriving ToJson, FromJson
goal: Type

full_name: Lean.Lsp.Registration.registerOptions
code: structure Registration where
  id : String
  method : String
  registerOptions : Option Json
  deriving ToJson, FromJson
goal: Option Lean.Json

full_name: Lean.Lsp.Registration.method
code: structure Registration where
  id : String
  method : String
  registerOptions : Option Json
  deriving ToJson, FromJson
goal: String

full_name: Lean.Lsp.instToJsonRegistration
code: ToJson
goal: Lean.ToJson Lean.Lsp.Registration

full_name: Lean.Lsp.instFromJsonRegistration
code: FromJson
goal: Lean.FromJson Lean.Lsp.Registration

full_name: Lean.Lsp.RegistrationParams.registrations
code: structure RegistrationParams where
  registrations : Array Registration
  deriving ToJson, FromJson
goal: Array Lean.Lsp.Registration

full_name: Lean.Lsp.RegistrationParams
code: structure RegistrationParams where
  registrations : Array Registration
  deriving ToJson, FromJson
goal: Type

full_name: Lean.Lsp.instToJsonRegistrationParams
code: ToJson
goal: Lean.ToJson Lean.Lsp.RegistrationParams

full_name: Lean.Lsp.instFromJsonRegistrationParams
code: FromJson
goal: Lean.FromJson Lean.Lsp.RegistrationParams
File: .lake/packages/lean4/src/lean/Lean/ParserCompiler.lean

full_name: Lean.ParserCompiler.Context.varName
code: structure Context (α : Type) where
  varName : Name
  categoryAttr : KeyedDeclsAttribute α
  combinatorAttr : CombinatorAttribute
goal: Lean.Name

full_name: Lean.ParserCompiler.Context.categoryAttr
code: structure Context (α : Type) where
  varName : Name
  categoryAttr : KeyedDeclsAttribute α
  combinatorAttr : CombinatorAttribute
goal: Lean.KeyedDeclsAttribute α

full_name: Lean.ParserCompiler.Context
code: structure Context (α : Type) where
  varName : Name
  categoryAttr : KeyedDeclsAttribute α
  combinatorAttr : CombinatorAttribute
goal: Type

full_name: Lean.ParserCompiler.Context.combinatorAttr
code: structure Context (α : Type) where
  varName : Name
  categoryAttr : KeyedDeclsAttribute α
  combinatorAttr : CombinatorAttribute
goal: Lean.ParserCompiler.CombinatorAttribute

full_name: Lean.ParserCompiler.Context.tyName
code: def Context.tyName {α} (ctx : Context α) : Name 
goal: Lean.Name

full_name: Lean.ParserCompiler.replaceParserTy
code: /-- Replace all references of `Parser` with `tyName` -/
def replaceParserTy {α} (ctx : Context α) (e : Expr) : Expr 
goal: Lean.Expr

full_name: Lean.ParserCompiler.parserNodeKind?
code: /-- Takes an expression of type `Parser`, and determines the syntax kind of the root node it produces. -/
partial def parserNodeKind? (e : Expr) : MetaM (Option Name) 
goal: Lean.MetaM (Option Lean.Name)

full_name: Lean.ParserCompiler.compileParserExpr
code: /--
  Translate an expression of type `Parser` into one of type `tyName`, tagging intermediary constants with
  `ctx.combinatorAttr`. If `force` is `false`, refuse to do so for imported constants. -/
partial def compileParserExpr (e : Expr) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: Lean.ParserCompiler.compileEmbeddedParsers
code: def compileEmbeddedParsers : ParserDescr → MetaM Unit
  
goal: Lean.ParserDescr → Lean.MetaM Unit

full_name: Lean.ParserCompiler.registerParserCompiler
code: /-- Precondition: `α` must match `ctx.tyName`. -/
unsafe def registerParserCompiler {α} (ctx : Context α) : IO Unit 
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Data/Json/Stream.lean

full_name: IO.FS.Stream.readJson
code: /-- Consumes `nBytes` bytes from the stream, interprets the bytes as a utf-8 string and the string as a valid JSON object. -/
def readJson (h : FS.Stream) (nBytes : Nat) : IO Json 
goal: IO Lean.Json

full_name: IO.FS.Stream.writeJson
code: def writeJson (h : FS.Stream) (j : Json) : IO Unit 
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Data/Format.lean

full_name: Std.Format.getWidth
code: def getWidth (o : Options) : Nat    
goal: Nat

full_name: Std.Format.getIndent
code: def getIndent (o : Options) : Nat   
goal: Nat

full_name: Std.Format.getUnicode
code: def getUnicode (o : Options) : Bool 
goal: Bool

full_name: Std.Format.initFn._@..lake.packages.lean4.src.lean.Lean.Data.Format._hyg.30
code: register_builtin_option format.width : Nat := {
  defValue := defWidth
  descr := "indentation"
}
goal: IO (Lean.Option Nat)

full_name: Std.Format.format.width
code: register_builtin_option format.width : Nat := {
  defValue := defWidth
  descr := "indentation"
}
goal: Lean.Option Nat

full_name: Std.Format.format.unicode
code: register_builtin_option format.unicode : Bool := {
  defValue := defUnicode
  descr    := "unicode characters"
}
goal: Lean.Option Bool

full_name: Std.Format.initFn._@..lake.packages.lean4.src.lean.Lean.Data.Format._hyg.71
code: register_builtin_option format.unicode : Bool := {
  defValue := defUnicode
  descr    := "unicode characters"
}
goal: IO (Lean.Option Bool)

full_name: Std.Format.format.indent
code: register_builtin_option format.indent : Nat := {
  defValue := defIndent
  descr    := "indentation"
}
goal: Lean.Option Nat

full_name: Std.Format.initFn._@..lake.packages.lean4.src.lean.Lean.Data.Format._hyg.112
code: register_builtin_option format.indent : Nat := {
  defValue := defIndent
  descr    := "indentation"
}
goal: IO (Lean.Option Nat)

full_name: Std.Format.pretty'
code: def pretty' (f : Format) (o : Options := {}) : String 
goal: String

full_name: Lean.«instToFormatName_.lake»
code: instance : ToFormat Name 
goal: Lean.ToFormat Lean.Name

full_name: Lean.«instToFormatDataValue_.lake»
code: instance : ToFormat DataValue 
goal: Lean.ToFormat Lean.DataValue

full_name: Lean.«instToFormatProdNameDataValue_.lake»
code: instance : ToFormat (Name × DataValue) 
goal: Lean.ToFormat (Lean.Name × Lean.DataValue)

full_name: Lean.formatKVMap
code: def formatKVMap (m : KVMap) : Format 
goal: Lean.Format

full_name: Lean.«instToFormatKVMap_.lake»
code: instance : ToFormat KVMap 
goal: Lean.ToFormat Lean.KVMap
File: .lake/packages/lean4/src/lean/Lean/Data/Json/Parser.lean

full_name: Lean.Json.Parser.hexChar
code: @[inline]
def hexChar : Parsec Nat 
goal: Lean.Parsec Nat

full_name: Lean.Json.Parser.escapedChar
code: def escapedChar : Parsec Char 
goal: Lean.Parsec Char

full_name: Lean.Json.Parser.strCore
code: partial def strCore (acc : String) : Parsec String 
goal: Lean.Parsec String

full_name: Lean.Json.Parser.str
code: def str : Parsec String 
goal: Lean.Parsec String

full_name: Lean.Json.Parser.natCore
code: partial def natCore (acc digits : Nat) : Parsec (Nat × Nat) 
goal: Lean.Parsec (Nat × Nat)

full_name: Lean.Json.Parser.lookahead
code: @[inline]
def lookahead (p : Char → Prop) (desc : String) [DecidablePred p] : Parsec Unit 
goal: Lean.Parsec Unit

full_name: Lean.Json.Parser.natNonZero
code: @[inline]
def natNonZero : Parsec Nat 
goal: Lean.Parsec Nat

full_name: Lean.Json.Parser.natNumDigits
code: @[inline]
def natNumDigits : Parsec (Nat × Nat) 
goal: Lean.Parsec (Nat × Nat)

full_name: Lean.Json.Parser.natMaybeZero
code: @[inline]
def natMaybeZero : Parsec Nat 
goal: Lean.Parsec Nat

full_name: Lean.Json.Parser.num
code: def num : Parsec JsonNumber 
goal: Lean.Parsec Lean.JsonNumber

full_name: Lean.Json.Parser.arrayCore
code: partial def arrayCore (anyCore : Parsec Json) (acc : Array Json) : Parsec (Array Json) 
goal: Lean.Parsec (Array Lean.Json)

full_name: Lean.Json.Parser.objectCore
code: partial def objectCore (anyCore : Parsec Json) : Parsec (RBNode String (fun _ => Json)) 
goal: Lean.Parsec (Lean.RBNode String fun x => Lean.Json)

full_name: Lean.Json.Parser.anyCore
code: partial def anyCore : Parsec Json 
goal: Lean.Parsec Lean.Json

full_name: Lean.Json.Parser.any
code: def any : Parsec Json 
goal: Lean.Parsec Lean.Json

full_name: Lean.Json.parse
code: def parse (s : String) : Except String Lean.Json 
goal: Except String Lean.Json
File: .lake/packages/lean4/src/lean/Lean/Data/Json/Printer.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.Json.Printer.0.Lean.Json.escapeAux
code: private def escapeAux (acc : String) (c : Char) : String 
goal: String

full_name: Lean.Json.escape
code: def escape (s : String) : String 
goal: String

full_name: Lean.Json.renderString
code: def renderString (s : String) : String 
goal: String

full_name: Lean.Json.render
code: partial def render : Json → Format
  
goal: Lean.Json → Lean.Format

full_name: Lean.Json.pretty
code: def pretty (j : Json) (lineWidth := 80) : String 
goal: String

full_name: Lean.Json.CompressWorkItem.arrayEnd
code: protected inductive CompressWorkItem
  | json (j : Json)
  | arrayElem (j : Json)
  | arrayEnd
  | objectField (k : String) (j : Json)
  | objectEnd
  | comma
goal: Lean.Json.CompressWorkItem

full_name: Lean.Json.CompressWorkItem
code: protected inductive CompressWorkItem
  | json (j : Json)
  | arrayElem (j : Json)
  | arrayEnd
  | objectField (k : String) (j : Json)
  | objectEnd
  | comma
goal: Type

full_name: Lean.Json.CompressWorkItem.arrayElem
code: protected inductive CompressWorkItem
  | json (j : Json)
  | arrayElem (j : Json)
  | arrayEnd
  | objectField (k : String) (j : Json)
  | objectEnd
  | comma
goal: Lean.Json.CompressWorkItem

full_name: Lean.Json.CompressWorkItem.json
code: protected inductive CompressWorkItem
  | json (j : Json)
  | arrayElem (j : Json)
  | arrayEnd
  | objectField (k : String) (j : Json)
  | objectEnd
  | comma
goal: Lean.Json.CompressWorkItem

full_name: Lean.Json.CompressWorkItem.objectField
code: protected inductive CompressWorkItem
  | json (j : Json)
  | arrayElem (j : Json)
  | arrayEnd
  | objectField (k : String) (j : Json)
  | objectEnd
  | comma
goal: Lean.Json.CompressWorkItem

full_name: Lean.Json.CompressWorkItem.objectEnd
code: protected inductive CompressWorkItem
  | json (j : Json)
  | arrayElem (j : Json)
  | arrayEnd
  | objectField (k : String) (j : Json)
  | objectEnd
  | comma
goal: Lean.Json.CompressWorkItem

full_name: Lean.Json.CompressWorkItem.comma
code: protected inductive CompressWorkItem
  | json (j : Json)
  | arrayElem (j : Json)
  | arrayEnd
  | objectField (k : String) (j : Json)
  | objectEnd
  | comma
goal: Lean.Json.CompressWorkItem

full_name: Lean.Json.compress
code: partial def compress (j : Json) : String 
goal: String

full_name: Lean.Json.compress.go
code: partial def compress (j : Json) : String 
goal: List Lean.Json.CompressWorkItem → String

full_name: Lean.Json.«instToFormat_.lake»
code: instance : ToFormat Json 
goal: Lean.ToFormat Lean.Json

full_name: Lean.Json.«instToString_.lake»
code: instance : ToString Json 
goal: ToString Lean.Json
File: .lake/packages/lean4/src/lean/Lean/Data/SSet.lean

full_name: Lean.SSet
code: /-- Staged set. It is just a simple wrapper on top of Staged maps. -/
def SSet (α : Type u) [BEq α] [Hashable α] 
goal: Type u

full_name: Lean.SSet.instInhabited
code: instance : Inhabited (SSet α) 
goal: Inhabited (Lean.SSet α)

full_name: Lean.SSet.empty
code: abbrev empty : SSet α 
goal: Lean.SSet α

full_name: Lean.SSet.insert
code: abbrev insert (s : SSet α) (a : α) : SSet α 
goal: Lean.SSet α

full_name: Lean.SSet.contains
code: abbrev contains (s : SSet α) (a : α) : Bool 
goal: Bool

full_name: Lean.SSet.forM
code: abbrev forM [Monad m] (s : SSet α) (f : α → m PUnit) : m PUnit 
goal: m PUnit

full_name: Lean.SSet.switch
code: /-- Move from stage 1 into stage 2. -/
abbrev switch (s : SSet α) : SSet α 
goal: Lean.SSet α

full_name: Lean.SSet.fold
code: abbrev fold (f : σ → α → σ) (init : σ) (s : SSet α) : σ 
goal: σ

full_name: Lean.SSet.toList
code: def toList (m : SSet α) : List α 
goal: List α

full_name: List.toSSet
code: def List.toSSet [BEq α] [Hashable α] (es : List α) : Lean.SSet α 
goal: Lean.SSet α

full_name: instReprSSet
code: instance {_ : BEq α} {_ : Hashable α} [Repr α] : Repr (Lean.SSet α) 
goal: {x : BEq α} → {x_1 : Hashable α} → [inst : Repr α] → Repr (Lean.SSet α)
File: .lake/packages/lean4/src/lean/Lean/Data/NameTrie.lean

full_name: Lean.NamePart
code: inductive NamePart
  | str (s : String)
  | num (n : Nat)
goal: Type

full_name: Lean.NamePart.num
code: inductive NamePart
  | str (s : String)
  | num (n : Nat)
goal: Lean.NamePart

full_name: Lean.NamePart.str
code: inductive NamePart
  | str (s : String)
  | num (n : Nat)
goal: Lean.NamePart

full_name: Lean.instToStringNamePart
code: instance : ToString NamePart 
goal: ToString Lean.NamePart

full_name: Lean.NamePart.cmp
code: def NamePart.cmp : NamePart → NamePart → Ordering
  
goal: Lean.NamePart → Lean.NamePart → Ordering

full_name: Lean.NamePart.lt
code: def NamePart.lt : NamePart → NamePart → Bool
  
goal: Lean.NamePart → Lean.NamePart → Bool

full_name: Lean.NameTrie
code: def NameTrie (β : Type u) 
goal: Type u

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.NameTrie.0.Lean.toKey.loop
code: private def toKey (n : Name) : List NamePart 
goal: Lean.Name → List Lean.NamePart → List Lean.NamePart

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.NameTrie.0.Lean.toKey
code: private def toKey (n : Name) : List NamePart 
goal: List Lean.NamePart

full_name: Lean.NameTrie.insert
code: def NameTrie.insert (t : NameTrie β) (n : Name) (b : β) : NameTrie β 
goal: Lean.NameTrie β

full_name: Lean.NameTrie.empty
code: def NameTrie.empty : NameTrie β 
goal: Lean.NameTrie β

full_name: Lean.instInhabitedNameTrie
code: instance : Inhabited (NameTrie β) 
goal: Inhabited (Lean.NameTrie β)

full_name: Lean.instEmptyCollectionNameTrie
code: instance : EmptyCollection (NameTrie β) 
goal: EmptyCollection (Lean.NameTrie β)

full_name: Lean.NameTrie.find?
code: def NameTrie.find? (t : NameTrie β) (k : Name) : Option β 
goal: Option β

full_name: Lean.NameTrie.foldMatchingM
code: @[inline]
def NameTrie.foldMatchingM [Monad m] (t : NameTrie β) (k : Name) (init : σ) (f : β → σ → m σ) : m σ 
goal: m σ

full_name: Lean.NameTrie.foldM
code: @[inline]
def NameTrie.foldM [Monad m] (t : NameTrie β) (init : σ) (f : β → σ → m σ) : m σ 
goal: m σ

full_name: Lean.NameTrie.forMatchingM
code: @[inline]
def NameTrie.forMatchingM [Monad m] (t : NameTrie β) (k : Name) (f : β → m Unit) : m Unit 
goal: m Unit

full_name: Lean.NameTrie.forM
code: @[inline]
def NameTrie.forM [Monad m] (t : NameTrie β) (f : β → m Unit) : m Unit 
goal: m Unit

full_name: Lean.NameTrie.matchingToArray
code: def NameTrie.matchingToArray (t : NameTrie β) (k : Name) : Array β 
goal: Array β

full_name: Lean.NameTrie.toArray
code: def NameTrie.toArray (t : NameTrie β) : Array β 
goal: Array β