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

Returns id e

def Lean.Meta.mkExpectedTypeHintCore (e expectedType : Expr) (expectedTypeUniv : Level) : Expr

def Lean.Meta.mkExpectedPropHint (proof expectedProp : Expr) : Expr

Given proof s.t. inferType proof is definitionally equal to expectedProp, returns term @id expectedProp proof.

def Lean.Meta.mkExpectedTypeHint (e expectedType : Expr) : MetaM Expr

Given e s.t. inferType e is definitionally equal to expectedType, returns term @id expectedType e.

def Lean.Meta.mkLetFun (x v e : Expr) : MetaM Expr

mkLetFun x v e creates the encoding for the let_fun x := v; e expression. The expression x can either be a free variable or a metavariable, and the function suitably abstracts x in e.

def Lean.Meta.mkEq (a b : Expr) : MetaM Expr

Returns a = b.

def Lean.Meta.mkHEq (a b : Expr) : MetaM Expr

Returns HEq a b.

def Lean.Meta.mkEqHEq (a b : Expr) : MetaM Expr

If a and b have definitionally equal types, returns Eq a b, otherwise returns HEq a b.

def Lean.Meta.mkEqRefl (a : Expr) : MetaM Expr

Returns a proof of a = a.

def Lean.Meta.mkHEqRefl (a : Expr) : MetaM Expr

Returns a proof of HEq a a.

def Lean.Meta.mkAbsurd (e hp hnp : Expr) : MetaM Expr

Given hp : P and nhp : Not P, returns an instance of type e.

def Lean.Meta.mkFalseElim (e h : Expr) : MetaM Expr

Given h : False, returns an instance of type e.

def Lean.Meta.mkEqSymm (h : Expr) : MetaM Expr

Given h : a = b, returns a proof of b = a.

def Lean.Meta.mkEqTrans (h₁ h₂ : Expr) : MetaM Expr

Given h₁ : a = b and h₂ : b = c, returns a proof of a = c.

def Lean.Meta.mkEqTrans? (h₁? h₂? : Option Expr) : MetaM (Option Expr)

Similar to mkEqTrans, but arguments can be none. none is treated as a reflexivity proof.

def Lean.Meta.mkHEqSymm (h : Expr) : MetaM Expr

Given h : HEq a b, returns a proof of HEq b a.

def Lean.Meta.mkHEqTrans (h₁ h₂ : Expr) : MetaM Expr

Given h₁ : HEq a b, h₂ : HEq b c, returns a proof of HEq a c.

def Lean.Meta.mkEqOfHEq (h : Expr) (check : Bool := true) : MetaM Expr

Given h : HEq a b where a and b have the same type, returns a proof of Eq a b.

def Lean.Meta.mkHEqOfEq (h : Expr) : MetaM Expr

Given h : Eq a b, returns a proof of HEq a b.

def Lean.Meta.isRefl? (e : Expr) : Option Expr

If e is @Eq.refl α a, returns a.

def Lean.Meta.congrArg? (e : Expr) : MetaM (Option (Expr × Expr × Expr))

If e is @congrArg α β a b f h, returns α, f and h. Also works if e can be turned into such an application (e.g. congrFun).

partial def Lean.Meta.mkCongrArg (f h : Expr) : MetaM Expr

Given f : α → β and h : a = b, returns a proof of f a = f b.

def Lean.Meta.mkCongrFun (h a : Expr) : MetaM Expr

Given h : f = g and a : α, returns a proof of f a = g a.

def Lean.Meta.mkCongr (h₁ h₂ : Expr) : MetaM Expr

Given h₁ : f = g and h₂ : a = b, returns a proof of f a = g b.

def Lean.Meta.mkAppM (constName : Name) (xs : Array Expr) : MetaM Expr

Returns the application constName xs. It tries to fill the implicit arguments before the last element in xs.

Remark: mkAppM `arbitrary #[α] returns @arbitrary.{u} α without synthesizing the implicit argument occurring after α. Given a x : ([Decidable p] → Bool) × Nat, mkAppM `Prod.fst #[x], returns @Prod.fst ([Decidable p] → Bool) Nat x.

def Lean.Meta.mkAppM' (f : Expr) (xs : Array Expr) : MetaM Expr

Similar to mkAppM, but takes an Expr instead of a constant name.

def Lean.Meta.mkAppOptM (constName : Name) (xs : Array (Option Expr)) : MetaM Expr

Similar to mkAppM, but it allows us to specify which arguments are provided explicitly using Option type. Example: Given Pure.pure {m : Type u → Type v} [Pure m] {α : Type u} (a : α) : m α,

mkAppOptM `Pure.pure #[m, none, none, a]

returns a Pure.pure application if the instance Pure m can be synthesized, and the universe match. Note that,

mkAppM `Pure.pure #[a]

fails because the only explicit argument (a : α) is not sufficient for inferring the remaining arguments, we would need the expected type.

def Lean.Meta.mkAppOptM' (f : Expr) (xs : Array (Option Expr)) : MetaM Expr

Similar to mkAppOptM, but takes an Expr instead of a constant name.

def Lean.Meta.mkEqNDRec (motive h1 h2 : Expr) : MetaM Expr

def Lean.Meta.mkEqRec (motive h1 h2 : Expr) : MetaM Expr

def Lean.Meta.mkEqMP (eqProof pr : Expr) : MetaM Expr

def Lean.Meta.mkEqMPR (eqProof pr : Expr) : MetaM Expr

def Lean.Meta.mkNoConfusion (target h : Expr) : MetaM Expr

def Lean.Meta.mkPure (monad e : Expr) : MetaM Expr

Given a monad and e : α, makes pure e.

partial def Lean.Meta.mkProjection (s : Expr) (fieldName : Name) : MetaM Expr

mkProjection s fieldName returns an expression for accessing field fieldName of the structure s. Remark: fieldName may be a subfield of s.

def Lean.Meta.mkListLit (type : Expr) (xs : List Expr) : MetaM Expr

def Lean.Meta.mkArrayLit (type : Expr) (xs : List Expr) : MetaM Expr

def Lean.Meta.mkNone (type : Expr) : MetaM Expr

def Lean.Meta.mkSome (type value : Expr) : MetaM Expr

def Lean.Meta.mkDecide (p : Expr) : MetaM Expr

Returns Decidable.decide p

def Lean.Meta.mkDecideProof (p : Expr) : MetaM Expr

Returns a proof for p : Prop using decide p

def Lean.Meta.mkLt (a b : Expr) : MetaM Expr

Returns a < b

def Lean.Meta.mkLe (a b : Expr) : MetaM Expr

Returns a <= b

def Lean.Meta.mkDefault (α : Expr) : MetaM Expr

Returns Inhabited.default α

def Lean.Meta.mkOfNonempty (α : Expr) : MetaM Expr

Returns @Classical.ofNonempty α _

def Lean.Meta.mkFunExt (h : Expr) : MetaM Expr

Returns funext h

def Lean.Meta.mkPropExt (h : Expr) : MetaM Expr

Returns propext h

def Lean.Meta.mkLetCongr (h₁ h₂ : Expr) : MetaM Expr

Returns let_congr h₁ h₂

def Lean.Meta.mkLetValCongr (b h : Expr) : MetaM Expr

Returns let_val_congr b h

def Lean.Meta.mkLetBodyCongr (a h : Expr) : MetaM Expr

Returns let_body_congr a h

def Lean.Meta.mkOfEqFalseCore (p h : Expr) : Expr

Returns @of_eq_false p h

def Lean.Meta.mkOfEqFalse (h : Expr) : MetaM Expr

Returns of_eq_false h

def Lean.Meta.mkOfEqTrueCore (p h : Expr) : Expr

Returns @of_eq_true p h

def Lean.Meta.mkOfEqTrue (h : Expr) : MetaM Expr

Returns of_eq_true h

def Lean.Meta.mkEqTrueCore (p h : Expr) : Expr

Returns eq_true h

def Lean.Meta.mkEqTrue (h : Expr) : MetaM Expr

Returns eq_true h

def Lean.Meta.mkEqFalse (h : Expr) : MetaM Expr

Returns eq_false h h must have type definitionally equal to ¬ p in the current reducibility setting.

def Lean.Meta.mkEqFalse' (h : Expr) : MetaM Expr

Returns eq_false' h h must have type definitionally equal to p → False in the current reducibility setting.

def Lean.Meta.mkImpCongr (h₁ h₂ : Expr) : MetaM Expr

def Lean.Meta.mkImpCongrCtx (h₁ h₂ : Expr) : MetaM Expr

def Lean.Meta.mkImpDepCongrCtx (h₁ h₂ : Expr) : MetaM Expr

def Lean.Meta.mkForallCongr (h : Expr) : MetaM Expr

def Lean.Meta.isMonad? (m : Expr) : MetaM (Option Expr)

Returns instance for [Monad m] if there is one

def Lean.Meta.mkNumeral (type : Expr) (n : Nat) : MetaM Expr

Returns (n : type), a numeric literal of type type. The method fails if we don't have an instance OfNat type n

def Lean.Meta.mkAdd (a b : Expr) : MetaM Expr

Returns a + b using a heterogeneous +. This method assumes a and b have the same type.

def Lean.Meta.mkSub (a b : Expr) : MetaM Expr

Returns a - b using a heterogeneous -. This method assumes a and b have the same type.

def Lean.Meta.mkMul (a b : Expr) : MetaM Expr

Returns a * b using a heterogeneous *. This method assumes a and b have the same type.

def Lean.Meta.mkLE (a b : Expr) : MetaM Expr

Returns a ≤ b. This method assumes a and b have the same type.

def Lean.Meta.mkLT (a b : Expr) : MetaM Expr

Returns a < b. This method assumes a and b have the same type.

def Lean.Meta.mkIffOfEq (h : Expr) : MetaM Expr

Given h : a = b, returns a proof for a ↔ b.