def Lean.Expr.instantiateBetaRevRange (e : Lean.Expr) (start : Nat) (stop : Nat) (args : Array Lean.Expr) : Lean.Expr

Auxiliary function for instantiating the loose bound variables in e with args[start:stop]. This function is similar to instantiateRevRange, but it applies beta-reduction when we instantiate a bound variable with a lambda expression. Example: Given the term #0 a, and start := 0, stop := 1, args := #[fun x => x] the result is a instead of (fun x => x) a. This reduction is useful when we are inferring the type of eliminator-like applications. For example, given (n m : Nat) (f : Nat → Nat) (h : m = n), the type of Eq.subst (motive := fun x => f m = f x) h rfl is motive n which is (fun (x : Nat) => f m = f x) n This function reduces the new application to f m = f n

We use it to implement inferAppType

Equations

• One or more equations did not get rendered due to their size.

partial def Lean.Expr.instantiateBetaRevRange.visit (start : Nat) (stop : Nat) (args : Array Lean.Expr) (e : Lean.Expr) (offset : Nat) : Lean.MonadStateCacheT (Lean.ExprStructEq × Nat) Lean.Expr Id Lean.Expr

def Lean.Meta.throwFunctionExpected {α : Type} (f : Lean.Expr) : Lean.MetaM α

Equations

• Lean.Meta.throwFunctionExpected f = Lean.throwError (Lean.toMessageData "function expected" ++ Lean.toMessageData (Lean.indentExpr f) ++ Lean.toMessageData "")

def Lean.Meta.throwIncorrectNumberOfLevels {α : Type} (constName : Lake.Name) (us : List Lean.Level) : Lean.MetaM α

Equations

• One or more equations did not get rendered due to their size.

def Lean.Meta.throwTypeExcepted {α : Type} (type : Lean.Expr) : Lean.MetaM α

Equations

• Lean.Meta.throwTypeExcepted type = Lean.throwError (Lean.toMessageData "type expected" ++ Lean.toMessageData (Lean.indentExpr type) ++ Lean.toMessageData "")

def Lean.Meta.getLevel (type : Lean.Expr) : Lean.MetaM Lean.Level

Equations

• One or more equations did not get rendered due to their size.

def Lean.Meta.throwUnknownMVar {α : Type} (mvarId : Lean.MVarId) : Lean.MetaM α

Equations

• Lean.Meta.throwUnknownMVar mvarId = Lean.throwError (Lean.toMessageData "unknown metavariable '?" ++ Lean.toMessageData mvarId.name ++ Lean.toMessageData "'")

@[export lean_infer_type]

def Lean.Meta.inferTypeImp (e : Lean.Expr) : Lean.MetaM Lean.Expr

Equations

• Lean.Meta.inferTypeImp e = Lean.withIncRecDepth (Lean.Meta.withTransparency Lean.Meta.TransparencyMode.default (Lean.Meta.inferTypeImp.infer e))

def Lean.Meta.inferTypeImp.infer (e : Lean.Expr) : Lean.MetaM Lean.Expr

Equations

• One or more equations did not get rendered due to their size.
• Lean.Meta.inferTypeImp.infer (Lean.Expr.const c []) = Lean.Meta.inferConstType c []
• Lean.Meta.inferTypeImp.infer (Lean.Expr.const c us) = Lean.Meta.checkInferTypeCache (Lean.Expr.const c us) (Lean.Meta.inferConstType c us)
• Lean.Meta.inferTypeImp.infer (Lean.Expr.proj n i s) = Lean.Meta.checkInferTypeCache (Lean.Expr.proj n i s) (Lean.Meta.inferProjType n i s)
• Lean.Meta.inferTypeImp.infer (Lean.Expr.mvar mvarId) = Lean.Meta.inferMVarType mvarId
• Lean.Meta.inferTypeImp.infer (Lean.Expr.fvar fvarId) = Lean.Meta.inferFVarType fvarId
• Lean.Meta.inferTypeImp.infer (Lean.Expr.mdata data e_2) = Lean.Meta.inferTypeImp.infer e_2
• Lean.Meta.inferTypeImp.infer (Lean.Expr.lit v) = pure (Lean.Literal.type v)
• Lean.Meta.inferTypeImp.infer (Lean.Expr.sort lvl) = pure (Lean.mkSort (Lean.mkLevelSucc lvl))

partial def Lean.Meta.isPropQuick : Lean.Expr → Lean.MetaM Lean.LBool

isPropQuick e is an "approximate" predicate which returns LBool.true if e is a proposition.

def Lean.Meta.isProp (e : Lean.Expr) : Lean.MetaM Bool

isProp whnf e return true if e is a proposition.

If e contains metavariables, it may not be possible to decide whether is a proposition or not. We return false in this case. We considered using LBool and retuning LBool.undef, but we have no applications for it.

Equations

• One or more equations did not get rendered due to their size.

partial def Lean.Meta.isProofQuick : Lean.Expr → Lean.MetaM Lean.LBool

isProofQuick e is an "approximate" predicate which returns LBool.true if e is a proof.

def Lean.Meta.isProof (e : Lean.Expr) : Lean.MetaM Bool

Equations

• One or more equations did not get rendered due to their size.

partial def Lean.Meta.isTypeQuick : Lean.Expr → Lean.MetaM Lean.LBool

isTypeQuick e is an "approximate" predicate which returns LBool.true if e is a type.

def Lean.Meta.isType (e : Lean.Expr) : Lean.MetaM Bool

Return true iff the type of e is a Sort _.

Equations

• One or more equations did not get rendered due to their size.

def Lean.Meta.isTypeFormerTypeQuick : Lean.Expr → Bool

Equations

• Lean.Meta.isTypeFormerTypeQuick (Lean.Expr.forallE binderName binderType b binderInfo) = Lean.Meta.isTypeFormerTypeQuick b
• Lean.Meta.isTypeFormerTypeQuick (Lean.Expr.sort u) = true
• Lean.Meta.isTypeFormerTypeQuick x = false

def Lean.Meta.isTypeFormerType (type : Lean.Expr) : Lean.MetaM Bool

Return true iff type is Sort _ or As → Sort _.

Equations

• Lean.Meta.isTypeFormerType type = match Lean.Meta.isTypeFormerTypeQuick type with | true => pure true | false => Lean.Meta.savingCache (Lean.Meta.isTypeFormerType.go type #[])

partial def Lean.Meta.isTypeFormerType.go (type : Lean.Expr) (xs : Array Lean.Expr) : Lean.MetaM Bool

def Lean.Meta.isTypeFormer (e : Lean.Expr) : Lean.MetaM Bool

Return true iff e : Sort _ or e : (forall As, Sort _). Remark: it subsumes isType

Equations

• Lean.Meta.isTypeFormer e = do let __do_lift ← Lean.Meta.inferType e Lean.Meta.isTypeFormerType __do_lift