ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/lean4/src/lean/Lean/Util/CollectLevelParams.lean

full_name: Lean.CollectLevelParams.State.visitedExpr
code: structure State where
  visitedLevel : LevelSet   := {}
  visitedExpr  : ExprSet    := {}
  params       : Array Name := #[]
goal: Lean.ExprSet

full_name: Lean.CollectLevelParams.State.params
code: structure State where
  visitedLevel : LevelSet   := {}
  visitedExpr  : ExprSet    := {}
  params       : Array Name := #[]
goal: Array Lean.Name

full_name: Lean.CollectLevelParams.State
code: structure State where
  visitedLevel : LevelSet   := {}
  visitedExpr  : ExprSet    := {}
  params       : Array Name := #[]
goal: Type

full_name: Lean.CollectLevelParams.State.visitedLevel
code: structure State where
  visitedLevel : LevelSet   := {}
  visitedExpr  : ExprSet    := {}
  params       : Array Name := #[]
goal: Lean.LevelSet

full_name: Lean.CollectLevelParams.instInhabitedState
code: instance : Inhabited State 
goal: Inhabited Lean.CollectLevelParams.State

full_name: Lean.CollectLevelParams.Visitor
code: abbrev Visitor 
goal: Type

full_name: Lean.CollectLevelParams.visitLevels
code: def visitLevels (us : List Level) : Visitor 
goal: Lean.CollectLevelParams.Visitor

full_name: Lean.CollectLevelParams.State.getUnusedLevelParam
code: partial def State.getUnusedLevelParam (s : CollectLevelParams.State) (pre : Name := `v) : Level 
goal: Lean.Level

full_name: Lean.CollectLevelParams.State.getUnusedLevelParam.loop
code: partial def State.getUnusedLevelParam (s : CollectLevelParams.State) (pre : Name := `v) : Level 
goal: Lean.Level

full_name: Lean.collectLevelParams
code: def collectLevelParams (s : CollectLevelParams.State) (e : Expr) : CollectLevelParams.State 
goal: Lean.CollectLevelParams.State

full_name: Lean.CollectLevelParams.State.collect
code: def CollectLevelParams.State.collect (s : CollectLevelParams.State) (e : Expr) : CollectLevelParams.State 
goal: Lean.CollectLevelParams.State
File: .lake/packages/lean4/src/lean/Lean/Util/LakePath.lean

full_name: Lean.determineLakePath
code: def Lean.determineLakePath : IO System.FilePath 
goal: IO System.FilePath
File: .lake/packages/lean4/src/lean/Lean/Util/ReplaceExpr.lean

full_name: Lean.Expr.ReplaceImpl.Cache.size
code: structure Cache where
  size : USize
  -- First `size` elements are the keys.
  -- Second `size` elements are the results.
  keysResults : Array NonScalar
goal: USize

full_name: Lean.Expr.ReplaceImpl.Cache
code: structure Cache where
  size : USize
  -- First `size` elements are the keys.
  -- Second `size` elements are the results.
  keysResults : Array NonScalar
goal: Type

full_name: Lean.Expr.ReplaceImpl.Cache.keysResults
code: structure Cache where
  size : USize
  -- First `size` elements are the keys.
  -- Second `size` elements are the results.
  keysResults : Array NonScalar
goal: Array NonScalar

full_name: Lean.Expr.ReplaceImpl.Cache.new
code: unsafe def Cache.new (e : Expr) : Cache 
goal: Lean.Expr.ReplaceImpl.Cache

full_name: Lean.Expr.ReplaceImpl.Cache.keyIdx
code: @[inline]
unsafe def Cache.keyIdx (c : Cache) (key : Expr) : USize 
goal: USize

full_name: Lean.Expr.ReplaceImpl.Cache.resultIdx
code: @[inline]
unsafe def Cache.resultIdx (c : Cache) (key : Expr) : USize 
goal: USize

full_name: Lean.Expr.ReplaceImpl.Cache.hasResultFor
code: @[inline]
unsafe def Cache.hasResultFor (c : Cache) (key : Expr) : Bool 
goal: Bool

full_name: Lean.Expr.ReplaceImpl.Cache.getResultFor
code: @[inline]
unsafe def Cache.getResultFor (c : Cache) (key : Expr) : Expr 
goal: Lean.Expr

full_name: Lean.Expr.ReplaceImpl.Cache.store
code: unsafe def Cache.store (c : Cache) (key result : Expr) : Cache 
goal: Lean.Expr.ReplaceImpl.Cache

full_name: Lean.Expr.ReplaceImpl.ReplaceM
code: abbrev ReplaceM 
goal: Type

full_name: Lean.Expr.ReplaceImpl.cache
code: @[inline]
unsafe def cache (key : Expr) (result : Expr) : ReplaceM Expr 
goal: Lean.Expr.ReplaceImpl.ReplaceM Lean.Expr

full_name: Lean.Expr.ReplaceImpl.replaceUnsafeM.visit
code: @[specialize]
unsafe def replaceUnsafeM (f? : Expr → Option Expr) (e : Expr) : ReplaceM Expr 
goal: Lean.Expr.ReplaceImpl.ReplaceM Lean.Expr

full_name: Lean.Expr.ReplaceImpl.replaceUnsafeM
code: @[specialize]
unsafe def replaceUnsafeM (f? : Expr → Option Expr) (e : Expr) : ReplaceM Expr 
goal: Lean.Expr.ReplaceImpl.ReplaceM Lean.Expr

full_name: Lean.Expr.ReplaceImpl.replaceUnsafe
code: @[inline]
unsafe def replaceUnsafe (f? : Expr → Option Expr) (e : Expr) : Expr 
goal: Lean.Expr

full_name: Lean.Expr.replaceNoCache
code: @[specialize]
def replaceNoCache (f? : Expr → Option Expr) (e : Expr) : Expr 
goal: Lean.Expr

full_name: Lean.Expr.replace
code: @[implemented_by ReplaceImpl.replaceUnsafe]
partial def replace (f? : Expr → Option Expr) (e : Expr) : Expr 
goal: Lean.Expr
File: .lake/packages/lean4/src/lean/Lean/Util/FoldConsts.lean

full_name: Lean.Expr.FoldConstsImpl.cacheSize
code: abbrev cacheSize : USize 
goal: USize

full_name: Lean.Expr.FoldConstsImpl.State
code: structure State where
  visitedTerms  : Array Expr  -- Remark: cache based on pointer address. Our "unsafe" implementation relies on the fact that `()` is not a valid Expr
  visitedConsts : NameHashSet
goal: Type

full_name: Lean.Expr.FoldConstsImpl.State.visitedTerms
code: structure State where
  visitedTerms  : Array Expr  -- Remark: cache based on pointer address. Our "unsafe" implementation relies on the fact that `()` is not a valid Expr
  visitedConsts : NameHashSet
goal: Array Lean.Expr

full_name: Lean.Expr.FoldConstsImpl.State.visitedConsts
code: structure State where
  visitedTerms  : Array Expr  -- Remark: cache based on pointer address. Our "unsafe" implementation relies on the fact that `()` is not a valid Expr
  visitedConsts : NameHashSet
goal: Lean.NameHashSet

full_name: Lean.Expr.FoldConstsImpl.FoldM
code: abbrev FoldM 
goal: Type

full_name: Lean.Expr.FoldConstsImpl.visited
code: unsafe def visited (e : Expr) (size : USize) : FoldM Bool 
goal: Lean.Expr.FoldConstsImpl.FoldM Bool

full_name: Lean.Expr.FoldConstsImpl.fold.visit
code: unsafe def fold {α : Type} (f : Name → α → α) (size : USize) (e : Expr) (acc : α) : FoldM α 
goal: Lean.Expr.FoldConstsImpl.FoldM α

full_name: Lean.Expr.FoldConstsImpl.fold
code: unsafe def fold {α : Type} (f : Name → α → α) (size : USize) (e : Expr) (acc : α) : FoldM α 
goal: Lean.Expr.FoldConstsImpl.FoldM α

full_name: Lean.Expr.FoldConstsImpl.initCache
code: unsafe def initCache : State 
goal: Lean.Expr.FoldConstsImpl.State

full_name: Lean.Expr.FoldConstsImpl.foldUnsafe
code: @[inline] unsafe def foldUnsafe {α : Type} (e : Expr) (init : α) (f : Name → α → α) : α 
goal: α

full_name: Lean.Expr.foldConsts
code: /-- Apply `f` to every constant occurring in `e` once. -/
@[implemented_by FoldConstsImpl.foldUnsafe]
opaque foldConsts {α : Type} (e : Expr) (init : α) (f : Name → α → α) : α 
goal: α

full_name: Lean.Expr.getUsedConstants
code: def getUsedConstants (e : Expr) : Array Name 
goal: Array Lean.Name

full_name: Lean.Expr.getUsedConstantsAsSet
code: /-- Like `Expr.getUsedConstants`, but produce a `NameSet`. -/
def getUsedConstantsAsSet (e : Expr) : NameSet 
goal: Lean.NameSet

full_name: Lean.ConstantInfo.getUsedConstantsAsSet
code: /-- Return all names appearing in the type or value of a `ConstantInfo`. -/
def getUsedConstantsAsSet (c : ConstantInfo) : NameSet 
goal: Lean.NameSet

full_name: Lean.getMaxHeight
code: def getMaxHeight (env : Environment) (e : Expr) : UInt32 
goal: UInt32
File: .lake/packages/lean4/src/lean/Lean/Util/FileSetupInfo.lean

full_name: Lean.FileSetupInfo.paths
code: /--
Information shared between Lake and Lean when calling `lake setup-file`.
-/
structure Lean.FileSetupInfo where
  paths        : LeanPaths
  setupOptions : LeanOptions
  deriving FromJson, ToJson
goal: Lean.LeanPaths

full_name: Lean.FileSetupInfo
code: /--
Information shared between Lake and Lean when calling `lake setup-file`.
-/
structure Lean.FileSetupInfo where
  paths        : LeanPaths
  setupOptions : LeanOptions
  deriving FromJson, ToJson
goal: Type

full_name: Lean.FileSetupInfo.setupOptions
code: /--
Information shared between Lake and Lean when calling `lake setup-file`.
-/
structure Lean.FileSetupInfo where
  paths        : LeanPaths
  setupOptions : LeanOptions
  deriving FromJson, ToJson
goal: Lean.LeanOptions

full_name: Lean.instFromJsonFileSetupInfo
code: FromJson
goal: Lean.FromJson Lean.FileSetupInfo

full_name: Lean.instToJsonFileSetupInfo
code: ToJson
goal: Lean.ToJson Lean.FileSetupInfo
File: .lake/packages/lean4/src/lean/Lean/Data/OpenDecl.lean

full_name: Lean.OpenDecl
code: /-- Data for representing `open` commands -/
inductive OpenDecl where
  | simple   (ns : Name) (except : List Name)
  | explicit (id : Name) (declName : Name)
  deriving BEq
goal: Type

full_name: Lean.OpenDecl.simple
code: /-- Data for representing `open` commands -/
inductive OpenDecl where
  | simple   (ns : Name) (except : List Name)
  | explicit (id : Name) (declName : Name)
  deriving BEq
goal: Lean.OpenDecl

full_name: Lean.instBEqOpenDecl
code: /-- Data for representing `open` commands -/
inductive OpenDecl where
  | simple   (ns : Name) (except : List Name)
  | explicit (id : Name) (declName : Name)
  deriving BEq
goal: BEq Lean.OpenDecl

full_name: Lean.OpenDecl.explicit
code: /-- Data for representing `open` commands -/
inductive OpenDecl where
  | simple   (ns : Name) (except : List Name)
  | explicit (id : Name) (declName : Name)
  deriving BEq
goal: Lean.OpenDecl

full_name: Lean.OpenDecl.instInhabited
code: instance : Inhabited OpenDecl 
goal: Inhabited Lean.OpenDecl

full_name: Lean.OpenDecl.instToString
code: instance : ToString OpenDecl 
goal: ToString Lean.OpenDecl

full_name: Lean.rootNamespace
code: def rootNamespace 
goal: Lean.Name

full_name: Lean.removeRoot
code: def removeRoot (n : Name) : Name 
goal: Lean.Name
File: .lake/packages/lean4/src/lean/Lean/Data/LOption.lean

full_name: Lean.LOption.none
code: inductive LOption (α : Type u) where
  | none  : LOption α
  | some  : α → LOption α
  | undef : LOption α
  deriving Inhabited, BEq
goal: Lean.LOption α

full_name: Lean.LOption
code: inductive LOption (α : Type u) where
  | none  : LOption α
  | some  : α → LOption α
  | undef : LOption α
  deriving Inhabited, BEq
goal: Type u

full_name: Lean.LOption.undef
code: inductive LOption (α : Type u) where
  | none  : LOption α
  | some  : α → LOption α
  | undef : LOption α
  deriving Inhabited, BEq
goal: Lean.LOption α

full_name: Lean.instInhabitedLOption
code: inductive LOption (α : Type u) where
  | none  : LOption α
  | some  : α → LOption α
  | undef : LOption α
  deriving Inhabited, BEq
goal: {a : Type u_1} → Inhabited (Lean.LOption a)

full_name: Lean.LOption.some
code: inductive LOption (α : Type u) where
  | none  : LOption α
  | some  : α → LOption α
  | undef : LOption α
  deriving Inhabited, BEq
goal: α → Lean.LOption α

full_name: Lean.instBEqLOption
code: inductive LOption (α : Type u) where
  | none  : LOption α
  | some  : α → LOption α
  | undef : LOption α
  deriving Inhabited, BEq
goal: {α : Type u_1} → [inst : BEq α] → BEq (Lean.LOption α)

full_name: Lean.instToStringLOption
code: instance [ToString α] : ToString (LOption α) 
goal: ToString (Lean.LOption α)

full_name: Option.toLOption
code: def Option.toLOption {α : Type u} : Option α → Lean.LOption α
  
goal: Option α → Lean.LOption α

full_name: toLOptionM
code: @[inline] def toLOptionM {α} {m : Type → Type} [Monad m] (x : m (Option α)) : m (Lean.LOption α) 
goal: m (Lean.LOption α)
File: .lake/packages/lean4/src/lean/Lean/Data/Xml/Basic.lean

full_name: Lean.Xml.Attributes
code: def Attributes 
goal: Type

full_name: Lean.Xml.instToStringAttributes
code: instance : ToString Attributes 
goal: ToString Lean.Xml.Attributes

full_name: Lean.Xml.instInhabitedContent
code: Inhabited
goal: Inhabited Lean.Xml.Content

full_name: Lean.Xml.instToStringElement
code: instance : ToString Element 
goal: ToString Lean.Xml.Element

full_name: Lean.Xml.instToStringContent
code: instance : ToString Content 
goal: ToString Lean.Xml.Content
File: .lake/packages/lean4/src/lean/Lean/Data/Rat.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.Rat.0.Lean.Rat.mk
code: structure Rat where
  private mk ::
    num : Int
    den : Nat := 1
  deriving Inhabited, BEq, DecidableEq
goal: Lean.Rat

full_name: Lean.Rat
code: structure Rat where
  private mk ::
    num : Int
    den : Nat := 1
  deriving Inhabited, BEq, DecidableEq
goal: Type

full_name: Lean.Rat.num
code: structure Rat where
  private mk ::
    num : Int
    den : Nat := 1
  deriving Inhabited, BEq, DecidableEq
goal: Int

full_name: Lean.instBEqRat
code: structure Rat where
  private mk ::
    num : Int
    den : Nat := 1
  deriving Inhabited, BEq, DecidableEq
goal: BEq Lean.Rat

full_name: Lean.Rat.den
code: structure Rat where
  private mk ::
    num : Int
    den : Nat := 1
  deriving Inhabited, BEq, DecidableEq
goal: Nat

full_name: Lean.instInhabitedRat
code: structure Rat where
  private mk ::
    num : Int
    den : Nat := 1
  deriving Inhabited, BEq, DecidableEq
goal: Inhabited Lean.Rat

full_name: Lean.instToStringRat
code: instance : ToString Rat 
goal: ToString Lean.Rat

full_name: Lean.instReprRat
code: instance : Repr Rat 
goal: Repr Lean.Rat

full_name: Lean.Rat.normalize
code: @[inline] def Rat.normalize (a : Rat) : Rat 
goal: Lean.Rat

full_name: Lean.mkRat
code: def mkRat (num : Int) (den : Nat) : Rat 
goal: Lean.Rat

full_name: Lean.Rat.isInt
code: protected def isInt (a : Rat) : Bool 
goal: Bool

full_name: Lean.Rat.lt
code: protected def lt (a b : Rat) : Bool 
goal: Bool

full_name: Lean.Rat.mul
code: protected def mul (a b : Rat) : Rat 
goal: Lean.Rat

full_name: Lean.Rat.inv
code: protected def inv (a : Rat) : Rat 
goal: Lean.Rat

full_name: Lean.Rat.div
code: protected def div (a b : Rat) : Rat 
goal: Lean.Rat

full_name: Lean.Rat.add
code: protected def add (a b : Rat) : Rat 
goal: Lean.Rat

full_name: Lean.Rat.sub
code: protected def sub (a b : Rat) : Rat 
goal: Lean.Rat

full_name: Lean.Rat.neg
code: protected def neg (a : Rat) : Rat 
goal: Lean.Rat

full_name: Lean.Rat.floor
code: protected def floor (a : Rat) : Int 
goal: Int

full_name: Lean.Rat.ceil
code: protected def ceil (a : Rat) : Int 
goal: Int

full_name: Lean.Rat.instLT
code: instance : LT Rat 
goal: LT Lean.Rat

full_name: Lean.Rat.instDecidableLt
code: instance (a b : Rat) : Decidable (a < b) 
goal: Decidable (a < b)

full_name: Lean.Rat.instLE
code: instance : LE Rat 
goal: LE Lean.Rat

full_name: Lean.Rat.instDecidableLe
code: instance (a b : Rat) : Decidable (a ≤ b) 
goal: Decidable (a ≤ b)

full_name: Lean.Rat.instAdd
code: instance : Add Rat 
goal: Add Lean.Rat

full_name: Lean.Rat.instSub
code: instance : Sub Rat 
goal: Sub Lean.Rat

full_name: Lean.Rat.instNeg
code: instance : Neg Rat 
goal: Neg Lean.Rat

full_name: Lean.Rat.instMul
code: instance : Mul Rat 
goal: Mul Lean.Rat

full_name: Lean.Rat.instDiv
code: instance : Div Rat 
goal: Div Lean.Rat

full_name: Lean.Rat.instOfNat
code: instance : OfNat Rat n 
goal: OfNat Lean.Rat n

full_name: Lean.Rat.instCoeInt
code: instance : Coe Int Rat 
goal: Coe Int Lean.Rat
File: .lake/packages/lean4/src/lean/Lean/Data/LBool.lean

full_name: Lean.instInhabitedLBool
code: inductive LBool where
  | false
  | true
  | undef
  deriving Inhabited, BEq
goal: Inhabited Lean.LBool

full_name: Lean.LBool.false
code: inductive LBool where
  | false
  | true
  | undef
  deriving Inhabited, BEq
goal: Lean.LBool

full_name: Lean.LBool.true
code: inductive LBool where
  | false
  | true
  | undef
  deriving Inhabited, BEq
goal: Lean.LBool

full_name: Lean.LBool
code: inductive LBool where
  | false
  | true
  | undef
  deriving Inhabited, BEq
goal: Type

full_name: Lean.LBool.undef
code: inductive LBool where
  | false
  | true
  | undef
  deriving Inhabited, BEq
goal: Lean.LBool

full_name: Lean.instBEqLBool
code: BEq
goal: BEq Lean.LBool

full_name: Lean.LBool.neg
code: def neg : LBool → LBool
  
goal: Lean.LBool → Lean.LBool

full_name: Lean.LBool.and
code: def and : LBool → LBool → LBool
  
goal: Lean.LBool → Lean.LBool → Lean.LBool

full_name: Lean.LBool.toString
code: def toString : LBool → String
  
goal: Lean.LBool → String

full_name: Lean.LBool.instToString
code: instance : ToString LBool 
goal: ToString Lean.LBool

full_name: Bool.toLBool
code: def Bool.toLBool : Bool → Lean.LBool
  
goal: Bool → Lean.LBool

full_name: toLBoolM
code: @[inline] def toLBoolM {m : Type → Type} [Monad m] (x : m Bool) : m Lean.LBool 
goal: m Lean.LBool
File: .lake/packages/lean4/src/lean/Lean/Data/PersistentHashSet.lean

full_name: Lean.PersistentHashSet
code: structure PersistentHashSet (α : Type u) [BEq α] [Hashable α] where
  (set : PersistentHashMap α Unit)
goal: Type u

full_name: Lean.PersistentHashSet.set
code: structure PersistentHashSet (α : Type u) [BEq α] [Hashable α] where
  (set : PersistentHashMap α Unit)
goal: Lean.PersistentHashMap α Unit

full_name: Lean.PHashSet
code: abbrev PHashSet (α : Type u) [BEq α] [Hashable α] 
goal: Type u

full_name: Lean.PersistentHashSet.empty
code: @[inline] def empty [BEq α] [Hashable α] : PersistentHashSet α 
goal: Lean.PersistentHashSet α

full_name: Lean.PersistentHashSet.instInhabited
code: instance [BEq α] [Hashable α] : Inhabited (PersistentHashSet α) 
goal: Inhabited (Lean.PersistentHashSet α)

full_name: Lean.PersistentHashSet.instEmptyCollection
code: instance [BEq α] [Hashable α] : EmptyCollection (PersistentHashSet α) 
goal: EmptyCollection (Lean.PersistentHashSet α)

full_name: Lean.PersistentHashSet.isEmpty
code: @[inline] def isEmpty (s : PersistentHashSet α) : Bool 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashSet α → Bool

full_name: Lean.PersistentHashSet.insert
code: @[inline] def insert (s : PersistentHashSet α) (a : α) : PersistentHashSet α 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashSet α → α → Lean.PersistentHashSet α

full_name: Lean.PersistentHashSet.erase
code: @[inline] def erase (s : PersistentHashSet α) (a : α) : PersistentHashSet α 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashSet α → α → Lean.PersistentHashSet α

full_name: Lean.PersistentHashSet.find?
code: @[inline] def find? (s : PersistentHashSet α) (a : α) : Option α 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashSet α → α → Option α

full_name: Lean.PersistentHashSet.contains
code: @[inline] def contains (s : PersistentHashSet α) (a : α) : Bool 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashSet α → α → Bool

full_name: Lean.PersistentHashSet.foldM
code: @[inline] def foldM {β : Type v} {m : Type v → Type v} [Monad m] (f : β → α → m β) (init : β) (s : PersistentHashSet α) : m β 
goal: {x : BEq α} →
  {x_1 : Hashable α} →
    {β : Type v} → {m : Type v → Type v} → [inst : Monad m] → (β → α → m β) → β → Lean.PersistentHashSet α → m β

full_name: Lean.PersistentHashSet.fold
code: @[inline] def fold {β : Type v} (f : β → α → β) (init : β) (s : PersistentHashSet α) : β 
goal: {x : BEq α} → {x_1 : Hashable α} → {β : Type v} → (β → α → β) → β → Lean.PersistentHashSet α → β
File: .lake/packages/lean4/src/lean/Lean/Data/Lsp/Communication.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.Lsp.Communication.0.IO.FS.Stream.parseHeaderField
code: private def parseHeaderField (s : String) : Option (String × String) 
goal: Option (String × String)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.Lsp.Communication.0.IO.FS.Stream.isLean3Request
code: /-- Returns true when the string is a Lean 3 request.
  This means that the user is running a Lean 3 language client that
  is not aware of Lean 4. In this case we should give a friendlier message. -/
  private def isLean3Request (s : String) : Bool 
goal: Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.Lsp.Communication.0.IO.FS.Stream.readHeaderFields
code: private partial def readHeaderFields (h : FS.Stream) : IO (List (String × String)) 
goal: IO (List (String × String))

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.Lsp.Communication.0.IO.FS.Stream.readLspHeader
code: /-- Returns the Content-Length. -/
  private def readLspHeader (h : FS.Stream) : IO Nat 
goal: IO Nat

full_name: IO.FS.Stream.readLspMessage
code: def readLspMessage (h : FS.Stream) : IO Message 
goal: IO Lean.JsonRpc.Message

full_name: IO.FS.Stream.readLspRequestAs
code: def readLspRequestAs (h : FS.Stream) (expectedMethod : String) (α) [FromJson α] : IO (Request α) 
goal: IO (Lean.JsonRpc.Request α)

full_name: IO.FS.Stream.readLspNotificationAs
code: def readLspNotificationAs (h : FS.Stream) (expectedMethod : String) (α) [FromJson α] : IO (Notification α) 
goal: IO (Lean.JsonRpc.Notification α)

full_name: IO.FS.Stream.readLspResponseAs
code: def readLspResponseAs (h : FS.Stream) (expectedID : RequestID) (α) [FromJson α] : IO (Response α) 
goal: IO (Lean.JsonRpc.Response α)

full_name: IO.FS.Stream.writeLspMessage
code: def writeLspMessage (h : FS.Stream) (msg : Message) : IO Unit 
goal: IO Unit

full_name: IO.FS.Stream.writeLspRequest
code: def writeLspRequest (h : FS.Stream) (r : Request α) : IO Unit 
goal: IO Unit

full_name: IO.FS.Stream.writeLspNotification
code: def writeLspNotification (h : FS.Stream) (n : Notification α) : IO Unit 
goal: IO Unit

full_name: IO.FS.Stream.writeLspResponse
code: def writeLspResponse (h : FS.Stream) (r : Response α) : IO Unit 
goal: IO Unit

full_name: IO.FS.Stream.writeLspResponseError
code: def writeLspResponseError (h : FS.Stream) (e : ResponseError Unit) : IO Unit 
goal: IO Unit

full_name: IO.FS.Stream.writeLspResponseErrorWithData
code: def writeLspResponseErrorWithData (h : FS.Stream) (e : ResponseError α) : IO Unit 
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Data/Array.lean

full_name: Array.filterPairsM
code: /--
Given an array `a`, runs `f xᵢ xⱼ` for all `i < j`, removes those entries for which `f` returns
`false` (and will subsequently skip pairs if one element is removed), and returns the array of
remaining elements.

This can be used to remove elements from an array where a “better” element, in some partial
order, exists in the array.
-/
def filterPairsM {m} [Monad m] {α} (a : Array α) (f : α → α → m (Bool × Bool)) :
    m (Array α) 
goal: m (Array α)