File: .lake/packages/lean4/src/lean/Lean/Compiler/LCNF/Basic.lean

full_name: Lean.Compiler.LCNF.Param.fvarId
code: structure Param where
  fvarId     : FVarId
  binderName : Name
  type       : Expr
  borrow     : Bool
  deriving Inhabited, BEq
goal: Lean.FVarId

full_name: Lean.Compiler.LCNF.Param.binderName
code: structure Param where
  fvarId     : FVarId
  binderName : Name
  type       : Expr
  borrow     : Bool
  deriving Inhabited, BEq
goal: Lean.Name

full_name: Lean.Compiler.LCNF.Param.type
code: structure Param where
  fvarId     : FVarId
  binderName : Name
  type       : Expr
  borrow     : Bool
  deriving Inhabited, BEq
goal: Lean.Expr

full_name: Lean.Compiler.LCNF.Param.borrow
code: structure Param where
  fvarId     : FVarId
  binderName : Name
  type       : Expr
  borrow     : Bool
  deriving Inhabited, BEq
goal: Bool

full_name: Lean.Compiler.LCNF.instBEqParam
code: structure Param where
  fvarId     : FVarId
  binderName : Name
  type       : Expr
  borrow     : Bool
  deriving Inhabited, BEq
goal: BEq Lean.Compiler.LCNF.Param

full_name: Lean.Compiler.LCNF.instInhabitedParam
code: structure Param where
  fvarId     : FVarId
  binderName : Name
  type       : Expr
  borrow     : Bool
  deriving Inhabited, BEq
goal: Inhabited Lean.Compiler.LCNF.Param

full_name: Lean.Compiler.LCNF.Param
code: structure Param where
  fvarId     : FVarId
  binderName : Name
  type       : Expr
  borrow     : Bool
  deriving Inhabited, BEq
goal: Type

full_name: Lean.Compiler.LCNF.Param.toExpr
code: def Param.toExpr (p : Param) : Expr 
goal: Lean.Expr

full_name: Lean.Compiler.LCNF.AltCore
code: inductive AltCore (Code : Type) where
  | alt (ctorName : Name) (params : Array Param) (code : Code)
  | default (code : Code)
  deriving Inhabited
goal: Type

full_name: Lean.Compiler.LCNF.instInhabitedAltCore
code: inductive AltCore (Code : Type) where
  | alt (ctorName : Name) (params : Array Param) (code : Code)
  | default (code : Code)
  deriving Inhabited
goal: {a : Type} → [inst : Inhabited a] → Inhabited (Lean.Compiler.LCNF.AltCore a)

full_name: Lean.Compiler.LCNF.AltCore.alt
code: inductive AltCore (Code : Type) where
  | alt (ctorName : Name) (params : Array Param) (code : Code)
  | default (code : Code)
  deriving Inhabited
goal: Lean.Compiler.LCNF.AltCore Code

full_name: Lean.Compiler.LCNF.AltCore.default
code: inductive AltCore (Code : Type) where
  | alt (ctorName : Name) (params : Array Param) (code : Code)
  | default (code : Code)
  deriving Inhabited
goal: Lean.Compiler.LCNF.AltCore Code

full_name: Lean.Compiler.LCNF.LitValue.strVal
code: inductive LitValue where
  | natVal (val : Nat)
  | strVal (val : String)
  -- TODO: add constructors for `Int`, `Float`, `UInt` ...
  deriving Inhabited, BEq, Hashable
goal: Lean.Compiler.LCNF.LitValue

full_name: Lean.Compiler.LCNF.instHashableLitValue
code: inductive LitValue where
  | natVal (val : Nat)
  | strVal (val : String)
  -- TODO: add constructors for `Int`, `Float`, `UInt` ...
  deriving Inhabited, BEq, Hashable
goal: Hashable Lean.Compiler.LCNF.LitValue

full_name: Lean.Compiler.LCNF.LitValue
code: inductive LitValue where
  | natVal (val : Nat)
  | strVal (val : String)
  -- TODO: add constructors for `Int`, `Float`, `UInt` ...
  deriving Inhabited, BEq, Hashable
goal: Type

full_name: Lean.Compiler.LCNF.instBEqLitValue
code: inductive LitValue where
  | natVal (val : Nat)
  | strVal (val : String)
  -- TODO: add constructors for `Int`, `Float`, `UInt` ...
  deriving Inhabited, BEq, Hashable
goal: BEq Lean.Compiler.LCNF.LitValue

full_name: Lean.Compiler.LCNF.instInhabitedLitValue
code: inductive LitValue where
  | natVal (val : Nat)
  | strVal (val : String)
  -- TODO: add constructors for `Int`, `Float`, `UInt` ...
  deriving Inhabited, BEq, Hashable
goal: Inhabited Lean.Compiler.LCNF.LitValue

full_name: Lean.Compiler.LCNF.LitValue.natVal
code: inductive LitValue where
  | natVal (val : Nat)
  | strVal (val : String)
  -- TODO: add constructors for `Int`, `Float`, `UInt` ...
  deriving Inhabited, BEq, Hashable
goal: Lean.Compiler.LCNF.LitValue

full_name: Lean.Compiler.LCNF.LitValue.toExpr
code: def LitValue.toExpr : LitValue → Expr
  
goal: Lean.Compiler.LCNF.LitValue → Lean.Expr

full_name: Lean.Compiler.LCNF.Arg.fvar
code: inductive Arg where
  | erased
  | fvar (fvarId : FVarId)
  | type (expr : Expr)
  deriving Inhabited, BEq, Hashable
goal: Lean.Compiler.LCNF.Arg

full_name: Lean.Compiler.LCNF.instBEqArg
code: inductive Arg where
  | erased
  | fvar (fvarId : FVarId)
  | type (expr : Expr)
  deriving Inhabited, BEq, Hashable
goal: BEq Lean.Compiler.LCNF.Arg

full_name: Lean.Compiler.LCNF.instInhabitedArg
code: inductive Arg where
  | erased
  | fvar (fvarId : FVarId)
  | type (expr : Expr)
  deriving Inhabited, BEq, Hashable
goal: Inhabited Lean.Compiler.LCNF.Arg

full_name: Lean.Compiler.LCNF.instHashableArg
code: inductive Arg where
  | erased
  | fvar (fvarId : FVarId)
  | type (expr : Expr)
  deriving Inhabited, BEq, Hashable
goal: Hashable Lean.Compiler.LCNF.Arg

full_name: Lean.Compiler.LCNF.Arg.erased
code: inductive Arg where
  | erased
  | fvar (fvarId : FVarId)
  | type (expr : Expr)
  deriving Inhabited, BEq, Hashable
goal: Lean.Compiler.LCNF.Arg

full_name: Lean.Compiler.LCNF.Arg.type
code: inductive Arg where
  | erased
  | fvar (fvarId : FVarId)
  | type (expr : Expr)
  deriving Inhabited, BEq, Hashable
goal: Lean.Compiler.LCNF.Arg

full_name: Lean.Compiler.LCNF.Arg
code: inductive Arg where
  | erased
  | fvar (fvarId : FVarId)
  | type (expr : Expr)
  deriving Inhabited, BEq, Hashable
goal: Type

full_name: Lean.Compiler.LCNF.Param.toArg
code: def Param.toArg (p : Param) : Arg 
goal: Lean.Compiler.LCNF.Arg

full_name: Lean.Compiler.LCNF.Arg.toExpr
code: def Arg.toExpr (arg : Arg) : Expr 
goal: Lean.Expr

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.Arg.updateTypeImp
code: private unsafe def Arg.updateTypeImp (arg : Arg) (type' : Expr) : Arg 
goal: Lean.Compiler.LCNF.Arg

full_name: Lean.Compiler.LCNF.Arg.updateType!
code: @[implemented_by Arg.updateTypeImp] opaque Arg.updateType! (arg : Arg) (type : Expr) : Arg
goal: Lean.Compiler.LCNF.Arg

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.Arg.updateFVarImp
code: private unsafe def Arg.updateFVarImp (arg : Arg) (fvarId' : FVarId) : Arg 
goal: Lean.Compiler.LCNF.Arg

full_name: Lean.Compiler.LCNF.Arg.updateFVar!
code: @[implemented_by Arg.updateFVarImp] opaque Arg.updateFVar! (arg : Arg) (fvarId' : FVarId) : Arg
goal: Lean.Compiler.LCNF.Arg

full_name: Lean.Compiler.LCNF.LetValue.proj
code: inductive LetValue where
  | value (value : LitValue)
  | erased
  | proj (typeName : Name) (idx : Nat) (struct : FVarId)
  | const (declName : Name) (us : List Level) (args : Array Arg)
  | fvar (fvarId : FVarId) (args : Array Arg)
  -- TODO: add constructors for mono and impure phases
  deriving Inhabited, BEq, Hashable
goal: Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.LetValue.value
code: inductive LetValue where
  | value (value : LitValue)
  | erased
  | proj (typeName : Name) (idx : Nat) (struct : FVarId)
  | const (declName : Name) (us : List Level) (args : Array Arg)
  | fvar (fvarId : FVarId) (args : Array Arg)
  -- TODO: add constructors for mono and impure phases
  deriving Inhabited, BEq, Hashable
goal: Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.instBEqLetValue
code: inductive LetValue where
  | value (value : LitValue)
  | erased
  | proj (typeName : Name) (idx : Nat) (struct : FVarId)
  | const (declName : Name) (us : List Level) (args : Array Arg)
  | fvar (fvarId : FVarId) (args : Array Arg)
  -- TODO: add constructors for mono and impure phases
  deriving Inhabited, BEq, Hashable
goal: BEq Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.LetValue.fvar
code: inductive LetValue where
  | value (value : LitValue)
  | erased
  | proj (typeName : Name) (idx : Nat) (struct : FVarId)
  | const (declName : Name) (us : List Level) (args : Array Arg)
  | fvar (fvarId : FVarId) (args : Array Arg)
  -- TODO: add constructors for mono and impure phases
  deriving Inhabited, BEq, Hashable
goal: Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.LetValue.erased
code: inductive LetValue where
  | value (value : LitValue)
  | erased
  | proj (typeName : Name) (idx : Nat) (struct : FVarId)
  | const (declName : Name) (us : List Level) (args : Array Arg)
  | fvar (fvarId : FVarId) (args : Array Arg)
  -- TODO: add constructors for mono and impure phases
  deriving Inhabited, BEq, Hashable
goal: Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.LetValue.const
code: inductive LetValue where
  | value (value : LitValue)
  | erased
  | proj (typeName : Name) (idx : Nat) (struct : FVarId)
  | const (declName : Name) (us : List Level) (args : Array Arg)
  | fvar (fvarId : FVarId) (args : Array Arg)
  -- TODO: add constructors for mono and impure phases
  deriving Inhabited, BEq, Hashable
goal: Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.LetValue
code: inductive LetValue where
  | value (value : LitValue)
  | erased
  | proj (typeName : Name) (idx : Nat) (struct : FVarId)
  | const (declName : Name) (us : List Level) (args : Array Arg)
  | fvar (fvarId : FVarId) (args : Array Arg)
  -- TODO: add constructors for mono and impure phases
  deriving Inhabited, BEq, Hashable
goal: Type

full_name: Lean.Compiler.LCNF.instInhabitedLetValue
code: inductive LetValue where
  | value (value : LitValue)
  | erased
  | proj (typeName : Name) (idx : Nat) (struct : FVarId)
  | const (declName : Name) (us : List Level) (args : Array Arg)
  | fvar (fvarId : FVarId) (args : Array Arg)
  -- TODO: add constructors for mono and impure phases
  deriving Inhabited, BEq, Hashable
goal: Inhabited Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.instHashableLetValue
code: inductive LetValue where
  | value (value : LitValue)
  | erased
  | proj (typeName : Name) (idx : Nat) (struct : FVarId)
  | const (declName : Name) (us : List Level) (args : Array Arg)
  | fvar (fvarId : FVarId) (args : Array Arg)
  -- TODO: add constructors for mono and impure phases
  deriving Inhabited, BEq, Hashable
goal: Hashable Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.Arg.toLetValue
code: def Arg.toLetValue (arg : Arg) : LetValue 
goal: Lean.Compiler.LCNF.LetValue

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateProjImp
code: private unsafe def LetValue.updateProjImp (e : LetValue) (fvarId' : FVarId) : LetValue 
goal: Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.LetValue.updateProj!
code: @[implemented_by LetValue.updateProjImp] opaque LetValue.updateProj! (e : LetValue) (fvarId' : FVarId) : LetValue
goal: Lean.Compiler.LCNF.LetValue

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateConstImp
code: private unsafe def LetValue.updateConstImp (e : LetValue) (declName' : Name) (us' : List Level) (args' : Array Arg) : LetValue 
goal: Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.LetValue.updateConst!
code: @[implemented_by LetValue.updateConstImp] opaque LetValue.updateConst! (e : LetValue) (declName' : Name) (us' : List Level) (args' : Array Arg) : LetValue
goal: Lean.Compiler.LCNF.LetValue

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateFVarImp
code: private unsafe def LetValue.updateFVarImp (e : LetValue) (fvarId' : FVarId) (args' : Array Arg) : LetValue 
goal: Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.LetValue.updateFVar!
code: @[implemented_by LetValue.updateFVarImp] opaque LetValue.updateFVar! (e : LetValue) (fvarId' : FVarId) (args' : Array Arg) : LetValue
goal: Lean.Compiler.LCNF.LetValue

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateArgsImp
code: private unsafe def LetValue.updateArgsImp (e : LetValue) (args' : Array Arg) : LetValue 
goal: Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.LetValue.updateArgs!
code: @[implemented_by LetValue.updateArgsImp] opaque LetValue.updateArgs! (e : LetValue) (args' : Array Arg) : LetValue
goal: Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.LetValue.toExpr
code: def LetValue.toExpr (e : LetValue) : Expr 
goal: Lean.Expr

full_name: Lean.Compiler.LCNF.LetDecl.binderName
code: structure LetDecl where
  fvarId : FVarId
  binderName : Name
  type : Expr
  value : LetValue
  deriving Inhabited, BEq
goal: Lean.Name

full_name: Lean.Compiler.LCNF.LetDecl.value
code: structure LetDecl where
  fvarId : FVarId
  binderName : Name
  type : Expr
  value : LetValue
  deriving Inhabited, BEq
goal: Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.LetDecl.fvarId
code: structure LetDecl where
  fvarId : FVarId
  binderName : Name
  type : Expr
  value : LetValue
  deriving Inhabited, BEq
goal: Lean.FVarId

full_name: Lean.Compiler.LCNF.instBEqLetDecl
code: structure LetDecl where
  fvarId : FVarId
  binderName : Name
  type : Expr
  value : LetValue
  deriving Inhabited, BEq
goal: BEq Lean.Compiler.LCNF.LetDecl

full_name: Lean.Compiler.LCNF.instInhabitedLetDecl
code: structure LetDecl where
  fvarId : FVarId
  binderName : Name
  type : Expr
  value : LetValue
  deriving Inhabited, BEq
goal: Inhabited Lean.Compiler.LCNF.LetDecl

full_name: Lean.Compiler.LCNF.LetDecl
code: structure LetDecl where
  fvarId : FVarId
  binderName : Name
  type : Expr
  value : LetValue
  deriving Inhabited, BEq
goal: Type

full_name: Lean.Compiler.LCNF.LetDecl.type
code: structure LetDecl where
  fvarId : FVarId
  binderName : Name
  type : Expr
  value : LetValue
  deriving Inhabited, BEq
goal: Lean.Expr

full_name: Lean.Compiler.LCNF.FunDeclCore.value
code: structure FunDeclCore (Code : Type) where
  fvarId : FVarId
  binderName : Name
  params : Array Param
  type : Expr
  value : Code
  deriving Inhabited
goal: Code

full_name: Lean.Compiler.LCNF.instInhabitedFunDeclCore
code: structure FunDeclCore (Code : Type) where
  fvarId : FVarId
  binderName : Name
  params : Array Param
  type : Expr
  value : Code
  deriving Inhabited
goal: {a : Type} → [inst : Inhabited a] → Inhabited (Lean.Compiler.LCNF.FunDeclCore a)

full_name: Lean.Compiler.LCNF.FunDeclCore.type
code: structure FunDeclCore (Code : Type) where
  fvarId : FVarId
  binderName : Name
  params : Array Param
  type : Expr
  value : Code
  deriving Inhabited
goal: Lean.Expr

full_name: Lean.Compiler.LCNF.FunDeclCore.binderName
code: structure FunDeclCore (Code : Type) where
  fvarId : FVarId
  binderName : Name
  params : Array Param
  type : Expr
  value : Code
  deriving Inhabited
goal: Lean.Name

full_name: Lean.Compiler.LCNF.FunDeclCore
code: structure FunDeclCore (Code : Type) where
  fvarId : FVarId
  binderName : Name
  params : Array Param
  type : Expr
  value : Code
  deriving Inhabited
goal: Type

full_name: Lean.Compiler.LCNF.FunDeclCore.params
code: structure FunDeclCore (Code : Type) where
  fvarId : FVarId
  binderName : Name
  params : Array Param
  type : Expr
  value : Code
  deriving Inhabited
goal: Array Lean.Compiler.LCNF.Param

full_name: Lean.Compiler.LCNF.FunDeclCore.fvarId
code: structure FunDeclCore (Code : Type) where
  fvarId : FVarId
  binderName : Name
  params : Array Param
  type : Expr
  value : Code
  deriving Inhabited
goal: Lean.FVarId

full_name: Lean.Compiler.LCNF.FunDeclCore.getArity
code: def FunDeclCore.getArity (decl : FunDeclCore Code) : Nat 
goal: Nat

full_name: Lean.Compiler.LCNF.CasesCore.discr
code: structure CasesCore (Code : Type) where
  typeName : Name
  resultType : Expr
  discr : FVarId
  alts : Array (AltCore Code)
  deriving Inhabited
goal: Lean.FVarId

full_name: Lean.Compiler.LCNF.CasesCore
code: structure CasesCore (Code : Type) where
  typeName : Name
  resultType : Expr
  discr : FVarId
  alts : Array (AltCore Code)
  deriving Inhabited
goal: Type

full_name: Lean.Compiler.LCNF.CasesCore.alts
code: structure CasesCore (Code : Type) where
  typeName : Name
  resultType : Expr
  discr : FVarId
  alts : Array (AltCore Code)
  deriving Inhabited
goal: Array (Lean.Compiler.LCNF.AltCore Code)

full_name: Lean.Compiler.LCNF.CasesCore.typeName
code: structure CasesCore (Code : Type) where
  typeName : Name
  resultType : Expr
  discr : FVarId
  alts : Array (AltCore Code)
  deriving Inhabited
goal: Lean.Name

full_name: Lean.Compiler.LCNF.instInhabitedCasesCore
code: structure CasesCore (Code : Type) where
  typeName : Name
  resultType : Expr
  discr : FVarId
  alts : Array (AltCore Code)
  deriving Inhabited
goal: {a : Type} → Inhabited (Lean.Compiler.LCNF.CasesCore a)

full_name: Lean.Compiler.LCNF.CasesCore.resultType
code: structure CasesCore (Code : Type) where
  typeName : Name
  resultType : Expr
  discr : FVarId
  alts : Array (AltCore Code)
  deriving Inhabited
goal: Lean.Expr

full_name: Lean.Compiler.LCNF.Code
code: inductive Code where
  | let (decl : LetDecl) (k : Code)
  | fun (decl : FunDeclCore Code) (k : Code)
  | jp (decl : FunDeclCore Code) (k : Code)
  | jmp (fvarId : FVarId) (args : Array Arg)
  | cases (cases : CasesCore Code)
  | return (fvarId : FVarId)
  | unreach (type : Expr)
  deriving Inhabited
goal: Type

full_name: Lean.Compiler.LCNF.Code.jp
code: inductive Code where
  | let (decl : LetDecl) (k : Code)
  | fun (decl : FunDeclCore Code) (k : Code)
  | jp (decl : FunDeclCore Code) (k : Code)
  | jmp (fvarId : FVarId) (args : Array Arg)
  | cases (cases : CasesCore Code)
  | return (fvarId : FVarId)
  | unreach (type : Expr)
  deriving Inhabited
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.unreach
code: inductive Code where
  | let (decl : LetDecl) (k : Code)
  | fun (decl : FunDeclCore Code) (k : Code)
  | jp (decl : FunDeclCore Code) (k : Code)
  | jmp (fvarId : FVarId) (args : Array Arg)
  | cases (cases : CasesCore Code)
  | return (fvarId : FVarId)
  | unreach (type : Expr)
  deriving Inhabited
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.instInhabitedCode
code: inductive Code where
  | let (decl : LetDecl) (k : Code)
  | fun (decl : FunDeclCore Code) (k : Code)
  | jp (decl : FunDeclCore Code) (k : Code)
  | jmp (fvarId : FVarId) (args : Array Arg)
  | cases (cases : CasesCore Code)
  | return (fvarId : FVarId)
  | unreach (type : Expr)
  deriving Inhabited
goal: Inhabited Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.cases
code: inductive Code where
  | let (decl : LetDecl) (k : Code)
  | fun (decl : FunDeclCore Code) (k : Code)
  | jp (decl : FunDeclCore Code) (k : Code)
  | jmp (fvarId : FVarId) (args : Array Arg)
  | cases (cases : CasesCore Code)
  | return (fvarId : FVarId)
  | unreach (type : Expr)
  deriving Inhabited
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.return
code: inductive Code where
  | let (decl : LetDecl) (k : Code)
  | fun (decl : FunDeclCore Code) (k : Code)
  | jp (decl : FunDeclCore Code) (k : Code)
  | jmp (fvarId : FVarId) (args : Array Arg)
  | cases (cases : CasesCore Code)
  | return (fvarId : FVarId)
  | unreach (type : Expr)
  deriving Inhabited
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.jmp
code: inductive Code where
  | let (decl : LetDecl) (k : Code)
  | fun (decl : FunDeclCore Code) (k : Code)
  | jp (decl : FunDeclCore Code) (k : Code)
  | jmp (fvarId : FVarId) (args : Array Arg)
  | cases (cases : CasesCore Code)
  | return (fvarId : FVarId)
  | unreach (type : Expr)
  deriving Inhabited
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.let
code: inductive Code where
  | let (decl : LetDecl) (k : Code)
  | fun (decl : FunDeclCore Code) (k : Code)
  | jp (decl : FunDeclCore Code) (k : Code)
  | jmp (fvarId : FVarId) (args : Array Arg)
  | cases (cases : CasesCore Code)
  | return (fvarId : FVarId)
  | unreach (type : Expr)
  deriving Inhabited
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.fun
code: inductive Code where
  | let (decl : LetDecl) (k : Code)
  | fun (decl : FunDeclCore Code) (k : Code)
  | jp (decl : FunDeclCore Code) (k : Code)
  | jmp (fvarId : FVarId) (args : Array Arg)
  | cases (cases : CasesCore Code)
  | return (fvarId : FVarId)
  | unreach (type : Expr)
  deriving Inhabited
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Alt
code: abbrev Alt 
goal: Type

full_name: Lean.Compiler.LCNF.FunDecl
code: abbrev FunDecl 
goal: Type

full_name: Lean.Compiler.LCNF.Cases
code: abbrev Cases 
goal: Type

full_name: Lean.Compiler.LCNF.CasesCore.getCtorNames
code: /--
Return the constructor names that have an explicit (non-default) alternative.
-/
def CasesCore.getCtorNames (c : Cases) : NameSet 
goal: Lean.NameSet

full_name: Lean.Compiler.LCNF.CodeDecl.let
code: inductive CodeDecl where
  | let (decl : LetDecl)
  | fun (decl : FunDecl)
  | jp (decl : FunDecl)
  deriving Inhabited
goal: Lean.Compiler.LCNF.CodeDecl

full_name: Lean.Compiler.LCNF.CodeDecl
code: inductive CodeDecl where
  | let (decl : LetDecl)
  | fun (decl : FunDecl)
  | jp (decl : FunDecl)
  deriving Inhabited
goal: Type

full_name: Lean.Compiler.LCNF.instInhabitedCodeDecl
code: inductive CodeDecl where
  | let (decl : LetDecl)
  | fun (decl : FunDecl)
  | jp (decl : FunDecl)
  deriving Inhabited
goal: Inhabited Lean.Compiler.LCNF.CodeDecl

full_name: Lean.Compiler.LCNF.CodeDecl.jp
code: inductive CodeDecl where
  | let (decl : LetDecl)
  | fun (decl : FunDecl)
  | jp (decl : FunDecl)
  deriving Inhabited
goal: Lean.Compiler.LCNF.CodeDecl

full_name: Lean.Compiler.LCNF.CodeDecl.fun
code: inductive CodeDecl where
  | let (decl : LetDecl)
  | fun (decl : FunDecl)
  | jp (decl : FunDecl)
  deriving Inhabited
goal: Lean.Compiler.LCNF.CodeDecl

full_name: Lean.Compiler.LCNF.CodeDecl.fvarId
code: def CodeDecl.fvarId : CodeDecl → FVarId
  
goal: Lean.Compiler.LCNF.CodeDecl → Lean.FVarId

full_name: Lean.Compiler.LCNF.attachCodeDecls.go
code: def attachCodeDecls (decls : Array CodeDecl) (code : Code) : Code 
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.attachCodeDecls
code: def attachCodeDecls (decls : Array CodeDecl) (code : Code) : Code 
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.beq
code: @[implemented_by eqImp] protected opaque Code.beq : Code → Code → Bool
goal: Lean.Compiler.LCNF.Code → Lean.Compiler.LCNF.Code → Bool

full_name: Lean.Compiler.LCNF.instBEqCode
code: instance : BEq Code 
goal: BEq Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.FunDecl.beq
code: @[implemented_by eqFunDecl] protected opaque FunDecl.beq : FunDecl → FunDecl → Bool
goal: Lean.Compiler.LCNF.FunDecl → Lean.Compiler.LCNF.FunDecl → Bool

full_name: Lean.Compiler.LCNF.instBEqFunDecl
code: instance : BEq FunDecl 
goal: BEq Lean.Compiler.LCNF.FunDecl

full_name: Lean.Compiler.LCNF.AltCore.getCode
code: def AltCore.getCode : Alt → Code
  
goal: Lean.Compiler.LCNF.Alt → Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.AltCore.getParams
code: def AltCore.getParams : Alt → Array Param
  
goal: Lean.Compiler.LCNF.Alt → Array Lean.Compiler.LCNF.Param

full_name: Lean.Compiler.LCNF.AltCore.forCodeM
code: def AltCore.forCodeM [Monad m] (alt : Alt) (f : Code → m Unit) : m Unit 
goal: m Unit

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateAltCodeImp
code: private unsafe def updateAltCodeImp (alt : Alt) (k' : Code) : Alt 
goal: Lean.Compiler.LCNF.Alt

full_name: Lean.Compiler.LCNF.AltCore.updateCode
code: @[implemented_by updateAltCodeImp] opaque AltCore.updateCode (alt : Alt) (c : Code) : Alt
goal: Lean.Compiler.LCNF.Alt

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateAltImp
code: private unsafe def updateAltImp (alt : Alt) (ps' : Array Param) (k' : Code) : Alt 
goal: Lean.Compiler.LCNF.Alt

full_name: Lean.Compiler.LCNF.AltCore.updateAlt!
code: @[implemented_by updateAltImp] opaque AltCore.updateAlt! (alt : Alt) (ps' : Array Param) (k' : Code) : Alt
goal: Lean.Compiler.LCNF.Alt

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateAltsImp
code: @[inline] private unsafe def updateAltsImp (c : Code) (alts : Array Alt) : Code 
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.updateAlts!
code: @[implemented_by updateAltsImp] opaque Code.updateAlts! (c : Code) (alts : Array Alt) : Code
goal: Lean.Compiler.LCNF.Code

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateCasesImp
code: @[inline] private unsafe def updateCasesImp (c : Code) (resultType : Expr) (discr : FVarId) (alts : Array Alt) : Code 
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.updateCases!
code: @[implemented_by updateCasesImp] opaque Code.updateCases! (c : Code) (resultType : Expr) (discr : FVarId) (alts : Array Alt) : Code
goal: Lean.Compiler.LCNF.Code

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateLetImp
code: @[inline] private unsafe def updateLetImp (c : Code) (decl' : LetDecl) (k' : Code) : Code 
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.updateLet!
code: @[implemented_by updateLetImp] opaque Code.updateLet! (c : Code) (decl' : LetDecl) (k' : Code) : Code
goal: Lean.Compiler.LCNF.Code

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateContImp
code: @[inline] private unsafe def updateContImp (c : Code) (k' : Code) : Code 
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.updateCont!
code: @[implemented_by updateContImp] opaque Code.updateCont! (c : Code) (k' : Code) : Code
goal: Lean.Compiler.LCNF.Code

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateFunImp
code: @[inline] private unsafe def updateFunImp (c : Code) (decl' : FunDecl) (k' : Code) : Code 
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.updateFun!
code: @[implemented_by updateFunImp] opaque Code.updateFun! (c : Code) (decl' : FunDecl) (k' : Code) : Code
goal: Lean.Compiler.LCNF.Code

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateReturnImp
code: @[inline] private unsafe def updateReturnImp (c : Code) (fvarId' : FVarId) : Code 
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.updateReturn!
code: @[implemented_by updateReturnImp] opaque Code.updateReturn! (c : Code) (fvarId' : FVarId) : Code
goal: Lean.Compiler.LCNF.Code

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateJmpImp
code: @[inline] private unsafe def updateJmpImp (c : Code) (fvarId' : FVarId) (args' : Array Arg) : Code 
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.updateJmp!
code: @[implemented_by updateJmpImp] opaque Code.updateJmp! (c : Code) (fvarId' : FVarId) (args' : Array Arg) : Code
goal: Lean.Compiler.LCNF.Code

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateUnreachImp
code: @[inline] private unsafe def updateUnreachImp (c : Code) (type' : Expr) : Code 
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Code.updateUnreach!
code: @[implemented_by updateUnreachImp] opaque Code.updateUnreach! (c : Code) (type' : Expr) : Code
goal: Lean.Compiler.LCNF.Code

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateParamCoreImp
code: private unsafe def updateParamCoreImp (p : Param) (type : Expr) : Param 
goal: Lean.Compiler.LCNF.Param

full_name: Lean.Compiler.LCNF.Param.updateCore
code: /--
Low-level update `Param` function. It does not update the local context.
Consider using `Param.update : Param → Expr → CompilerM Param` if you want the local context
to be updated.
-/
@[implemented_by updateParamCoreImp] opaque Param.updateCore (p : Param) (type : Expr) : Param
goal: Lean.Compiler.LCNF.Param

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateLetDeclCoreImp
code: private unsafe def updateLetDeclCoreImp (decl : LetDecl) (type : Expr) (value : LetValue) : LetDecl 
goal: Lean.Compiler.LCNF.LetDecl

full_name: Lean.Compiler.LCNF.LetDecl.updateCore
code: /--
Low-level update `LetDecl` function. It does not update the local context.
Consider using `LetDecl.update : LetDecl → Expr → Expr → CompilerM LetDecl` if you want the local context
to be updated.
-/
@[implemented_by updateLetDeclCoreImp] opaque LetDecl.updateCore (decl : LetDecl) (type : Expr) (value : LetValue) : LetDecl
goal: Lean.Compiler.LCNF.LetDecl

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateFunDeclCoreImp
code: private unsafe def updateFunDeclCoreImp (decl: FunDecl) (type : Expr) (params : Array Param) (value : Code) : FunDecl 
goal: Lean.Compiler.LCNF.FunDecl

full_name: Lean.Compiler.LCNF.FunDeclCore.updateCore
code: /--
Low-level update `FunDecl` function. It does not update the local context.
Consider using `FunDecl.update : LetDecl → Expr → Array Param → Code → CompilerM FunDecl` if you want the local context
to be updated.
-/
@[implemented_by updateFunDeclCoreImp] opaque FunDeclCore.updateCore (decl: FunDecl) (type : Expr) (params : Array Param) (value : Code) : FunDecl
goal: Lean.Compiler.LCNF.FunDecl

full_name: Lean.Compiler.LCNF.CasesCore.extractAlt!
code: def CasesCore.extractAlt! (cases : Cases) (ctorName : Name) : Alt × Cases 
goal: Lean.Compiler.LCNF.Alt × Lean.Compiler.LCNF.Cases

full_name: Lean.Compiler.LCNF.AltCore.mapCodeM
code: def AltCore.mapCodeM [Monad m] (alt : Alt) (f : Code → m Code) : m Alt 
goal: m Lean.Compiler.LCNF.Alt

full_name: Lean.Compiler.LCNF.Code.isDecl
code: def Code.isDecl : Code → Bool
  
goal: Lean.Compiler.LCNF.Code → Bool

full_name: Lean.Compiler.LCNF.Code.isFun
code: def Code.isFun : Code → Bool
  
goal: Lean.Compiler.LCNF.Code → Bool

full_name: Lean.Compiler.LCNF.Code.isReturnOf
code: def Code.isReturnOf : Code → FVarId → Bool
  
goal: Lean.Compiler.LCNF.Code → Lean.FVarId → Bool

full_name: Lean.Compiler.LCNF.Code.size.go
code: partial def Code.size (c : Code) : Nat 
goal: Nat

full_name: Lean.Compiler.LCNF.Code.size
code: partial def Code.size (c : Code) : Nat 
goal: Nat

full_name: Lean.Compiler.LCNF.Code.sizeLe.inc
code: /-- Return true iff `c.size ≤ n` -/
partial def Code.sizeLe (c : Code) (n : Nat) : Bool 
goal: EStateM Unit Nat Unit

full_name: Lean.Compiler.LCNF.Code.sizeLe
code: /-- Return true iff `c.size ≤ n` -/
partial def Code.sizeLe (c : Code) (n : Nat) : Bool 
goal: Bool

full_name: Lean.Compiler.LCNF.Code.sizeLe.go
code: /-- Return true iff `c.size ≤ n` -/
partial def Code.sizeLe (c : Code) (n : Nat) : Bool 
goal: EStateM Unit Nat Unit

full_name: Lean.Compiler.LCNF.Code.forM.go
code: partial def Code.forM [Monad m] (c : Code) (f : Code → m Unit) : m Unit 
goal: m Unit

full_name: Lean.Compiler.LCNF.Code.forM
code: partial def Code.forM [Monad m] (c : Code) (f : Code → m Unit) : m Unit 
goal: m Unit

full_name: Lean.Compiler.LCNF.Decl
code: /--
Declaration being processed by the Lean to Lean compiler passes.
-/
structure Decl where
  /--
  The name of the declaration from the `Environment` it came from
  -/
  name  : Name
  /--
  Universe level parameter names.
  -/
  levelParams : List Name
  /--
  The type of the declaration. Note that this is an erased LCNF type
  instead of the fully dependent one that might have been the original
  type of the declaration in the `Environment`.
  -/
  type  : Expr
  /--
  Parameters.
  -/
  params : Array Param
  /--
  The body of the declaration, usually changes as it progresses
  through compiler passes.
  -/
  value : Code
  /--
  We set this flag to true during LCNF conversion. When we receive
  a block of functions to be compiled, we set this flag to `true`
  if there is an application to the function in the block containing
  it. This is an approximation, but it should be good enough because
  in the frontend, we invoke the compiler with blocks of strongly connected
  components only.
  We use this information to control inlining.
  -/
  recursive : Bool := false
  /--
  We set this flag to false during LCNF conversion if the Lean function
  associated with this function was tagged as partial or unsafe. This
  information affects how static analyzers treat function applications
  of this kind. See `DefinitionSafety`.
  `partial` and `unsafe` functions may not be terminating, but Lean
  functions terminate, and some static analyzers exploit this
  fact. So, we use the following semantics. Suppose we have a (large) natural
  number `C`. We consider a nondeterministic model for computation of Lean expressions as
  follows:
  Each call to a partial/unsafe function uses up one "recursion token".
  Prior to consuming `C` recursion tokens all partial functions must be called
  as normal. Once the model has used up `C` recursion tokens, a subsequent call to
  a partial function has the following nondeterministic options: it can either call
  the function again, or return any value of the target type (even a noncomputable one).
  Larger values of `C` yield less nondeterminism in the model, but even the intersection of
  all choices of `C` yields nondeterminism where `def loop : A := loop` returns any value of type `A`.
  The compiler fixes a choice for `C`. This is a fixed constant greater than 2^2^64,
  which is allowed to be compiler and architecture dependent, and promises that it will
  produce an execution consistent with every possible nondeterministic outcome of the `C`-model.
  In the event that different nondeterministic executions disagree, the compiler is required to
  exhaust resources or output a looping computation.
  -/
  safe : Bool := true
  /--
  We store the inline attribute at LCNF declarations to make sure we can set them for
  auxiliary declarations created during compilation.
  -/
  inlineAttr? : Option InlineAttributeKind
  deriving Inhabited, BEq
goal: Type

full_name: Lean.Compiler.LCNF.Decl.levelParams
code: /--
Declaration being processed by the Lean to Lean compiler passes.
-/
structure Decl where
  /--
  The name of the declaration from the `Environment` it came from
  -/
  name  : Name
  /--
  Universe level parameter names.
  -/
  levelParams : List Name
  /--
  The type of the declaration. Note that this is an erased LCNF type
  instead of the fully dependent one that might have been the original
  type of the declaration in the `Environment`.
  -/
  type  : Expr
  /--
  Parameters.
  -/
  params : Array Param
  /--
  The body of the declaration, usually changes as it progresses
  through compiler passes.
  -/
  value : Code
  /--
  We set this flag to true during LCNF conversion. When we receive
  a block of functions to be compiled, we set this flag to `true`
  if there is an application to the function in the block containing
  it. This is an approximation, but it should be good enough because
  in the frontend, we invoke the compiler with blocks of strongly connected
  components only.
  We use this information to control inlining.
  -/
  recursive : Bool := false
  /--
  We set this flag to false during LCNF conversion if the Lean function
  associated with this function was tagged as partial or unsafe. This
  information affects how static analyzers treat function applications
  of this kind. See `DefinitionSafety`.
  `partial` and `unsafe` functions may not be terminating, but Lean
  functions terminate, and some static analyzers exploit this
  fact. So, we use the following semantics. Suppose we have a (large) natural
  number `C`. We consider a nondeterministic model for computation of Lean expressions as
  follows:
  Each call to a partial/unsafe function uses up one "recursion token".
  Prior to consuming `C` recursion tokens all partial functions must be called
  as normal. Once the model has used up `C` recursion tokens, a subsequent call to
  a partial function has the following nondeterministic options: it can either call
  the function again, or return any value of the target type (even a noncomputable one).
  Larger values of `C` yield less nondeterminism in the model, but even the intersection of
  all choices of `C` yields nondeterminism where `def loop : A := loop` returns any value of type `A`.
  The compiler fixes a choice for `C`. This is a fixed constant greater than 2^2^64,
  which is allowed to be compiler and architecture dependent, and promises that it will
  produce an execution consistent with every possible nondeterministic outcome of the `C`-model.
  In the event that different nondeterministic executions disagree, the compiler is required to
  exhaust resources or output a looping computation.
  -/
  safe : Bool := true
  /--
  We store the inline attribute at LCNF declarations to make sure we can set them for
  auxiliary declarations created during compilation.
  -/
  inlineAttr? : Option InlineAttributeKind
  deriving Inhabited, BEq
goal: List Lean.Name

full_name: Lean.Compiler.LCNF.Decl.recursive
code: /--
Declaration being processed by the Lean to Lean compiler passes.
-/
structure Decl where
  /--
  The name of the declaration from the `Environment` it came from
  -/
  name  : Name
  /--
  Universe level parameter names.
  -/
  levelParams : List Name
  /--
  The type of the declaration. Note that this is an erased LCNF type
  instead of the fully dependent one that might have been the original
  type of the declaration in the `Environment`.
  -/
  type  : Expr
  /--
  Parameters.
  -/
  params : Array Param
  /--
  The body of the declaration, usually changes as it progresses
  through compiler passes.
  -/
  value : Code
  /--
  We set this flag to true during LCNF conversion. When we receive
  a block of functions to be compiled, we set this flag to `true`
  if there is an application to the function in the block containing
  it. This is an approximation, but it should be good enough because
  in the frontend, we invoke the compiler with blocks of strongly connected
  components only.
  We use this information to control inlining.
  -/
  recursive : Bool := false
  /--
  We set this flag to false during LCNF conversion if the Lean function
  associated with this function was tagged as partial or unsafe. This
  information affects how static analyzers treat function applications
  of this kind. See `DefinitionSafety`.
  `partial` and `unsafe` functions may not be terminating, but Lean
  functions terminate, and some static analyzers exploit this
  fact. So, we use the following semantics. Suppose we have a (large) natural
  number `C`. We consider a nondeterministic model for computation of Lean expressions as
  follows:
  Each call to a partial/unsafe function uses up one "recursion token".
  Prior to consuming `C` recursion tokens all partial functions must be called
  as normal. Once the model has used up `C` recursion tokens, a subsequent call to
  a partial function has the following nondeterministic options: it can either call
  the function again, or return any value of the target type (even a noncomputable one).
  Larger values of `C` yield less nondeterminism in the model, but even the intersection of
  all choices of `C` yields nondeterminism where `def loop : A := loop` returns any value of type `A`.
  The compiler fixes a choice for `C`. This is a fixed constant greater than 2^2^64,
  which is allowed to be compiler and architecture dependent, and promises that it will
  produce an execution consistent with every possible nondeterministic outcome of the `C`-model.
  In the event that different nondeterministic executions disagree, the compiler is required to
  exhaust resources or output a looping computation.
  -/
  safe : Bool := true
  /--
  We store the inline attribute at LCNF declarations to make sure we can set them for
  auxiliary declarations created during compilation.
  -/
  inlineAttr? : Option InlineAttributeKind
  deriving Inhabited, BEq
goal: Bool

full_name: Lean.Compiler.LCNF.Decl.value
code: /--
Declaration being processed by the Lean to Lean compiler passes.
-/
structure Decl where
  /--
  The name of the declaration from the `Environment` it came from
  -/
  name  : Name
  /--
  Universe level parameter names.
  -/
  levelParams : List Name
  /--
  The type of the declaration. Note that this is an erased LCNF type
  instead of the fully dependent one that might have been the original
  type of the declaration in the `Environment`.
  -/
  type  : Expr
  /--
  Parameters.
  -/
  params : Array Param
  /--
  The body of the declaration, usually changes as it progresses
  through compiler passes.
  -/
  value : Code
  /--
  We set this flag to true during LCNF conversion. When we receive
  a block of functions to be compiled, we set this flag to `true`
  if there is an application to the function in the block containing
  it. This is an approximation, but it should be good enough because
  in the frontend, we invoke the compiler with blocks of strongly connected
  components only.
  We use this information to control inlining.
  -/
  recursive : Bool := false
  /--
  We set this flag to false during LCNF conversion if the Lean function
  associated with this function was tagged as partial or unsafe. This
  information affects how static analyzers treat function applications
  of this kind. See `DefinitionSafety`.
  `partial` and `unsafe` functions may not be terminating, but Lean
  functions terminate, and some static analyzers exploit this
  fact. So, we use the following semantics. Suppose we have a (large) natural
  number `C`. We consider a nondeterministic model for computation of Lean expressions as
  follows:
  Each call to a partial/unsafe function uses up one "recursion token".
  Prior to consuming `C` recursion tokens all partial functions must be called
  as normal. Once the model has used up `C` recursion tokens, a subsequent call to
  a partial function has the following nondeterministic options: it can either call
  the function again, or return any value of the target type (even a noncomputable one).
  Larger values of `C` yield less nondeterminism in the model, but even the intersection of
  all choices of `C` yields nondeterminism where `def loop : A := loop` returns any value of type `A`.
  The compiler fixes a choice for `C`. This is a fixed constant greater than 2^2^64,
  which is allowed to be compiler and architecture dependent, and promises that it will
  produce an execution consistent with every possible nondeterministic outcome of the `C`-model.
  In the event that different nondeterministic executions disagree, the compiler is required to
  exhaust resources or output a looping computation.
  -/
  safe : Bool := true
  /--
  We store the inline attribute at LCNF declarations to make sure we can set them for
  auxiliary declarations created during compilation.
  -/
  inlineAttr? : Option InlineAttributeKind
  deriving Inhabited, BEq
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.instInhabitedDecl
code: /--
Declaration being processed by the Lean to Lean compiler passes.
-/
structure Decl where
  /--
  The name of the declaration from the `Environment` it came from
  -/
  name  : Name
  /--
  Universe level parameter names.
  -/
  levelParams : List Name
  /--
  The type of the declaration. Note that this is an erased LCNF type
  instead of the fully dependent one that might have been the original
  type of the declaration in the `Environment`.
  -/
  type  : Expr
  /--
  Parameters.
  -/
  params : Array Param
  /--
  The body of the declaration, usually changes as it progresses
  through compiler passes.
  -/
  value : Code
  /--
  We set this flag to true during LCNF conversion. When we receive
  a block of functions to be compiled, we set this flag to `true`
  if there is an application to the function in the block containing
  it. This is an approximation, but it should be good enough because
  in the frontend, we invoke the compiler with blocks of strongly connected
  components only.
  We use this information to control inlining.
  -/
  recursive : Bool := false
  /--
  We set this flag to false during LCNF conversion if the Lean function
  associated with this function was tagged as partial or unsafe. This
  information affects how static analyzers treat function applications
  of this kind. See `DefinitionSafety`.
  `partial` and `unsafe` functions may not be terminating, but Lean
  functions terminate, and some static analyzers exploit this
  fact. So, we use the following semantics. Suppose we have a (large) natural
  number `C`. We consider a nondeterministic model for computation of Lean expressions as
  follows:
  Each call to a partial/unsafe function uses up one "recursion token".
  Prior to consuming `C` recursion tokens all partial functions must be called
  as normal. Once the model has used up `C` recursion tokens, a subsequent call to
  a partial function has the following nondeterministic options: it can either call
  the function again, or return any value of the target type (even a noncomputable one).
  Larger values of `C` yield less nondeterminism in the model, but even the intersection of
  all choices of `C` yields nondeterminism where `def loop : A := loop` returns any value of type `A`.
  The compiler fixes a choice for `C`. This is a fixed constant greater than 2^2^64,
  which is allowed to be compiler and architecture dependent, and promises that it will
  produce an execution consistent with every possible nondeterministic outcome of the `C`-model.
  In the event that different nondeterministic executions disagree, the compiler is required to
  exhaust resources or output a looping computation.
  -/
  safe : Bool := true
  /--
  We store the inline attribute at LCNF declarations to make sure we can set them for
  auxiliary declarations created during compilation.
  -/
  inlineAttr? : Option InlineAttributeKind
  deriving Inhabited, BEq
goal: Inhabited Lean.Compiler.LCNF.Decl

full_name: Lean.Compiler.LCNF.Decl.safe
code: /--
Declaration being processed by the Lean to Lean compiler passes.
-/
structure Decl where
  /--
  The name of the declaration from the `Environment` it came from
  -/
  name  : Name
  /--
  Universe level parameter names.
  -/
  levelParams : List Name
  /--
  The type of the declaration. Note that this is an erased LCNF type
  instead of the fully dependent one that might have been the original
  type of the declaration in the `Environment`.
  -/
  type  : Expr
  /--
  Parameters.
  -/
  params : Array Param
  /--
  The body of the declaration, usually changes as it progresses
  through compiler passes.
  -/
  value : Code
  /--
  We set this flag to true during LCNF conversion. When we receive
  a block of functions to be compiled, we set this flag to `true`
  if there is an application to the function in the block containing
  it. This is an approximation, but it should be good enough because
  in the frontend, we invoke the compiler with blocks of strongly connected
  components only.
  We use this information to control inlining.
  -/
  recursive : Bool := false
  /--
  We set this flag to false during LCNF conversion if the Lean function
  associated with this function was tagged as partial or unsafe. This
  information affects how static analyzers treat function applications
  of this kind. See `DefinitionSafety`.
  `partial` and `unsafe` functions may not be terminating, but Lean
  functions terminate, and some static analyzers exploit this
  fact. So, we use the following semantics. Suppose we have a (large) natural
  number `C`. We consider a nondeterministic model for computation of Lean expressions as
  follows:
  Each call to a partial/unsafe function uses up one "recursion token".
  Prior to consuming `C` recursion tokens all partial functions must be called
  as normal. Once the model has used up `C` recursion tokens, a subsequent call to
  a partial function has the following nondeterministic options: it can either call
  the function again, or return any value of the target type (even a noncomputable one).
  Larger values of `C` yield less nondeterminism in the model, but even the intersection of
  all choices of `C` yields nondeterminism where `def loop : A := loop` returns any value of type `A`.
  The compiler fixes a choice for `C`. This is a fixed constant greater than 2^2^64,
  which is allowed to be compiler and architecture dependent, and promises that it will
  produce an execution consistent with every possible nondeterministic outcome of the `C`-model.
  In the event that different nondeterministic executions disagree, the compiler is required to
  exhaust resources or output a looping computation.
  -/
  safe : Bool := true
  /--
  We store the inline attribute at LCNF declarations to make sure we can set them for
  auxiliary declarations created during compilation.
  -/
  inlineAttr? : Option InlineAttributeKind
  deriving Inhabited, BEq
goal: Bool

full_name: Lean.Compiler.LCNF.Decl.params
code: /--
Declaration being processed by the Lean to Lean compiler passes.
-/
structure Decl where
  /--
  The name of the declaration from the `Environment` it came from
  -/
  name  : Name
  /--
  Universe level parameter names.
  -/
  levelParams : List Name
  /--
  The type of the declaration. Note that this is an erased LCNF type
  instead of the fully dependent one that might have been the original
  type of the declaration in the `Environment`.
  -/
  type  : Expr
  /--
  Parameters.
  -/
  params : Array Param
  /--
  The body of the declaration, usually changes as it progresses
  through compiler passes.
  -/
  value : Code
  /--
  We set this flag to true during LCNF conversion. When we receive
  a block of functions to be compiled, we set this flag to `true`
  if there is an application to the function in the block containing
  it. This is an approximation, but it should be good enough because
  in the frontend, we invoke the compiler with blocks of strongly connected
  components only.
  We use this information to control inlining.
  -/
  recursive : Bool := false
  /--
  We set this flag to false during LCNF conversion if the Lean function
  associated with this function was tagged as partial or unsafe. This
  information affects how static analyzers treat function applications
  of this kind. See `DefinitionSafety`.
  `partial` and `unsafe` functions may not be terminating, but Lean
  functions terminate, and some static analyzers exploit this
  fact. So, we use the following semantics. Suppose we have a (large) natural
  number `C`. We consider a nondeterministic model for computation of Lean expressions as
  follows:
  Each call to a partial/unsafe function uses up one "recursion token".
  Prior to consuming `C` recursion tokens all partial functions must be called
  as normal. Once the model has used up `C` recursion tokens, a subsequent call to
  a partial function has the following nondeterministic options: it can either call
  the function again, or return any value of the target type (even a noncomputable one).
  Larger values of `C` yield less nondeterminism in the model, but even the intersection of
  all choices of `C` yields nondeterminism where `def loop : A := loop` returns any value of type `A`.
  The compiler fixes a choice for `C`. This is a fixed constant greater than 2^2^64,
  which is allowed to be compiler and architecture dependent, and promises that it will
  produce an execution consistent with every possible nondeterministic outcome of the `C`-model.
  In the event that different nondeterministic executions disagree, the compiler is required to
  exhaust resources or output a looping computation.
  -/
  safe : Bool := true
  /--
  We store the inline attribute at LCNF declarations to make sure we can set them for
  auxiliary declarations created during compilation.
  -/
  inlineAttr? : Option InlineAttributeKind
  deriving Inhabited, BEq
goal: Array Lean.Compiler.LCNF.Param

full_name: Lean.Compiler.LCNF.Decl.type
code: /--
Declaration being processed by the Lean to Lean compiler passes.
-/
structure Decl where
  /--
  The name of the declaration from the `Environment` it came from
  -/
  name  : Name
  /--
  Universe level parameter names.
  -/
  levelParams : List Name
  /--
  The type of the declaration. Note that this is an erased LCNF type
  instead of the fully dependent one that might have been the original
  type of the declaration in the `Environment`.
  -/
  type  : Expr
  /--
  Parameters.
  -/
  params : Array Param
  /--
  The body of the declaration, usually changes as it progresses
  through compiler passes.
  -/
  value : Code
  /--
  We set this flag to true during LCNF conversion. When we receive
  a block of functions to be compiled, we set this flag to `true`
  if there is an application to the function in the block containing
  it. This is an approximation, but it should be good enough because
  in the frontend, we invoke the compiler with blocks of strongly connected
  components only.
  We use this information to control inlining.
  -/
  recursive : Bool := false
  /--
  We set this flag to false during LCNF conversion if the Lean function
  associated with this function was tagged as partial or unsafe. This
  information affects how static analyzers treat function applications
  of this kind. See `DefinitionSafety`.
  `partial` and `unsafe` functions may not be terminating, but Lean
  functions terminate, and some static analyzers exploit this
  fact. So, we use the following semantics. Suppose we have a (large) natural
  number `C`. We consider a nondeterministic model for computation of Lean expressions as
  follows:
  Each call to a partial/unsafe function uses up one "recursion token".
  Prior to consuming `C` recursion tokens all partial functions must be called
  as normal. Once the model has used up `C` recursion tokens, a subsequent call to
  a partial function has the following nondeterministic options: it can either call
  the function again, or return any value of the target type (even a noncomputable one).
  Larger values of `C` yield less nondeterminism in the model, but even the intersection of
  all choices of `C` yields nondeterminism where `def loop : A := loop` returns any value of type `A`.
  The compiler fixes a choice for `C`. This is a fixed constant greater than 2^2^64,
  which is allowed to be compiler and architecture dependent, and promises that it will
  produce an execution consistent with every possible nondeterministic outcome of the `C`-model.
  In the event that different nondeterministic executions disagree, the compiler is required to
  exhaust resources or output a looping computation.
  -/
  safe : Bool := true
  /--
  We store the inline attribute at LCNF declarations to make sure we can set them for
  auxiliary declarations created during compilation.
  -/
  inlineAttr? : Option InlineAttributeKind
  deriving Inhabited, BEq
goal: Lean.Expr

full_name: Lean.Compiler.LCNF.Decl.inlineAttr?
code: /--
Declaration being processed by the Lean to Lean compiler passes.
-/
structure Decl where
  /--
  The name of the declaration from the `Environment` it came from
  -/
  name  : Name
  /--
  Universe level parameter names.
  -/
  levelParams : List Name
  /--
  The type of the declaration. Note that this is an erased LCNF type
  instead of the fully dependent one that might have been the original
  type of the declaration in the `Environment`.
  -/
  type  : Expr
  /--
  Parameters.
  -/
  params : Array Param
  /--
  The body of the declaration, usually changes as it progresses
  through compiler passes.
  -/
  value : Code
  /--
  We set this flag to true during LCNF conversion. When we receive
  a block of functions to be compiled, we set this flag to `true`
  if there is an application to the function in the block containing
  it. This is an approximation, but it should be good enough because
  in the frontend, we invoke the compiler with blocks of strongly connected
  components only.
  We use this information to control inlining.
  -/
  recursive : Bool := false
  /--
  We set this flag to false during LCNF conversion if the Lean function
  associated with this function was tagged as partial or unsafe. This
  information affects how static analyzers treat function applications
  of this kind. See `DefinitionSafety`.
  `partial` and `unsafe` functions may not be terminating, but Lean
  functions terminate, and some static analyzers exploit this
  fact. So, we use the following semantics. Suppose we have a (large) natural
  number `C`. We consider a nondeterministic model for computation of Lean expressions as
  follows:
  Each call to a partial/unsafe function uses up one "recursion token".
  Prior to consuming `C` recursion tokens all partial functions must be called
  as normal. Once the model has used up `C` recursion tokens, a subsequent call to
  a partial function has the following nondeterministic options: it can either call
  the function again, or return any value of the target type (even a noncomputable one).
  Larger values of `C` yield less nondeterminism in the model, but even the intersection of
  all choices of `C` yields nondeterminism where `def loop : A := loop` returns any value of type `A`.
  The compiler fixes a choice for `C`. This is a fixed constant greater than 2^2^64,
  which is allowed to be compiler and architecture dependent, and promises that it will
  produce an execution consistent with every possible nondeterministic outcome of the `C`-model.
  In the event that different nondeterministic executions disagree, the compiler is required to
  exhaust resources or output a looping computation.
  -/
  safe : Bool := true
  /--
  We store the inline attribute at LCNF declarations to make sure we can set them for
  auxiliary declarations created during compilation.
  -/
  inlineAttr? : Option InlineAttributeKind
  deriving Inhabited, BEq
goal: Option Lean.Compiler.InlineAttributeKind

full_name: Lean.Compiler.LCNF.instBEqDecl
code: /--
Declaration being processed by the Lean to Lean compiler passes.
-/
structure Decl where
  /--
  The name of the declaration from the `Environment` it came from
  -/
  name  : Name
  /--
  Universe level parameter names.
  -/
  levelParams : List Name
  /--
  The type of the declaration. Note that this is an erased LCNF type
  instead of the fully dependent one that might have been the original
  type of the declaration in the `Environment`.
  -/
  type  : Expr
  /--
  Parameters.
  -/
  params : Array Param
  /--
  The body of the declaration, usually changes as it progresses
  through compiler passes.
  -/
  value : Code
  /--
  We set this flag to true during LCNF conversion. When we receive
  a block of functions to be compiled, we set this flag to `true`
  if there is an application to the function in the block containing
  it. This is an approximation, but it should be good enough because
  in the frontend, we invoke the compiler with blocks of strongly connected
  components only.
  We use this information to control inlining.
  -/
  recursive : Bool := false
  /--
  We set this flag to false during LCNF conversion if the Lean function
  associated with this function was tagged as partial or unsafe. This
  information affects how static analyzers treat function applications
  of this kind. See `DefinitionSafety`.
  `partial` and `unsafe` functions may not be terminating, but Lean
  functions terminate, and some static analyzers exploit this
  fact. So, we use the following semantics. Suppose we have a (large) natural
  number `C`. We consider a nondeterministic model for computation of Lean expressions as
  follows:
  Each call to a partial/unsafe function uses up one "recursion token".
  Prior to consuming `C` recursion tokens all partial functions must be called
  as normal. Once the model has used up `C` recursion tokens, a subsequent call to
  a partial function has the following nondeterministic options: it can either call
  the function again, or return any value of the target type (even a noncomputable one).
  Larger values of `C` yield less nondeterminism in the model, but even the intersection of
  all choices of `C` yields nondeterminism where `def loop : A := loop` returns any value of type `A`.
  The compiler fixes a choice for `C`. This is a fixed constant greater than 2^2^64,
  which is allowed to be compiler and architecture dependent, and promises that it will
  produce an execution consistent with every possible nondeterministic outcome of the `C`-model.
  In the event that different nondeterministic executions disagree, the compiler is required to
  exhaust resources or output a looping computation.
  -/
  safe : Bool := true
  /--
  We store the inline attribute at LCNF declarations to make sure we can set them for
  auxiliary declarations created during compilation.
  -/
  inlineAttr? : Option InlineAttributeKind
  deriving Inhabited, BEq
goal: BEq Lean.Compiler.LCNF.Decl

full_name: Lean.Compiler.LCNF.Decl.name
code: /--
Declaration being processed by the Lean to Lean compiler passes.
-/
structure Decl where
  /--
  The name of the declaration from the `Environment` it came from
  -/
  name  : Name
  /--
  Universe level parameter names.
  -/
  levelParams : List Name
  /--
  The type of the declaration. Note that this is an erased LCNF type
  instead of the fully dependent one that might have been the original
  type of the declaration in the `Environment`.
  -/
  type  : Expr
  /--
  Parameters.
  -/
  params : Array Param
  /--
  The body of the declaration, usually changes as it progresses
  through compiler passes.
  -/
  value : Code
  /--
  We set this flag to true during LCNF conversion. When we receive
  a block of functions to be compiled, we set this flag to `true`
  if there is an application to the function in the block containing
  it. This is an approximation, but it should be good enough because
  in the frontend, we invoke the compiler with blocks of strongly connected
  components only.
  We use this information to control inlining.
  -/
  recursive : Bool := false
  /--
  We set this flag to false during LCNF conversion if the Lean function
  associated with this function was tagged as partial or unsafe. This
  information affects how static analyzers treat function applications
  of this kind. See `DefinitionSafety`.
  `partial` and `unsafe` functions may not be terminating, but Lean
  functions terminate, and some static analyzers exploit this
  fact. So, we use the following semantics. Suppose we have a (large) natural
  number `C`. We consider a nondeterministic model for computation of Lean expressions as
  follows:
  Each call to a partial/unsafe function uses up one "recursion token".
  Prior to consuming `C` recursion tokens all partial functions must be called
  as normal. Once the model has used up `C` recursion tokens, a subsequent call to
  a partial function has the following nondeterministic options: it can either call
  the function again, or return any value of the target type (even a noncomputable one).
  Larger values of `C` yield less nondeterminism in the model, but even the intersection of
  all choices of `C` yields nondeterminism where `def loop : A := loop` returns any value of type `A`.
  The compiler fixes a choice for `C`. This is a fixed constant greater than 2^2^64,
  which is allowed to be compiler and architecture dependent, and promises that it will
  produce an execution consistent with every possible nondeterministic outcome of the `C`-model.
  In the event that different nondeterministic executions disagree, the compiler is required to
  exhaust resources or output a looping computation.
  -/
  safe : Bool := true
  /--
  We store the inline attribute at LCNF declarations to make sure we can set them for
  auxiliary declarations created during compilation.
  -/
  inlineAttr? : Option InlineAttributeKind
  deriving Inhabited, BEq
goal: Lean.Name

full_name: Lean.Compiler.LCNF.Decl.size
code: def Decl.size (decl : Decl) : Nat 
goal: Nat

full_name: Lean.Compiler.LCNF.Decl.getArity
code: def Decl.getArity (decl : Decl) : Nat 
goal: Nat

full_name: Lean.Compiler.LCNF.Decl.inlineAttr
code: def Decl.inlineAttr (decl : Decl) : Bool 
goal: Bool

full_name: Lean.Compiler.LCNF.Decl.noinlineAttr
code: def Decl.noinlineAttr (decl : Decl) : Bool 
goal: Bool

full_name: Lean.Compiler.LCNF.Decl.inlineIfReduceAttr
code: def Decl.inlineIfReduceAttr (decl : Decl) : Bool 
goal: Bool

full_name: Lean.Compiler.LCNF.Decl.alwaysInlineAttr
code: def Decl.alwaysInlineAttr (decl : Decl) : Bool 
goal: Bool

full_name: Lean.Compiler.LCNF.Decl.inlineable
code: /-- Return `true` if the given declaration has been annotated with `[inline]`, `[inline_if_reduce]`, `[macro_inline]`, or `[always_inline]` -/
def Decl.inlineable (decl : Decl) : Bool 
goal: Bool

full_name: Lean.Compiler.LCNF.Decl.isCasesOnParam?.go
code: /--
Return `some i` if `decl` is of the form
```
def f (a_0 ... a_i ...) :=
  ...
  cases a_i
  | ...
  | ...
```
That is, `f` is a sequence of declarations followed by a `cases` on the parameter `i`.
We use this function to decide whether we should inline a declaration tagged with
`[inline_if_reduce]` or not.
-/
def Decl.isCasesOnParam? (decl : Decl) : Option Nat 
goal: Option Nat

full_name: Lean.Compiler.LCNF.Decl.isCasesOnParam?
code: /--
Return `some i` if `decl` is of the form
```
def f (a_0 ... a_i ...) :=
  ...
  cases a_i
  | ...
  | ...
```
That is, `f` is a sequence of declarations followed by a `cases` on the parameter `i`.
We use this function to decide whether we should inline a declaration tagged with
`[inline_if_reduce]` or not.
-/
def Decl.isCasesOnParam? (decl : Decl) : Option Nat 
goal: Option Nat

full_name: Lean.Compiler.LCNF.Decl.instantiateTypeLevelParams
code: def Decl.instantiateTypeLevelParams (decl : Decl) (us : List Level) : Expr 
goal: Lean.Expr

full_name: Lean.Compiler.LCNF.Decl.instantiateParamsLevelParams
code: def Decl.instantiateParamsLevelParams (decl : Decl) (us : List Level) : Array Param 
goal: Array Lean.Compiler.LCNF.Param

full_name: Lean.Compiler.LCNF.Decl.instantiateValueLevelParams
code: partial def Decl.instantiateValueLevelParams (decl : Decl) (us : List Level) : Code 
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Decl.instantiateValueLevelParams.instAlt
code: partial def Decl.instantiateValueLevelParams (decl : Decl) (us : List Level) : Code 
goal: Lean.Compiler.LCNF.AltCore Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Decl.instantiateValueLevelParams.instLevel
code: partial def Decl.instantiateValueLevelParams (decl : Decl) (us : List Level) : Code 
goal: Lean.Level

full_name: Lean.Compiler.LCNF.Decl.instantiateValueLevelParams.instExpr
code: partial def Decl.instantiateValueLevelParams (decl : Decl) (us : List Level) : Code 
goal: Lean.Expr

full_name: Lean.Compiler.LCNF.Decl.instantiateValueLevelParams.instCode
code: partial def Decl.instantiateValueLevelParams (decl : Decl) (us : List Level) : Code 
goal: Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.Decl.instantiateValueLevelParams.instLetValue
code: partial def Decl.instantiateValueLevelParams (decl : Decl) (us : List Level) : Code 
goal: Lean.Compiler.LCNF.LetValue

full_name: Lean.Compiler.LCNF.Decl.instantiateValueLevelParams.instFunDecl
code: partial def Decl.instantiateValueLevelParams (decl : Decl) (us : List Level) : Code 
goal: Lean.Compiler.LCNF.FunDecl → Lean.Compiler.LCNF.FunDecl

full_name: Lean.Compiler.LCNF.Decl.instantiateValueLevelParams.instLetDecl
code: partial def Decl.instantiateValueLevelParams (decl : Decl) (us : List Level) : Code 
goal: Lean.Compiler.LCNF.LetDecl → Lean.Compiler.LCNF.LetDecl

full_name: Lean.Compiler.LCNF.Decl.instantiateValueLevelParams.instParams
code: partial def Decl.instantiateValueLevelParams (decl : Decl) (us : List Level) : Code 
goal: Array Lean.Compiler.LCNF.Param

full_name: Lean.Compiler.LCNF.Decl.instantiateValueLevelParams.instArg
code: partial def Decl.instantiateValueLevelParams (decl : Decl) (us : List Level) : Code 
goal: Lean.Compiler.LCNF.Arg

full_name: Lean.Compiler.LCNF.hasLocalInst
code: /--
Return `true` if the arrow type contains an instance implicit argument.
-/
def hasLocalInst (type : Expr) : Bool 
goal: Bool

full_name: Lean.Compiler.LCNF.Decl.isTemplateLike
code: /--
Return `true` if `decl` is supposed to be inlined/specialized.
-/
def Decl.isTemplateLike (decl : Decl) : CoreM Bool 
goal: Lean.CoreM Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.collectType
code: private partial def collectType (e : Expr) : FVarIdSet → FVarIdSet 
goal: Lean.FVarIdSet → Lean.FVarIdSet

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.collectArg
code: private def collectArg (arg : Arg) (s : FVarIdSet) : FVarIdSet 
goal: Lean.FVarIdSet

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.collectArgs
code: private def collectArgs (args : Array Arg) (s : FVarIdSet) : FVarIdSet 
goal: Lean.FVarIdSet

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.collectLetValue
code: private def collectLetValue (e : LetValue) (s : FVarIdSet) : FVarIdSet 
goal: Lean.FVarIdSet

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.collectParams
code: private partial def collectParams (ps : Array Param) (s : FVarIdSet) : FVarIdSet 
goal: Lean.FVarIdSet

full_name: Lean.Compiler.LCNF.collectUsedAtExpr
code: abbrev collectUsedAtExpr (s : FVarIdSet) (e : Expr) : FVarIdSet 
goal: Lean.FVarIdSet

full_name: Lean.Compiler.LCNF.markRecDecls.visit
code: /--
Traverse the given block of potentially mutually recursive functions
and mark a declaration `f` as recursive if there is an application
`f ...` in the block.
This is an overapproximation, and relies on the fact that our frontend
computes strongly connected components.
See comment at `recursive` field.
-/
partial def markRecDecls (decls : Array Decl) : Array Decl 
goal: StateM Lean.NameSet Unit

full_name: Lean.Compiler.LCNF.markRecDecls
code: /--
Traverse the given block of potentially mutually recursive functions
and mark a declaration `f` as recursive if there is an application
`f ...` in the block.
This is an overapproximation, and relies on the fact that our frontend
computes strongly connected components.
See comment at `recursive` field.
-/
partial def markRecDecls (decls : Array Decl) : Array Decl 
goal: Array Lean.Compiler.LCNF.Decl

full_name: Lean.Compiler.LCNF.markRecDecls.go
code: /--
Traverse the given block of potentially mutually recursive functions
and mark a declaration `f` as recursive if there is an application
`f ...` in the block.
This is an overapproximation, and relies on the fact that our frontend
computes strongly connected components.
See comment at `recursive` field.
-/
partial def markRecDecls (decls : Array Decl) : Array Decl 
goal: StateM Lean.NameSet Unit

full_name: Lean.Compiler.LCNF.instantiateRangeArgs
code: def instantiateRangeArgs (e : Expr) (beginIdx endIdx : Nat) (args : Array Arg) : Expr 
goal: Lean.Expr

full_name: Lean.Compiler.LCNF.instantiateRevRangeArgs
code: def instantiateRevRangeArgs (e : Expr) (beginIdx endIdx : Nat) (args : Array Arg) : Expr 
goal: Lean.Expr