def Lean.Parser.Command.commentBody : Lean.Parser.Parser

Equations

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

def Lean.Parser.Command.commentBody.parenthesizer : Lean.PrettyPrinter.Parenthesizer

def Lean.Parser.Command.commentBody.formatter : Lean.PrettyPrinter.Formatter

Equations

• Lean.Parser.Command.commentBody.formatter = Lean.PrettyPrinter.Formatter.visitAtom Lean.Name.anonymous

def Lean.Parser.Command.docComment : Lean.Parser.Parser

A docComment parses a "documentation comment" like /-- foo -/. This is not treated like a regular comment (that is, as whitespace); it is parsed and forms part of the syntax tree structure.

A docComment node contains a /-- atom and then the remainder of the comment, foo -/ in this example. Use TSyntax.getDocString to extract the body text from a doc string syntax node.

Equations

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

@[inline]

def Lean.Parser.tacticParser (rbp : Nat := 0) : Lean.Parser.Parser

Equations

• Lean.Parser.tacticParser rbp = Lean.Parser.categoryParser `tactic rbp

@[inline]

def Lean.Parser.convParser (rbp : Nat := 0) : Lean.Parser.Parser

def Lean.Parser.Tactic.sepByIndentSemicolon (p : Lean.Parser.Parser) : Lean.Parser.Parser

sepByIndentSemicolon(p) parses a sequence of p optionally followed by ;, similar to manyIndent(p ";"?), except that if two occurrences of p occur on the same line, the ; is mandatory. This is used by tactic parsing, so that

example := by
  skip
  skip

is legal, but by skip skip is not - it must be written as by skip; skip.

Equations

• Lean.Parser.Tactic.sepByIndentSemicolon p = Lean.Parser.sepByIndent p "; " (Lean.Parser.symbol "; ") true

def Lean.Parser.Tactic.sepBy1IndentSemicolon (p : Lean.Parser.Parser) : Lean.Parser.Parser

sepBy1IndentSemicolon(p) parses a (nonempty) sequence of p optionally followed by ;, similar to many1Indent(p ";"?), except that if two occurrences of p occur on the same line, the ; is mandatory. This is used by tactic parsing, so that

example := by
  skip
  skip

is legal, but by skip skip is not - it must be written as by skip; skip.

Equations

• Lean.Parser.Tactic.sepBy1IndentSemicolon p = Lean.Parser.sepBy1Indent p "; " (Lean.Parser.symbol "; ") true

def Lean.Parser.Tactic.tacticSeq1Indented : Lean.Parser.Parser

Equations

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

def Lean.Parser.Tactic.tacticSeqBracketed : Lean.Parser.Parser

The syntax { tacs } is an alternative syntax for · tacs. It runs the tactics in sequence, and fails if the goal is not solved.

def Lean.Parser.Tactic.tacticSeq : Lean.Parser.Parser

A sequence of tactics in brackets, or a delimiter-free indented sequence of tactics. Delimiter-free indentation is determined by the first tactic of the sequence.

Equations

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

def Lean.Parser.Tactic.tacticSeqIndentGt : Lean.Parser.Parser

Same as [tacticSeq] but requires delimiter-free tactic sequence to have strict indentation. The strict indentation requirement only apply to nested bys, as top-level bys do not have a position set.

def Lean.Parser.Tactic.seq1 : Lean.Parser.Parser

def Lean.Parser.darrow : Lean.Parser.Parser

def Lean.Parser.semicolonOrLinebreak : Lean.Parser.Parser

Built-in parsers

def Lean.Parser.Term.byTactic : Lean.Parser.Parser

by tac constructs a term of the expected type by running the tactic(s) tac.

def Lean.Parser.Term.byTactic' : Lean.Parser.Parser

def Lean.Parser.Term.optSemicolon (p : Lean.Parser.Parser) : Lean.Parser.Parser

Equations

• Lean.Parser.Term.optSemicolon p = Lean.Parser.ppDedent (Lean.Parser.semicolonOrLinebreak >> Lean.Parser.ppLine >> p)

def Lean.Parser.Term.ident : Lean.Parser.Parser

Equations

• Lean.Parser.Term.ident = Lean.Parser.checkPrec Lean.Parser.maxPrec >> Lean.Parser.ident

def Lean.Parser.Term.num : Lean.Parser.Parser

def Lean.Parser.Term.scientific : Lean.Parser.Parser

Equations

• Lean.Parser.Term.scientific = Lean.Parser.checkPrec Lean.Parser.maxPrec >> Lean.Parser.scientificLit

def Lean.Parser.Term.str : Lean.Parser.Parser

def Lean.Parser.Term.char : Lean.Parser.Parser

def Lean.Parser.Term.type : Lean.Parser.Parser

A type universe. Type ≡ Type 0, Type u ≡ Sort (u + 1).

Equations

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

def Lean.Parser.Term.sort : Lean.Parser.Parser

A specific universe in Lean's infinite hierarchy of universes.

def Lean.Parser.Term.prop : Lean.Parser.Parser

The universe of propositions. Prop ≡ Sort 0.

def Lean.Parser.Term.hole : Lean.Parser.Parser

A hole (or placeholder term), which stands for an unknown term that is expected to be inferred based on context. For example, in @id _ Nat.zero, the _ must be the type of Nat.zero, which is Nat.

The way this works is that holes create fresh metavariables. The elaborator is allowed to assign terms to metavariables while it is checking definitional equalities. This is often known as unification.

Normally, all holes must be solved for. However, there are a few contexts where this is not necessary:

• In match patterns, holes are catch-all patterns.
• In some tactics, such as refine' and apply, unsolved-for placeholders become new goals.

Related concept: implicit parameters are automatically filled in with holes during the elaboration process.

See also ?m syntax (synthetic holes).

Equations

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

def Lean.Parser.Term.syntheticHole : Lean.Parser.Parser

A synthetic hole (or synthetic placeholder), which stands for an unknown term that should be synthesized using tactics.

• ?_ creates a fresh metavariable with an auto-generated name.
• ?m either refers to a pre-existing metavariable named m or creates a fresh metavariable with that name.

In particular, the synthetic hole syntax creates "synthetic opaque metavariables", the same kind of metavariable used to represent goals in the tactic state.

Synthetic holes are similar to holes in that _ also creates metavariables, but synthetic opaque metavariables have some different properties:

• In tactics such as refine, only synthetic holes yield new goals.
• During elaboration, unification will not solve for synthetic opaque metavariables, they are "opaque". This is to prevent counterintuitive behavior such as disappearing goals.
• When synthetic holes appear under binders, they capture local variables using a more complicated mechanism known as delayed assignment.

Delayed assigned metavariables

This section gives an overview of some technical details of synthetic holes, which you should feel free to skip. Understanding delayed assignments is mainly useful for those who are working on tactics and other metaprogramming. It is included here until there is a suitable place for it in the reference manual.

When a synthetic hole appears under a binding construct, such as for example fun (x : α) (y : β) => ?s, the system creates a delayed assignment. This consists of

1. A metavariable ?m of type (x : α) → (y : β) → γ x y whose local context is the local context outside the fun, where γ x y is the type of ?s. Recall that x and y appear in the local context of ?s.
2. A delayed assigment record associating ?m to ?s and the variables #[x, y] in the local context of ?s

Then, this function elaborates as fun (x : α) (y : β) => ?m x y, where one should understand x and y here as being De Bruijn indexes, since Lean uses the locally nameless encoding of lambda calculus.

Once ?s is fully solved for, in the sense that after metavariable instantiation it is a metavariable-free term e, then we can make the assignment ?m := fun (x' : α) (y' : β) => e[x := x', y := y']. (Implementation note: Lean only instantiates full applications ?m x' y' of delayed assigned metavariables, to skip forming this function.) This delayed assignment mechanism is essential to the operation of basic tactics like intro, and a good mental model is that it is a way to "apply" the metavariable ?s by substituting values in for some of its local variables. While it would be easier to immediately assign ?s := ?m x y, delayed assigment preserves ?s as an unsolved-for metavariable with a local context that still contains x and y, which is exactly what tactics like intro need.

By default, delayed assigned metavariables pretty print with what they are delayed assigned to. The delayed assigned metavariables themselves can be pretty printed using set_option pp.mvars.delayed true.

For more information, see the "Gruesome details" module docstrings in Lean.MetavarContext.

Equations

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

def Lean.Parser.Term.omission : Lean.Parser.Parser

The ⋯ term denotes a term that was omitted by the pretty printer. The presence of ⋯ in pretty printer output is controlled by the pp.deepTerms and pp.proofs options, and these options can be further adjusted using pp.deepTerms.threshold and pp.proofs.threshold.

It is only meant to be used for pretty printing. However, in case it is copied and pasted from the Infoview, ⋯ logs a warning and elaborates like _.

Equations

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

def Lean.Parser.Term.binderIdent : Lean.Parser.Parser

Equations

• Lean.Parser.Term.binderIdent = (Lean.Parser.Term.ident <|> Lean.Parser.Term.hole)

def Lean.Parser.Term.sorry : Lean.Parser.Parser

A temporary placeholder for a missing proof or value.

def Lean.Parser.Term.cdot : Lean.Parser.Parser

A placeholder for an implicit lambda abstraction's variable. The lambda abstraction is scoped to the surrounding parentheses. For example, (· + ·) is equivalent to fun x y => x + y.

Equations

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

def Lean.Parser.Term.typeAscription : Lean.Parser.Parser

Type ascription notation: (0 : Int) instructs Lean to process 0 as a value of type Int. An empty type ascription (e :) elaborates e without the expected type. This is occasionally useful when Lean's heuristics for filling arguments from the expected type do not yield the right result.

def Lean.Parser.Term.tuple : Lean.Parser.Parser

Tuple notation; () is short for Unit.unit, (a, b, c) for Prod.mk a (Prod.mk b c), etc.

def Lean.Parser.Term.paren : Lean.Parser.Parser

Parentheses, used for grouping expressions (e.g., a * (b + c)). Can also be used for creating simple functions when combined with ·. Here are some examples:

• (· + 1) is shorthand for fun x => x + 1
• (· + ·) is shorthand for fun x y => x + y
• (f · a b) is shorthand for fun x => f x a b
• (h (· + 1) ·) is shorthand for fun x => h (fun y => y + 1) x
• also applies to other parentheses-like notations such as (·, 1)

Equations

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

def Lean.Parser.Term.anonymousCtor : Lean.Parser.Parser

The anonymous constructor ⟨e, ...⟩ is equivalent to c e ... if the expected type is an inductive type with a single constructor c. If more terms are given than c has parameters, the remaining arguments are turned into a new anonymous constructor application. For example, ⟨a, b, c⟩ : α × (β × γ) is equivalent to ⟨a, ⟨b, c⟩⟩.

Equations

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

def Lean.Parser.Term.optIdent : Lean.Parser.Parser

def Lean.Parser.Term.fromTerm : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.showRhs : Lean.Parser.Parser

Equations

• Lean.Parser.Term.showRhs = (Lean.Parser.Term.fromTerm <|> Lean.Parser.Term.byTactic')

def Lean.Parser.Term.sufficesDecl : Lean.Parser.Parser

A sufficesDecl represents everything that comes after the suffices keyword: an optional x :, then a term ty, then from val or by tac.

Equations

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

def Lean.Parser.Term.suffices : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.show : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.typeSpec : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.optType : Lean.Parser.Parser

def Lean.Parser.Term.explicit : Lean.Parser.Parser

@x disables automatic insertion of implicit parameters of the constant x. @e for any term e also disables the insertion of implicit lambdas at this position.

Equations

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

def Lean.Parser.Term.inaccessible : Lean.Parser.Parser

.(e) marks an "inaccessible pattern", which does not influence evaluation of the pattern match, but may be necessary for type-checking. In contrast to regular patterns, e may be an arbitrary term of the appropriate type.

Equations

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

def Lean.Parser.Term.binderType (requireType : Bool := false) : Lean.Parser.Parser

def Lean.Parser.Term.binderTactic : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.binderDefault : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.binderDefault.parenthesizer : Lean.PrettyPrinter.Parenthesizer

Equations

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

def Lean.Parser.Term.explicitBinder (requireType : Bool := false) : Lean.Parser.Parser

Explicit binder, like (x y : A) or (x y). Default values can be specified using (x : A := v) syntax, and tactics using (x : A := by tac).

def Lean.Parser.Term.implicitBinder (requireType : Bool := false) : Lean.Parser.Parser

Implicit binder, like {x y : A} or {x y}. In regular applications, whenever all parameters before it have been specified, then a _ placeholder is automatically inserted for this parameter. Implicit parameters should be able to be determined from the other arguments and the return type by unification.

In @ explicit mode, implicit binders behave like explicit binders.

def Lean.Parser.Term.strictImplicitLeftBracket : Lean.Parser.Parser

Equations

• Lean.Parser.Term.strictImplicitLeftBracket = (Lean.Parser.atomic (Lean.Parser.group (Lean.Parser.symbol "{" >> Lean.Parser.symbol "{")) <|> Lean.Parser.symbol "⦃")

def Lean.Parser.Term.strictImplicitRightBracket : Lean.Parser.Parser

Equations

• Lean.Parser.Term.strictImplicitRightBracket = (Lean.Parser.atomic (Lean.Parser.group (Lean.Parser.symbol "}" >> Lean.Parser.symbol "}")) <|> Lean.Parser.symbol "⦄")

def Lean.Parser.Term.strictImplicitBinder (requireType : Bool := false) : Lean.Parser.Parser

Strict-implicit binder, like ⦃x y : A⦄ or ⦃x y⦄. In contrast to { ... } implicit binders, strict-implicit binders do not automatically insert a _ placeholder until at least one subsequent explicit parameter is specified. Do not use strict-implicit binders unless there is a subsequent explicit parameter. Assuming this rule is followed, for fully applied expressions implicit and strict-implicit binders have the same behavior.

Example: If h : ∀ ⦃x : A⦄, x ∈ s → p x and hs : y ∈ s, then h by itself elaborates to itself without inserting _ for the x : A parameter, and h hs has type p y. In contrast, if h' : ∀ {x : A}, x ∈ s → p x, then h by itself elaborates to have type ?m ∈ s → p ?m with ?m a fresh metavariable.

def Lean.Parser.Term.instBinder : Lean.Parser.Parser

Instance-implicit binder, like [C] or [inst : C]. In regular applications without @ explicit mode, it is automatically inserted and solved for by typeclass inference for the specified class C. In @ explicit mode, if _ is used for an instance-implicit parameter, then it is still solved for by typeclass inference; use (_) to inhibit this and have it be solved for by unification instead, like an implicit argument.

Equations

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

def Lean.Parser.Term.bracketedBinder (requireType : Bool := false) : Lean.Parser.Parser

A bracketedBinder matches any kind of binder group that uses some kind of brackets:

• An explicit binder like (x y : A)
• An implicit binder like {x y : A}
• A strict implicit binder, ⦃y z : A⦄ or its ASCII alternative {{y z : A}}
• An instance binder [A] or [x : A] (multiple variables are not allowed here)

Equations

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

def Lean.Parser.Term.depArrow : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.forall : Lean.Parser.Parser

def Lean.Parser.Term.matchAlt (rhsParser : Lean.Parser.Parser := Lean.Parser.termParser) : Lean.Parser.Parser

def Lean.Parser.Term.matchAltExpr : Lean.Parser.Parser

Useful for syntax quotations. Note that generic patterns such as `(matchAltExpr| | ... => $rhs) should also work with other rhsParsers (of arity 1).

Equations

• Lean.Parser.Term.matchAltExpr = Lean.Parser.Term.matchAlt

instance Lean.Parser.Term.instCoeTSyntaxConsSyntaxNodeKindMkStr4Nil_lean : Coe (Lean.TSyntax `Lean.Parser.Term.matchAltExpr) (Lean.TSyntax `Lean.Parser.Term.matchAlt)

Equations

• Lean.Parser.Term.instCoeTSyntaxConsSyntaxNodeKindMkStr4Nil_lean = { coe := fun (stx : Lean.TSyntax `Lean.Parser.Term.matchAltExpr) => { raw := stx.raw } }

def Lean.Parser.Term.matchAlts (rhsParser : Lean.Parser.Parser := Lean.Parser.termParser) : Lean.Parser.Parser

def Lean.Parser.Term.matchDiscr : Lean.Parser.Parser

matchDiscr matches a "match discriminant", either h : tm or tm, used in match as match h1 : e1, e2, h3 : e3 with ....

def Lean.Parser.Term.trueVal : Lean.Parser.Parser

def Lean.Parser.Term.falseVal : Lean.Parser.Parser

def Lean.Parser.Term.generalizingParam : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.motive : Lean.Parser.Parser

def Lean.Parser.Term.match : Lean.Parser.Parser

Pattern matching. match e, ... with | p, ... => f | ... matches each given term e against each pattern p of a match alternative. When all patterns of an alternative match, the match term evaluates to the value of the corresponding right-hand side f with the pattern variables bound to the respective matched values. If used as match h : e, ... with | p, ... => f | ..., h : e = p is available within f.

When not constructing a proof, match does not automatically substitute variables matched on in dependent variables' types. Use match (generalizing := true) ... to enforce this.

Syntax quotations can also be used in a pattern match. This matches a Syntax value against quotations, pattern variables, or _.

Quoted identifiers only match identical identifiers - custom matching such as by the preresolved names only should be done explicitly.

Syntax.atoms are ignored during matching by default except when part of a built-in literal. For users introducing new atoms, we recommend wrapping them in dedicated syntax kinds if they should participate in matching. For example, in

syntax "c" ("foo" <|> "bar") ...

foo and bar are indistinguishable during matching, but in

syntax foo := "foo"
syntax "c" (foo <|> "bar") ...

they are not.

def Lean.Parser.Term.nomatch : Lean.Parser.Parser

Empty match/ex falso. nomatch e is of arbitrary type α : Sort u if Lean can show that an empty set of patterns is exhaustive given e's type, e.g. because it has no constructors.

def Lean.Parser.Term.nofun : Lean.Parser.Parser

@[inline]

def Lean.Parser.Term.structInstFieldDeclParser (rbp : Nat := 0) : Lean.Parser.Parser

def Lean.Parser.Term.optEllipsis : Lean.Parser.Parser

def Lean.Parser.Term.structInstArrayRef : Lean.Parser.Parser

def Lean.Parser.Term.structInstLVal : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.structInstFieldBinder : Lean.Parser.Parser

def Lean.Parser.Term.optTypeForStructInst : Lean.Parser.Parser

def Lean.Parser.Term.structInstField : Lean.Parser.Parser

def Lean.Parser.Term.structInstFields (p : Lean.Parser.Parser) : Lean.Parser.Parser

Equations

• Lean.Parser.Term.structInstFields p = Lean.Parser.node `Lean.Parser.Term.structInstFields p

def Lean.Parser.Term.structInst : Lean.Parser.Parser

Structure instance. { x := e, ... } assigns e to field x, which may be inherited. If e is itself a variable called x, it can be elided: fun y => { x := 1, y }. A structure update of an existing value can be given via with: { point with x := 1 }. The structure type can be specified if not inferable: { x := 1, y := 2 : Point }.

Equations

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

def Lean.Parser.Term.structInstFieldDef : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.structInstFieldEqns : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.funImplicitBinder : Lean.Parser.Parser

def Lean.Parser.Term.funStrictImplicitBinder : Lean.Parser.Parser

def Lean.Parser.Term.funBinder : Lean.Parser.Parser

def Lean.Parser.Term.basicFun : Lean.Parser.Parser

def Lean.Parser.Term.fun : Lean.Parser.Parser

def Lean.Parser.Term.optExprPrecedence : Lean.Parser.Parser

Equations

• Lean.Parser.Term.optExprPrecedence = Lean.Parser.optional (Lean.Parser.atomic (Lean.Parser.symbol ":") >> Lean.Parser.termParser Lean.Parser.maxPrec)

def Lean.Parser.Term.withAnonymousAntiquot : Lean.Parser.Parser

def Lean.Parser.Term.leading_parser : Lean.Parser.Parser

def Lean.Parser.Term.trailing_parser : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.borrowed : Lean.Parser.Parser

Indicates that an argument to a function marked @[extern] is borrowed.

Being borrowed only affects the ABI and runtime behavior of the function when compiled or interpreted. From the perspective of Lean's type system, this annotation has no effect. It similarly has no effect on functions not marked @[extern].

When a function argument is borrowed, the function does not consume the value. This means that the function will not decrement the value's reference count or deallocate it, and the caller is responsible for doing so.

Please see https://lean-lang.org/lean4/doc/dev/ffi.html#borrowing for a complete description.

Equations

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

def Lean.Parser.Term.quotedName : Lean.Parser.Parser

A literal of type Name.

def Lean.Parser.Term.doubleQuotedName : Lean.Parser.Parser

A resolved name literal. Evaluates to the full name of the given constant if existent in the current context, or else fails.

def Lean.Parser.Term.letIdBinder : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.letIdLhs : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.letIdDecl : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.letPatDecl : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.letEqnsDecl : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.letDecl : Lean.Parser.Parser

letDecl matches the body of a let declaration let f x1 x2 := e, let pat := e (where pat is an arbitrary term) or let f | pat1 => e1 | pat2 => e2 ... (a pattern matching declaration), except for the let keyword itself. let rec declarations are not handled here.

def Lean.Parser.Term.let : Lean.Parser.Parser

let is used to declare a local definition. Example:

let x := 1
let y := x + 1
x + y

Since functions are first class citizens in Lean, you can use let to declare local functions too.

let double := fun x => 2*x
double (double 3)

For recursive definitions, you should use let rec. You can also perform pattern matching using let. For example, assume p has type Nat × Nat, then you can write

let (x, y) := p
x + y

Equations

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

def Lean.Parser.Term.let_fun : Lean.Parser.Parser

let_fun x := v; b is syntax sugar for (fun x => b) v. It is very similar to let x := v; b, but they are not equivalent. In let_fun, the value v has been abstracted away and cannot be accessed in b.

def Lean.Parser.Term.let_delayed : Lean.Parser.Parser

let_delayed x := v; b is similar to let x := v; b, but b is elaborated before v.

def Lean.Parser.Term.let_tmp : Lean.Parser.Parser

let-declaration that is only included in the elaborated term if variable is still there. It is often used when building macros.

def Lean.Parser.Term.haveId : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.haveIdLhs : Lean.Parser.Parser

Equations

• Lean.Parser.Term.haveIdLhs = Lean.Parser.Term.haveId >> Lean.Parser.many (Lean.Parser.ppSpace >> Lean.Parser.Term.letIdBinder) >> Lean.Parser.Term.optType

def Lean.Parser.Term.haveIdDecl : Lean.Parser.Parser

def Lean.Parser.Term.haveEqnsDecl : Lean.Parser.Parser

def Lean.Parser.Term.haveDecl : Lean.Parser.Parser

haveDecl matches the body of a have declaration: have := e, have f x1 x2 := e, have pat := e (where pat is an arbitrary term) or have f | pat1 => e1 | pat2 => e2 ... (a pattern matching declaration), except for the have keyword itself.

def Lean.Parser.Term.have : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.haveI : Lean.Parser.Parser

haveI behaves like have, but inlines the value instead of producing a let_fun term.

def Lean.Parser.Term.letI : Lean.Parser.Parser

letI behaves like let, but inlines the value instead of producing a let_fun term.

Equations

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

def Lean.Parser.Term.scoped : Lean.Parser.Parser

def Lean.Parser.Term.local : Lean.Parser.Parser

def Lean.Parser.Term.attrKind : Lean.Parser.Parser

attrKind matches ("scoped" <|> "local")?, used before an attribute like @[local simp].

Equations

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

def Lean.Parser.Term.attrInstance : Lean.Parser.Parser

def Lean.Parser.Term.attributes : Lean.Parser.Parser

Equations

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

def Lean.Parser.Termination.terminationBy : Lean.Parser.Parser

Specify a termination argument for recursive functions.

termination_by a - b

indicates that termination of the currently defined recursive function follows because the difference between the arguments a and b decreases.

If the function takes further argument after the colon, you can name them as follows:

def example (a : Nat) : Nat → Nat → Nat :=
termination_by b c => a - b

By default, a termination_by clause will cause the function to be constructed using well-founded recursion. The syntax termination_by structural a (or termination_by structural _ c => c) indicates the function is expected to be structural recursive on the argument. In this case the body of the termination_by clause must be one of the function's parameters.

If omitted, a termination argument will be inferred. If written as termination_by?, the inferrred termination argument will be suggested.

Equations

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

def Lean.Parser.Termination.terminationBy? : Lean.Parser.Parser

Specify a termination argument for recursive functions.

termination_by a - b

indicates that termination of the currently defined recursive function follows because the difference between the arguments a and b decreases.

If the function takes further argument after the colon, you can name them as follows:

def example (a : Nat) : Nat → Nat → Nat :=
termination_by b c => a - b

By default, a termination_by clause will cause the function to be constructed using well-founded recursion. The syntax termination_by structural a (or termination_by structural _ c => c) indicates the function is expected to be structural recursive on the argument. In this case the body of the termination_by clause must be one of the function's parameters.

If omitted, a termination argument will be inferred. If written as termination_by?, the inferrred termination argument will be suggested.

def Lean.Parser.Termination.decreasingBy : Lean.Parser.Parser

Manually prove that the termination argument (as specified with termination_by or inferred) decreases at each recursive call.

By default, the tactic decreasing_tactic is used.

Forces the use of well-founded recursion and is hence incompatible with termination_by structural.

Equations

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

def Lean.Parser.Termination.suffix : Lean.Parser.Parser

Termination hints are termination_by and decreasing_by, in that order.

def Lean.Parser.Term.letRecDecl : Lean.Parser.Parser

letRecDecl matches the body of a let-rec declaration: a doc comment, attributes, and then a let declaration without the let keyword, such as /-- foo -/ @[simp] bar := 1.

Equations

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

def Lean.Parser.Term.letRecDecls : Lean.Parser.Parser

letRecDecls matches letRecDecl,+, a comma-separated list of let-rec declarations (see letRecDecl).

def Lean.Parser.Term.letrec : Lean.Parser.Parser

def Lean.Parser.Term.whereDecls : Lean.Parser.Parser

def Lean.Parser.Term.matchAltsWhereDecls : Lean.Parser.Parser

def Lean.Parser.Term.noindex : Lean.Parser.Parser

def Lean.Parser.Term.unsafe : Lean.Parser.Parser

unsafe t : α is an expression constructor which allows using unsafe declarations inside the body of t : α, by creating an auxiliary definition containing t and using implementedBy to wrap it in a safe interface. It is required that α is nonempty for this to be sound, but even beyond that, an unsafe block should be carefully inspected for memory safety because the compiler is unable to guarantee the safety of the operation.

For example, the evalExpr function is unsafe, because the compiler cannot guarantee that when you call evalExpr Foo ``Foo e that the type Foo corresponds to the name Foo, but in a particular use case, we can ensure this, so unsafe (evalExpr Foo ``Foo e) is a correct usage.

Equations

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

def Lean.Parser.Term.binrel : Lean.Parser.Parser

binrel% r a b elaborates r a b as a binary relation using the type propagation protocol in Lean.Elab.Extra.

Equations

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

def Lean.Parser.Term.binrel_no_prop : Lean.Parser.Parser

binrel_no_prop% r a b is similar to binrel% r a b, but it coerces Prop arguments into Bool.

Equations

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

def Lean.Parser.Term.binop : Lean.Parser.Parser

binop% f a b elaborates f a b as a binary operation using the type propagation protocol in Lean.Elab.Extra.

def Lean.Parser.Term.binop_lazy : Lean.Parser.Parser

binop_lazy% is similar to binop% f a b, but it wraps b as a function from Unit.

def Lean.Parser.Term.leftact : Lean.Parser.Parser

leftact% f a b elaborates f a b as a left action using the type propagation protocol in Lean.Elab.Extra. In particular, it is like a unary operation with a fixed parameter a, where only the right argument b participates in the operator coercion elaborator.

Equations

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

def Lean.Parser.Term.rightact : Lean.Parser.Parser

rightact% f a b elaborates f a b as a right action using the type propagation protocol in Lean.Elab.Extra. In particular, it is like a unary operation with a fixed parameter b, where only the left argument a participates in the operator coercion elaborator.

def Lean.Parser.Term.unop : Lean.Parser.Parser

unop% f a elaborates f a as a unary operation using the type propagation protocol in Lean.Elab.Extra.

def Lean.Parser.Term.forInMacro : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.forInMacro' : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.declName : Lean.Parser.Parser

A macro which evaluates to the name of the currently elaborating declaration.

def Lean.Parser.Term.withDeclName : Lean.Parser.Parser

• with_decl_name% id e elaborates e in a context while changing the effective declaration name to id.
• with_decl_name% ?id e does the same, but resolves id as a new definition name (appending the current namespaces).

Equations

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

def Lean.Parser.Term.typeOf : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.ensureTypeOf : Lean.Parser.Parser

def Lean.Parser.Term.ensureExpectedType : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.noImplicitLambda : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.clear : Lean.Parser.Parser

clear% x; e elaborates x after clearing the free variable x from the local context. If x cannot be cleared (due to dependencies), it will keep x without failing.

def Lean.Parser.Term.letMVar : Lean.Parser.Parser

def Lean.Parser.Term.waitIfTypeMVar : Lean.Parser.Parser

def Lean.Parser.Term.waitIfTypeContainsMVar : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.waitIfContainsMVar : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.defaultOrOfNonempty : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.noErrorIfUnused : Lean.Parser.Parser

Helper parser for marking match-alternatives that should not trigger errors if unused. We use them to implement macro_rules and elab_rules

def Lean.Parser.Term.namedArgument : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.ellipsis : Lean.Parser.Parser

In a function application, .. notation inserts zero or more _ placeholders.

Equations

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

def Lean.Parser.Term.argument : Lean.Parser.Parser

def Lean.Parser.Term.app : Lean.Parser.TrailingParser

Equations

• Lean.Parser.Term.app = Lean.Parser.trailingNode `Lean.Parser.Term.app Lean.Parser.leadPrec Lean.Parser.maxPrec (Lean.Parser.many1 Lean.Parser.Term.argument)

def Lean.Parser.Term.proj : Lean.Parser.TrailingParser

The extended field notation e.f is roughly short for T.f e where T is the type of e. More precisely,

• if e is of a function type, e.f is translated to Function.f (p := e) where p is the first explicit parameter of function type
• if e is of a named type T ... and there is a declaration T.f (possibly from export), e.f is translated to T.f (p := e) where p is the first explicit parameter of type T ...
• otherwise, if e is of a structure type, the above is repeated for every base type of the structure.

The field index notation e.i, where i is a positive number, is short for accessing the i-th field (1-indexed) of e if it is of a structure type.

Equations

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

def Lean.Parser.Term.completion : Lean.Parser.TrailingParser

Equations

• Lean.Parser.Term.completion = Lean.Parser.trailingNode `Lean.Parser.Term.completion 1024 0 (Lean.Parser.checkNoWsBefore >> Lean.Parser.symbol ".")

def Lean.Parser.Term.arrow : Lean.Parser.TrailingParser

Equations

• Lean.Parser.Term.arrow = Lean.Parser.trailingNode `Lean.Parser.Term.arrow 1024 0 (Lean.Parser.checkPrec 25 >> Lean.Parser.unicodeSymbol " → " " -> " >> Lean.Parser.termParser 25)

def Lean.Parser.Term.identProjKind : Lean.Name

Syntax kind for syntax nodes representing the field of a projection in the InfoTree. Specifically, the InfoTree node for a projection s.f contains a child InfoTree node with syntax (Syntax.node .none identProjKind #[`f]).

This is necessary because projection syntax cannot always be detected purely syntactically (s.f may refer to either the identifier s.f or a projection s.f depending on the available context).

def Lean.Parser.Term.isIdent (stx : Lean.Syntax) : Bool

def Lean.Parser.Term.explicitUniv : Lean.Parser.TrailingParser

x.{u, ...} explicitly specifies the universes u, ... of the constant x.

Equations

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

def Lean.Parser.Term.namedPattern : Lean.Parser.TrailingParser

x@e or x@h:e matches the pattern e and binds its value to the identifier x. If present, the identifier h is bound to a proof of x = e.

def Lean.Parser.Term.pipeProj : Lean.Parser.TrailingParser

e |>.x is a shorthand for (e).x. It is especially useful for avoiding parentheses with repeated applications.

Equations

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

def Lean.Parser.Term.pipeCompletion : Lean.Parser.TrailingParser

def Lean.Parser.Term.subst : Lean.Parser.TrailingParser

h ▸ e is a macro built on top of Eq.rec and Eq.symm definitions. Given h : a = b and e : p a, the term h ▸ e has type p b. You can also view h ▸ e as a "type casting" operation where you change the type of e by using h.

The macro tries both orientations of h. If the context provides an expected type, it rewrites the expected type, else it rewrites the type of e`.

See the Chapter "Quantifiers and Equality" in the manual "Theorem Proving in Lean" for additional information.

def Lean.Parser.Term.bracketedBinderF : Lean.Parser.Parser

instance Lean.Parser.Term.instCoeTSyntaxConsSyntaxNodeKindMkStr4Nil_lean_1 : Coe (Lean.TSyntax `Lean.Parser.Term.bracketedBinderF) (Lean.TSyntax `Lean.Parser.Term.bracketedBinder)

def Lean.Parser.Term.panic : Lean.Parser.Parser

panic! msg formally evaluates to @Inhabited.default α if the expected type α implements Inhabited. At runtime, msg and the file position are printed to stderr unless the C function lean_set_panic_messages(false) has been executed before. If the C function lean_set_exit_on_panic(true) has been executed before, the process is then aborted.

def Lean.Parser.Term.unreachable : Lean.Parser.Parser

A shorthand for panic! "unreachable code has been reached".

Equations

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

def Lean.Parser.Term.dbgTrace : Lean.Parser.Parser

dbg_trace e; body evaluates to body and prints e (which can be an interpolated string literal) to stderr. It should only be used for debugging.

Equations

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

def Lean.Parser.Term.assert : Lean.Parser.Parser

assert! cond panics if cond evaluates to false.

def Lean.Parser.Term.macroArg : Lean.Parser.Parser

Equations

• Lean.Parser.Term.macroArg = Lean.Parser.termParser Lean.Parser.maxPrec

def Lean.Parser.Term.macroDollarArg : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.macroLastArg : Lean.Parser.Parser

def Lean.Parser.Term.stateRefT : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.dynamicQuot : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.dotIdent : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.showTermElabImpl : Lean.Parser.Parser

Implementation of the show_term term elaborator.

match_expr support.

def Lean.Parser.Term.matchExprPat : Lean.Parser.Parser

def Lean.Parser.Term.matchExprAlt (rhsParser : Lean.Parser.Parser) : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.matchExprElseAlt (rhsParser : Lean.Parser.Parser) : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.matchExprAlts (rhsParser : Lean.Parser.Parser) : Lean.Parser.Parser

Equations

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

def Lean.Parser.Term.matchExpr : Lean.Parser.Parser

def Lean.Parser.Term.letExpr : Lean.Parser.Parser

Equations

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

def Lean.Parser.Tactic.quot : Lean.Parser.Parser

def Lean.Parser.Tactic.quotSeq : Lean.Parser.Parser