Documentation

Init.Prelude

Init.Prelude #

This is the first file in the lean import hierarchy. It is responsible for setting up basic definitions, most of which lean already has "built in knowledge" about, so it is important that they be set up in exactly this way. (For example, lean will use PUnit in the desugaring of do notation, or in the pattern match compiler.)

@[inline]

def id {α : Sort u} (a : α) :

α

The identity function. id takes an implicit argument α : Sort u (a type in any universe), and an argument a : α, and returns a.

Although this may look like a useless function, one application of the identity function is to explicitly put a type on an expression. If e has type T, and T' is definitionally equal to T, then @id T' e typechecks, and lean knows that this expression has type T' rather than T. This can make a difference for typeclass inference, since T and T' may have different typeclass instances on them. show T' from e is sugar for an @id T' e expression.

Equations

id a = a

@[inline]

def Function.comp {α : Sort u} {β : Sort v} {δ : Sort w} (f : β → δ) (g : α → β) :

α → δ

Function composition is the act of pipelining the result of one function, to the input of another, creating an entirely new function. Example:

#eval Function.comp List.reverse (List.drop 2) [3, 2, 4, 1]
-- [1, 4]

You can use the notation f ∘ g as shorthand for Function.comp f g.

#eval (List.reverse ∘ List.drop 2) [3, 2, 4, 1]
-- [1, 4]

A simpler way of thinking about it, is that List.reverse ∘ List.drop 2 is equivalent to fun xs => List.reverse (List.drop 2 xs), the benefit is that the meaning of composition is obvious, and the representation is compact.

Equations

Function.comp f g x = f (g x)

@[inline]

def Function.const {α : Sort u} (β : Sort v) (a : α) :

β → α

The constant function. If a : α, then Function.const β a : β → α is the "constant function with value a", that is, Function.const β a b = a.

example (b : Bool) : Function.const Bool 10 b = 10 :=
  rfl

#check Function.const Bool 10
-- Bool → Nat

Equations

Function.const β a x = a

@[inline]

abbrev inferInstance {α : Sort u} [i : α] :

α

inferInstance synthesizes a value of any target type by typeclass inference. This function has the same type signature as the identity function, but the square brackets on the [i : α] argument means that it will attempt to construct this argument by typeclass inference. (This will fail if α is not a class.) Example:

#check (inferInstance : Inhabited Nat) -- Inhabited Nat

def foo : Inhabited (Nat × Nat) :=
  inferInstance

example : foo.default = (default, default) :=
  rfl

Equations

inferInstance = i

@[inline]

abbrev inferInstanceAs (α : Sort u) [i : α] :

α

inferInstanceAs α synthesizes a value of any target type by typeclass inference. This is just like inferInstance except that α is given explicitly instead of being inferred from the target type. It is especially useful when the target type is some α' which is definitionally equal to α, but the instance we are looking for is only registered for α (because typeclass search does not unfold most definitions, but definitional equality does.) Example:

#check inferInstanceAs (Inhabited Nat) -- Inhabited Nat

Equations

inferInstanceAs α = i

inductive PUnit :

PUnit.unit : PUnit is the canonical element of the unit type.
unit: PUnit

The unit type, the canonical type with one element, named unit or (). This is the universe-polymorphic version of Unit; it is preferred to use Unit instead where applicable. For more information about universe levels: Types as objects

Instances For

@[inline]

abbrev Unit :

The unit type, the canonical type with one element, named unit or (). In other words, it describes only a single value, which consists of said constructor applied to no arguments whatsoever. The Unit type is similar to void in languages derived from C.

Unit is actually defined as PUnit.{0} where PUnit is the universe polymorphic version. The Unit should be preferred over PUnit where possible to avoid unnecessary universe parameters.

In functional programming, Unit is the return type of things that "return nothing", since a type with one element conveys no additional information. When programming with monads, the type m Unit represents an action that has some side effects but does not return a value, while m α would be an action that has side effects and returns a value of type α.

Equations

Unit = PUnit

@[match_pattern, inline]

abbrev Unit.unit :

Unit.unit : Unit is the canonical element of the unit type. It can also be written as ().

Equations

() = PUnit.unit

unsafe axiom lcErased :

Marker for information that has been erased by the code generator.

unsafe axiom lcProof {α : Prop} :

α

Auxiliary unsafe constant used by the Compiler when erasing proofs from code.

It may look strange to have an axiom that says "every proposition is true", since this is obviously unsound, but the unsafe marker ensures that the kernel will not let this through into regular proofs. The lower levels of the code generator don't need proofs in terms, so this is used to stub the proofs out.

unsafe axiom lcCast {α : Sort u} {β : Sort v} (a : α) :

β

Auxiliary unsafe constant used by the Compiler when erasing casts.

unsafe axiom lcUnreachable {α : Sort u} :

α

Auxiliary unsafe constant used by the Compiler to mark unreachable code.

Like lcProof, this is an unsafe axiom, which means that even though it is not sound, the kernel will not let us use it for regular proofs.

Executing this expression to actually synthesize a value of type α causes immediate undefined behavior, and the compiler does take advantage of this to optimize the code assuming that it is not called. If it is not optimized out, it is likely to appear as a print message saying "unreachable code", but this behavior is not guaranteed or stable in any way.

inductive True :

True is true, and True.intro (or more commonly, trivial) is the proof.
intro: True

True is a proposition and has only an introduction rule, True.intro : True. In other words, True is simply true, and has a canonical proof, True.intro For more information: Propositional Logic

Instances For

inductive False :

False is the empty proposition. Thus, it has no introduction rules. It represents a contradiction. False elimination rule, False.rec, expresses the fact that anything follows from a contradiction. This rule is sometimes called ex falso (short for ex falso sequitur quodlibet), or the principle of explosion. For more information: Propositional Logic

Instances For

inductive Empty :

The empty type. It has no constructors. The Empty.rec eliminator expresses the fact that anything follows from the empty type.

Instances For

inductive PEmpty :

The universe-polymorphic empty type. Prefer Empty or False where possible.

Instances For

def Not (a : Prop) :

Not p, or ¬p, is the negation of p. It is defined to be p → False, so if your goal is ¬p you can use intro h to turn the goal into h : p ⊢ False, and if you have hn : ¬p and h : p then hn h : False and (hn h).elim will prove anything. For more information: Propositional Logic

Equations

(¬a) = (a → False)

@[macro_inline]

def False.elim {C : Sort u} (h : False) :

C

False.elim : False → C says that from False, any desired proposition C holds. Also known as ex falso quodlibet (EFQ) or the principle of explosion.

The target type is actually C : Sort u which means it works for both propositions and types. When executed, this acts like an "unreachable" instruction: it is undefined behavior to run, but it will probably print "unreachable code". (You would need to construct a proof of false to run it anyway, which you can only do using sorry or unsound axioms.)

Equations

False.elim h = False.rec (fun x => C) h

@[macro_inline]

def absurd {a : Prop} {b : Sort v} (h₁ : a) (h₂ : ¬a) :

b

Anything follows from two contradictory hypotheses. Example:

example (hp : p) (hnp : ¬p) : q := absurd hp hnp

For more information: Propositional Logic

Equations

absurd h₁ h₂ = False.rec (fun x => b) (h₂ h₁)

inductive Eq {α : Sort u_1} :

α → α → Prop

Eq.refl a : a = a is reflexivity, the unique constructor of the equality type. See also rfl, which is usually used instead.
refl: ∀ {α : Sort u_1} (a : α), a = a

The equality relation. It has one introduction rule, Eq.refl. We use a = b as notation for Eq a b. A fundamental property of equality is that it is an equivalence relation.

variable (α : Type) (a b c d : α)
variable (hab : a = b) (hcb : c = b) (hcd : c = d)

example : a = d :=
  Eq.trans (Eq.trans hab (Eq.symm hcb)) hcd

Equality is much more than an equivalence relation, however. It has the important property that every assertion respects the equivalence, in the sense that we can substitute equal expressions without changing the truth value. That is, given h1 : a = b and h2 : p a, we can construct a proof for p b using substitution: Eq.subst h1 h2. Example:

example (α : Type) (a b : α) (p : α → Prop)
        (h1 : a = b) (h2 : p a) : p b :=
  Eq.subst h1 h2

example (α : Type) (a b : α) (p : α → Prop)
    (h1 : a = b) (h2 : p a) : p b :=
  h1 ▸ h2

The triangle in the second presentation is a macro built on top of Eq.subst and Eq.symm, and you can enter it by typing \t. For more information: Equality

Instances For

@[match_pattern]

def rfl {α : Sort u} {a : α} :

a = a

rfl : a = a is the unique constructor of the equality type. This is the same as Eq.refl except that it takes a implicitly instead of explicitly.

This is a more powerful theorem than it may appear at first, because although the statement of the theorem is a = a, lean will allow anything that is definitionally equal to that type. So, for instance, 2 + 2 = 4 is proven in lean by rfl, because both sides are the same up to definitional equality.

Equations

@rfl = @rfl.proof_1

@[simp]

theorem id_eq {α : Sort u_1} (a : α) :

id a = a

id x = x, as a @[simp] lemma.

theorem Eq.subst {α : Sort u} {motive : α → Prop} {a : α} {b : α} (h₁ : a = b) (h₂ : motive a) :

motive b

The substitution principle for equality. If a = b and P a holds, then P b also holds. We conventionally use the name motive for P here, so that you can specify it explicitly using e.g. Eq.subst (motive := fun x => x < 5) if it is not otherwise inferred correctly.

This theorem is the underlying mechanism behind the rw tactic, which is essentially a fancy algorithm for finding good motive arguments to usefully apply this theorem to replace occurrences of a with b in the goal or hypotheses.

For more information: Equality

theorem Eq.symm {α : Sort u} {a : α} {b : α} (h : a = b) :

b = a

Equality is symmetric: if a = b then b = a.

Because this is in the Eq namespace, if you have a variable h : a = b, h.symm can be used as shorthand for Eq.symm h as a proof of b = a.

For more information: Equality

theorem Eq.trans {α : Sort u} {a : α} {b : α} {c : α} (h₁ : a = b) (h₂ : b = c) :

a = c

Equality is transitive: if a = b and b = c then a = c.

Because this is in the Eq namespace, if you variables or expressions h₁ : a = b and h₂ : b = c, you can use h₁.trans h₂ : a = c as shorthand for Eq.trans h₁ h₂.

For more information: Equality

@[macro_inline]

def cast {α : Sort u} {β : Sort u} (h : α = β) (a : α) :

β

Cast across a type equality. If h : α = β is an equality of types, and a : α, then a : β will usually not typecheck directly, but this function will allow you to work around this and embed a in type β as cast h a : β.

It is best to avoid this function if you can, because it is more complicated to reason about terms containing casts, but if the types don't match up definitionally sometimes there isn't anything better you can do.

For more information: Equality

Equations

cast h a = h ▸ a

theorem congrArg {α : Sort u} {β : Sort v} {a₁ : α} {a₂ : α} (f : α → β) (h : a₁ = a₂) :

f a₁ = f a₂

Congruence in the function argument: if a₁ = a₂ then f a₁ = f a₂ for any (nondependent) function f. This is more powerful than it might look at first, because you can also use a lambda expression for f to prove that = . This function is used internally by tactics like congr and simp to apply equalities inside subterms.

For more information: Equality

theorem congr {α : Sort u} {β : Sort v} {f₁ : α → β} {f₂ : α → β} {a₁ : α} {a₂ : α} (h₁ : f₁ = f₂) (h₂ : a₁ = a₂) :

f₁ a₁ = f₂ a₂

Congruence in both function and argument. If f₁ = f₂ and a₁ = a₂ then f₁ a₁ = f₂ a₂. This only works for nondependent functions; the theorem statement is more complex in the dependent case.

For more information: Equality

theorem congrFun {α : Sort u} {β : α → Sort v} {f : (x : α) → β x} {g : (x : α) → β x} (h : f = g) (a : α) :

f a = g a

Congruence in the function part of an application: If f = g then f a = g a.

Initialize the Quotient Module, which effectively adds the following definitions:

opaque Quot {α : Sort u} (r : α → α → Prop) : Sort u

opaque Quot.mk {α : Sort u} (r : α → α → Prop) (a : α) : Quot r

opaque Quot.lift {α : Sort u} {r : α → α → Prop} {β : Sort v} (f : α → β) :
  (∀ a b : α, r a b → Eq (f a) (f b)) → Quot r → β

opaque Quot.ind {α : Sort u} {r : α → α → Prop} {β : Quot r → Prop} :
  (∀ a : α, β (Quot.mk r a)) → ∀ q : Quot r, β q

unsafe axiom Quot.lcInv {α : Sort u} {r : α → α → Prop} (q : Quot r) :

α

Unsafe auxiliary constant used by the compiler to erase Quot.lift.

inductive HEq {α : Sort u} :

α → {β : Sort u} → β → Prop

Reflexivity of heterogeneous equality.
refl: ∀ {α : Sort u} (a : α), HEq a a

Heterogeneous equality. HEq a b asserts that a and b have the same type, and casting a across the equality yields b, and vice versa.

You should avoid using this type if you can. Heterogeneous equality does not have all the same properties as Eq, because the assumption that the types of a and b are equal is often too weak to prove theorems of interest. One important non-theorem is the analogue of congr: If HEq f g and HEq x y and f x and g y are well typed it does not follow that HEq (f x) (g y). (This does follow if you have f = g instead.) However if a and b have the same type then a = b and HEq a b ae equivalent.

Instances For

@[match_pattern]

def HEq.rfl {α : Sort u} {a : α} :

HEq a a

A version of HEq.refl with an implicit argument.

Equations

@HEq.rfl = @HEq.rfl.proof_1

theorem eq_of_heq {α : Sort u} {a : α} {a' : α} (h : HEq a a') :

a = a'

@[unbox]

structure Prod (α : Type u) (β : Type v) :

Type (maxuv)

The first projection out of a pair. if p : α × β then p.1 : α.
fst : α
The second projection out of a pair. if p : α × β then p.2 : β.
snd : β

Product type (aka pair). You can use α × β as notation for Prod α β. Given a : α and b : β, Prod.mk a b : Prod α β. You can use (a, b) as notation for Prod.mk a b. Moreover, (a, b, c) is notation for Prod.mk a (Prod.mk b c). Given p : Prod α β, p.1 : α and p.2 : β. They are short for Prod.fst p and Prod.snd p respectively. You can also write p.fst and p.snd. For more information: Constructors with Arguments

Instances For

structure PProd (α : Sort u) (β : Sort v) :

Sort (max(max1u)v)

The first projection out of a pair. if p : PProd α β then p.1 : α.
fst : α
The second projection out of a pair. if p : PProd α β then p.2 : β.
snd : β

Similar to Prod, but α and β can be propositions. We use this Type internally to automatically generate the brecOn recursor.

Instances For

structure MProd (α : Type u) (β : Type u) :

The first projection out of a pair. if p : MProd α β then p.1 : α.
fst : α
The second projection out of a pair. if p : MProd α β then p.2 : β.
snd : β

Similar to Prod, but α and β are in the same universe. We say MProd is the universe monomorphic product type.

Instances For

structure And (a : Prop) (b : Prop) :

intro :: (

Extract the left conjunct from a conjunction. h : a ∧ b then h.left, also notated as h.1, is a proof of a.
left : a
Extract the right conjunct from a conjunction. h : a ∧ b then h.right, also notated as h.2, is a proof of b.
right : b

)

And a b, or a ∧ b, is the conjunction of propositions. It can be constructed and destructed like a pair: if ha : a and hb : b then ⟨ha, hb⟩ : a ∧ b, and if h : a ∧ b then h.left : a and h.right : b.

Instances For

inductive Or (a : Prop) (b : Prop) :

Or.inl is "left injection" into an Or. If h : a then Or.inl h : a ∨ b.
inl: ∀ {a b : Prop}, a → a ∨ b
Or.inr is "right injection" into an Or. If h : b then Or.inr h : a ∨ b.
inr: ∀ {a b : Prop}, b → a ∨ b

Or a b, or a ∨ b, is the disjunction of propositions. There are two constructors for Or, called Or.inl : a → a ∨ b and Or.inr : b → a ∨ b, and you can use match or cases to destruct an Or assumption into the two cases.

Instances For

theorem Or.intro_left {a : Prop} (b : Prop) (h : a) :

a ∨ b

Alias for Or.inl.

theorem Or.intro_right {b : Prop} (a : Prop) (h : b) :

a ∨ b

Alias for Or.inr.

theorem Or.elim {a : Prop} {b : Prop} {c : Prop} (h : a ∨ b) (left : a → c) (right : b → c) :

c

Proof by cases on an Or. If a ∨ b, and both a and b imply proposition c, then c is true.

inductive Bool :

The boolean value false, not to be confused with the proposition False.
false: Bool
The boolean value true, not to be confused with the proposition True.
true: Bool

Bool is the type of boolean values, true and false. Classically, this is equivalent to Prop (the type of propositions), but the distinction is important for programming, because values of type Prop are erased in the code generator, while Bool corresponds to the type called bool or boolean in most programming languages.

Instances For

structure Subtype {α : Sort u} (p : α → Prop) :

Sort (max1u)

If s : {x // p x} then s.val : α is the underlying element in the base type. You can also write this as s.1, or simply as s when the type is known from context.
val : α
If s : {x // p x} then s.2 or s.property is the assertion that p s.1, that is, that s is in fact an element for which p holds.
property : p val

Subtype p, usually written as {x : α // p x}, is a type which represents all the elements x : α for which p x is true. It is structurally a pair-like type, so if you have x : α and h : p x then ⟨x, h⟩ : {x // p x}. An element s : {x // p x} will coerce to α but you can also make it explicit using s.1 or s.val.

Instances For

def optParam (α : Sort u) (default : α) :

Gadget for optional parameter support.

A binder like (x : α := default) in a declaration is syntax sugar for x : optParam α default, and triggers the elaborator to attempt to use default to supply the argument if it is not supplied.

Equations

optParam α default = α

def outParam (α : Sort u) :

Gadget for marking output parameters in type classes.

For example, the Membership class is defined as:

class Membership (α : outParam (Type u)) (γ : Type v)

This means that whenever a typeclass goal of the form Membership ?α ?γ comes up, lean will wait to solve it until ?γ is known, but then it will run typeclass inference, and take the first solution it finds, for any value of ?α, which thereby determines what ?α should be.

This expresses that in a term like a ∈ s, s might be a Set α or List α or some other type with a membership operation, and in each case the "member" type α is determined by looking at the container type.

Equations

outParam α = α

def namedPattern {α : Sort u} (x : α) (a : α) (h : x = a) :

α

Auxiliary declaration used to implement named patterns like x@h:p.

Equations

namedPattern x a h = a

@[never_extract, extern lean_sorry]

axiom sorryAx (α : Sort u) (synthetic : optParam Bool false) :

α

Auxiliary axiom used to implement sorry.

The sorry term/tactic expands to sorryAx _ (synthetic := false). This is a proof of anything, which is intended for stubbing out incomplete parts of a proof while still having a syntactically correct proof skeleton. Lean will give a warning whenever a proof uses sorry, so you aren't likely to miss it, but you can double check if a theorem depends on sorry by using #print axioms my_thm and looking for sorryAx in the axiom list.

The synthetic flag is false when written explicitly by the user, but it is set to true when a tactic fails to prove a goal, or if there is a type error in the expression. A synthetic sorry acts like a regular one, except that it suppresses follow-up errors in order to prevent one error from causing a cascade of other errors because the desired term was not constructed.

theorem eq_false_of_ne_true {b : Bool} :

¬b = true → b = false

theorem eq_true_of_ne_false {b : Bool} :

¬b = false → b = true

theorem ne_false_of_eq_true {b : Bool} :

b = true → ¬b = false

theorem ne_true_of_eq_false {b : Bool} :

b = false → ¬b = true

class Inhabited (α : Sort u) :

Sort (max1u)

default is a function that produces a "default" element of any Inhabited type. This element does not have any particular specified properties, but it is often an all-zeroes value.
default : α

Inhabited α is a typeclass that says that α has a designated element, called (default : α). This is sometimes referred to as a "pointed type".

This class is used by functions that need to return a value of the type when called "out of domain". For example, Array.get! arr i : α returns a value of type α when arr : Array α, but if i is not in range of the array, it reports a panic message, but this does not halt the program, so it must still return a value of type α (and in fact this is required for logical consistency), so in this case it returns default.

Instances

class inductive Nonempty (α : Sort u) :

If val : α, then α is nonempty.
intro: ∀ {α : Sort u}, α → Nonempty α

Nonempty α is a typeclass that says that α is not an empty type, that is, there exists an element in the type. It differs from Inhabited α in that Nonempty α is a Prop, which means that it does not actually carry an element of α, only a proof that there exists such an element. Given Nonempty α, you can construct an element of α nonconstructively using Classical.choice.

Instances

axiom Classical.choice {α : Sort u} :

Nonempty α → α

The axiom of choice. Nonempty α is a proof that α has an element, but the element itself is erased. The axiom choice supplies a particular element of α given only this proof.

The textbook axiom of choice normally makes a family of choices all at once, but that is implied from this formulation, because if α : ι → Type is a family of types and h : ∀ i, Nonempty (α i) is a proof that they are all nonempty, then fun i => Classical.choice (h i) : ∀ i, α i is a family of chosen elements. This is actually a bit stronger than the ZFC choice axiom; this is sometimes called "global choice".

In lean, we use the axiom of choice to derive the law of excluded middle (see Classical.em), so it will often show up in axiom listings where you may not expect. You can use #print axioms my_thm to find out if a given theorem depends on this or other axioms.

This axiom can be used to construct "data", but obviously there is no algorithm to compute it, so lean will require you to mark any definition that would involve executing Classical.choice or other axioms as noncomputable, and will not produce any executable code for such definitions.

def Nonempty.elim {α : Sort u} {p : Prop} (h₁ : Nonempty α) (h₂ : α → p) :

p

The elimination principle for Nonempty α. If Nonempty α, and we can prove p given any element x : α, then p holds. Note that it is essential that p is a Prop here; the version with p being a Sort u is equivalent to Classical.choice.

Equations

@Nonempty.elim = @Nonempty.elim.proof_1

instance instNonempty {α : Sort u} [inst : Inhabited α] :

Equations

@instNonempty = @instNonempty.proof_1

noncomputable def Classical.ofNonempty {α : Sort u} [inst : Nonempty α] :

α

A variation on Classical.choice that uses typeclass inference to infer the proof of Nonempty α.

Equations

Classical.ofNonempty = Classical.choice (_ : Nonempty α)

instance instNonemptyForAll (α : Sort u) {β : Sort v} [inst : Nonempty β] :

Nonempty (α → β)

Equations

instNonemptyForAll = instNonemptyForAll.proof_1

instance instNonemptyForAll_1 (α : Sort u) {β : α → Sort v} [inst : ∀ (a : α), Nonempty (β a)] :

Nonempty ((a : α) → β a)

Equations

instNonemptyForAll_1 = instNonemptyForAll_1.proof_1

instance instInhabitedSort :

Inhabited (Sort u)

Equations

instInhabitedSort = { default := PUnit }

instance instInhabitedForAll (α : Sort u) {β : Sort v} [inst : Inhabited β] :

Inhabited (α → β)

Equations

instInhabitedForAll α = { default := fun x => default }

instance instInhabitedForAll_1 (α : Sort u) {β : α → Sort v} [inst : (a : α) → Inhabited (β a)] :

Inhabited ((a : α) → β a)

Equations

instInhabitedForAll_1 α = { default := fun x => default }

instance instInhabitedBool :

Equations

instInhabitedBool = { default := false }

structure PLift (α : Sort u) :

up :: (

Extract a value from PLift α
down : α

)

Universe lifting operation from Sort u to Type u.

Instances For

theorem PLift.up_down {α : Sort u} (b : PLift α) :

{ down := b.down } = b

Bijection between α and PLift α

theorem PLift.down_up {α : Sort u} (a : α) :

{ down := a }.down = a

Bijection between α and PLift α

def NonemptyType :

Type (u+1)

NonemptyType.{u} is the type of nonempty types in universe u. It is mainly used in constant declarations where we wish to introduce a type and simultaneously assert that it is nonempty, but otherwise make the type opaque.

Equations

NonemptyType = { α // Nonempty α }

@[inline]

abbrev NonemptyType.type (type : NonemptyType) :

The underlying type of a NonemptyType.

Equations

NonemptyType.type type = type.val

instance instInhabitedNonemptyType :

Inhabited NonemptyType

NonemptyType is inhabited, because PUnit is a nonempty type.

Equations

instInhabitedNonemptyType = { default := { val := PUnit, property := (_ : Nonempty PUnit) } }

structure ULift (α : Type s) :

Type (maxsr)

up :: (

Extract a value from ULift α
down : α

)

Universe lifting operation from a lower Type universe to a higher one. To express this using level variables, the input is Type s and the output is Type (max s r), so if s ≤ r then the latter is (definitionally) Type r.

The universe variable r is written first so that ULift.{r} α can be used when s can be inferred from the type of α.

Instances For

theorem ULift.up_down {α : Type u} (b : ULift α) :

{ down := b.down } = b

Bijection between α and ULift.{v} α

theorem ULift.down_up {α : Type u} (a : α) :

{ down := a }.down = a

Bijection between α and ULift.{v} α

class inductive Decidable (p : Prop) :

Prove that p is decidable by supplying a proof of ¬p
isFalse: {p : Prop} → ¬p → Decidable p
Prove that p is decidable by supplying a proof of p
isTrue: {p : Prop} → p → Decidable p

Decidable p is a data-carrying class that supplies a proof that p is either true or false. It is equivalent to Bool (and in fact it has the same code generation as Bool) together with a proof that the Bool is true iff p is.

Decidable instances are used to infer "computation strategies" for propositions, so that you can have the convenience of writing propositions inside if statements and executing them (which actually executes the inferred decidability instance instead of the proposition, which has no code).

If a proposition p is Decidable, then (by decide : p) will prove it by evaluating the decidability instance to isTrue h and returning h.

Instances

@[inline_if_reduce]

def Decidable.decide (p : Prop) [h : Decidable p] :

Convert a decidable proposition into a boolean value.

If p : Prop is decidable, then decide p : Bool is the boolean value which is true if p is true and false if p is false.

Equations

decide p = Decidable.casesOn h (fun x => false) fun x => true

@[inline]

abbrev DecidablePred {α : Sort u} (r : α → Prop) :

Sort (max1u)

A decidable predicate. See Decidable.

Equations

DecidablePred r = ((a : α) → Decidable (r a))

@[inline]

abbrev DecidableRel {α : Sort u} (r : α → α → Prop) :

Sort (max1u)

A decidable relation. See Decidable.

Equations

DecidableRel r = ((a b : α) → Decidable (r a b))

@[inline]

abbrev DecidableEq (α : Sort u) :

Sort (max1u)

Asserts that α has decidable equality, that is, a = b is decidable for all a b : α. See Decidable.

Equations

DecidableEq α = ((a b : α) → Decidable (a = b))

def decEq {α : Sort u} [inst : DecidableEq α] (a : α) (b : α) :

Decidable (a = b)

Proves that a = b is decidable given DecidableEq α.

Equations

decEq a b = inst a b

theorem decide_eq_true {p : Prop} [inst : Decidable p] :

p → decide p = true

theorem decide_eq_false {p : Prop} [inst : Decidable p] :

¬p → decide p = false

theorem of_decide_eq_true {p : Prop} [inst : Decidable p] :

decide p = true → p

theorem of_decide_eq_false {p : Prop} [inst : Decidable p] :

decide p = false → ¬p

theorem of_decide_eq_self_eq_true {α : Sort u_1} [inst : DecidableEq α] (a : α) :

decide (a = a) = true

@[inline]

def Bool.decEq (a : Bool) (b : Bool) :

Decidable (a = b)

Decidable equality for Bool

Equations

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

@[inline]

instance instDecidableEqBool :

DecidableEq Bool

Equations

instDecidableEqBool = Bool.decEq

class BEq (α : Type u) :

Boolean equality, notated as a == b.
beq : α → α → Bool

BEq α is a typeclass for supplying a boolean-valued equality relation on α, notated as a == b. Unlike DecidableEq α (which uses a = b), this is Bool valued instead of Prop valued, and it also does not have any axioms like being reflexive or agreeing with =. It is mainly intended for programming applications. See LawfulBEq for a version that requires that == and = coincide.

Instances

instance instBEq {α : Type u_1} [inst : DecidableEq α] :

BEq α

Equations

instBEq = { beq := fun a b => decide (a = b) }

@[macro_inline]

def dite {α : Sort u} (c : Prop) [h : Decidable c] (t : c → α) (e : ¬c → α) :

α

"Dependent" if-then-else, normally written via the notation if h : c then t(h) else e(h), is sugar for dite c (fun h => t(h)) (fun h => e(h)), and it is the same as if c then t else e except that t is allowed to depend on a proof h : c, and e can depend on h : ¬c. (Both branches use the same name for the hypothesis, even though it has different types in the two cases.)

We use this to be able to communicate the if-then-else condition to the branches. For example, Array.get arr ⟨i, h⟩ expects a proof h : i < arr.size in order to avoid a bounds check, so you can write if h : i < arr.size then arr.get ⟨i, h⟩ else ... to avoid the bounds check inside the if branch. (Of course in this case we have only lifted the check into an explicit if, but we could also use this proof multiple times or derive i < arr.size from some other proposition that we are checking in the if.)

Equations

dite c t e = Decidable.casesOn h e t

if-then-else #

@[macro_inline]

def ite {α : Sort u} (c : Prop) [h : Decidable c] (t : α) (e : α) :

α

if c then t else e is notation for ite c t e, "if-then-else", which decides to return t or e depending on whether c is true or false. The explicit argument c : Prop does not have any actual computational content, but there is an additional [Decidable c] argument synthesized by typeclass inference which actually determines how to evaluate c to true or false.

Because lean uses a strict (call-by-value) evaluation strategy, the signature of this function is problematic in that it would require t and e to be evaluated before calling the ite function, which would cause both sides of the if to be evaluated. Even if the result is discarded, this would be a big performance problem, and is undesirable for users in any case. To resolve this, ite is marked as @[macro_inline], which means that it is unfolded during code generation, and the definition of the function uses fun _ => t and fun _ => e so this recovers the expected "lazy" behavior of if: the t and e arguments delay evaluation until c is known.

Equations

(if c then t else e) = Decidable.casesOn h (fun x => e) fun x => t

@[macro_inline]

instance instDecidableAnd {p : Prop} {q : Prop} [dp : Decidable p] [dq : Decidable q] :

Decidable (p ∧ q)

Equations

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

@[macro_inline]

instance instDecidableOr {p : Prop} {q : Prop} [dp : Decidable p] [dq : Decidable q] :

Decidable (p ∨ q)

Equations

instDecidableOr = match dp with | isTrue hp => isTrue (_ : p ∨ q) | isFalse hp => match dq with | isTrue hq => isTrue (_ : p ∨ q) | isFalse hq => isFalse (_ : p ∨ q → False)

instance instDecidableNot {p : Prop} [dp : Decidable p] :

Equations

instDecidableNot = match dp with | isTrue hp => isFalse (_ : ¬p → False) | isFalse hp => isTrue hp

Boolean operators #

@[macro_inline]

def cond {α : Type u} (c : Bool) (x : α) (y : α) :

α

cond b x y is the same as if b then x else y, but optimized for a boolean condition. It can also be written as bif b then x else y. This is @[macro_inline] because x and y should not be eagerly evaluated (see ite).

Equations

(bif c then x else y) = match c with | true => x | false => y

@[macro_inline]

def or (x : Bool) (y : Bool) :

or x y, or x || y, is the boolean "or" operation (not to be confused with Or : Prop → Prop → Prop, which is the propositional connective). It is @[macro_inline] because it has C-like short-circuiting behavior: if x is true then y is not evaluated.

Equations

(x || y) = match x with | true => true | false => y

@[macro_inline]

def and (x : Bool) (y : Bool) :

and x y, or x && y, is the boolean "and" operation (not to be confused with And : Prop → Prop → Prop, which is the propositional connective). It is @[macro_inline] because it has C-like short-circuiting behavior: if x is false then y is not evaluated.

Equations

(x && y) = match x with | false => false | true => y

@[inline]

def not :

not x, or !x, is the boolean "not" operation (not to be confused with Not : Prop → Prop, which is the propositional connective).

Equations

(!x) = match x with | true => false | false => true

inductive Nat :

Nat.zero, normally written 0 : Nat, is the smallest natural number. This is one of the two constructors of Nat.
zero: Nat
The successor function on natural numbers, succ n = n + 1. This is one of the two constructors of Nat.
succ: Nat → Nat

The type of natural numbers, starting at zero. It is defined as an inductive type freely generated by "zero is a natural number" and "the successor of a natural number is a natural number".

You can prove a theorem P n about n : Nat by induction n, which will expect a proof of the theorem for P 0, and a proof of P (succ i) assuming a proof of P i. The same method also works to define functions by recursion on natural numbers: induction and recursion are two expressions of the same operation from lean's point of view.

open Nat
example (n : Nat) : n < succ n := by
  induction n with
  | zero =>
    show 0 < 1
    decide
  | succ i ih => -- ih : i < succ i
    show succ i < succ (succ i)
    exact Nat.succ_lt_succ ih

This type is special-cased by both the kernel and the compiler:

The type of expressions contains "Nat literals" as a primitive constructor, and the kernel knows how to reduce zero/succ expressions to nat literals.
If implemented naively, this type would represent a numeral n in unary as a linked list with n links, which is horribly inefficient. Instead, the runtime itself has a special representation for Nat which stores numbers up to 2^63 directly and larger numbers use an arbitrary precision "bignum" library (usually GMP).

Instances For

instance instInhabitedNat :

Equations

instInhabitedNat = { default := Nat.zero }

class OfNat (α : Type u) :

Nat → Type u

The OfNat.ofNat function is automatically inserted by the parser when the user writes a numeric literal like 1 : α. Implementations of this typeclass can therefore customize the behavior of n : α based on n and α.
ofNat : α

The class OfNat α n powers the numeric literal parser. If you write 37 : α, lean will attempt to synthesize OfNat α 37, and will generate the term (OfNat.ofNat 37 : α).

There is a bit of infinite regress here since the desugaring apparently still contains a literal 37 in it. The type of expressions contains a primitive constructor for "raw natural number literals", which you can directly access using the macro nat_lit 37. Raw number literals are always of type Nat. So it would be more correct to say that lean looks for an instance of OfNat α (nat_lit 37), and it generates the term (OfNat.ofNat (nat_lit 37) : α).

Instances

@[defaultInstance 100]

instance instOfNatNat (n : Nat) :

Equations

instOfNatNat n = { ofNat := n }

class LE (α : Type u) :

The less-equal relation: x ≤ y
le : α → α → Prop

LE α is the typeclass which supports the notation x ≤ y where x y : α.

Instances

class LT (α : Type u) :

The less-than relation: x < y
lt : α → α → Prop

LT α is the typeclass which supports the notation x < y where x y : α.

Instances

def GE.ge {α : Type u} [inst : LE α] (a : α) (b : α) :

a ≥ b is an abbreviation for b ≤ a.

Equations

(a ≥ b) = (b ≤ a)

def GT.gt {α : Type u} [inst : LT α] (a : α) (b : α) :

a > b is an abbreviation for b < a.

Equations

(a > b) = (b < a)

class Max (α : Type u) :

The maximum operation: max x y.
max : α → α → α

Max α is the typeclass which supports the operation max x y where x y : α.

Instances

@[inline]

def maxOfLe {α : Type u_1} [inst : LE α] [inst : DecidableRel LE.le] :

Max α

Implementation of the max operation using ≤.

Equations

maxOfLe = { max := fun x y => if x ≤ y then y else x }

class Min (α : Type u) :

The minimum operation: min x y.
min : α → α → α

Min α is the typeclass which supports the operation min x y where x y : α.

Instances

@[inline]

def minOfLe {α : Type u_1} [inst : LE α] [inst : DecidableRel LE.le] :

Min α

Implementation of the min operation using ≤.

Equations

minOfLe = { min := fun x y => if x ≤ y then x else y }

class Trans {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (r : α → β → Sort u) (s : β → γ → Sort v) (t : outParam (α → γ → Sort w)) :

Sort (max(max(max(max(max(max1u)u_1)u_2)u_3)v)w)

Compose two proofs by transitivity, generalized over the relations involved.
trans : {a : α} → {b : β} → {c : γ} → r a b → s b c → t a c

Transitive chaining of proofs, used e.g. by calc.

It takes two relations r and s as "input", and produces an "output" relation t, with the property that r a b and s b c implies t a c. The calc tactic uses this so that when it sees a chain with a ≤ b and b < c it knows that this should be a proof of a < c because there is an instance Trans (·≤·) (·<·) (·<·).

Instances

instance instTransEq {α : Sort u_1} {γ : Sort u_2} (r : α → γ → Sort u) :

Trans Eq r r

Equations

instTransEq r = { trans := fun {a b} {c} heq h' => (_ : b = a) ▸ h' }

instance instTransEq_1 {α : Sort u_1} {β : Sort u_2} (r : α → β → Sort u) :

Trans r Eq r

Equations

instTransEq_1 r = { trans := fun {a} {b c} h' heq => heq ▸ h' }

class HAdd (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a + b computes the sum of a and b. The meaning of this notation is type-dependent.
hAdd : α → β → γ

The notation typeclass for heterogeneous addition. This enables the notation a + b : γ where a : α, b : β.

Instances

class HSub (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a - b computes the difference of a and b. The meaning of this notation is type-dependent.
- For natural numbers, this operator saturates at 0: a - b = 0 when a ≤ b.
hSub : α → β → γ

The notation typeclass for heterogeneous subtraction. This enables the notation a - b : γ where a : α, b : β.

Instances

class HMul (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a * b computes the product of a and b. The meaning of this notation is type-dependent.
hMul : α → β → γ

The notation typeclass for heterogeneous multiplication. This enables the notation a * b : γ where a : α, b : β.

Instances

class HDiv (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a / b computes the result of dividing a by b. The meaning of this notation is type-dependent.
- For most types like Nat, Int, Rat, Real, a / 0 is defined to be 0.
- For Nat and Int, a / b rounds toward 0.
- For Float, a / 0 follows the IEEE 754 semantics for division, usually resulting in inf or nan.
hDiv : α → β → γ

The notation typeclass for heterogeneous division. This enables the notation a / b : γ where a : α, b : β.

Instances

class HMod (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a % b computes the remainder upon dividing a by b. The meaning of this notation is type-dependent.
- For Nat and Int, a % 0 is defined to be a.
hMod : α → β → γ

The notation typeclass for heterogeneous modulo / remainder. This enables the notation a % b : γ where a : α, b : β.

Instances

class HPow (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a ^ b computes a to the power of b. The meaning of this notation is type-dependent.
hPow : α → β → γ

The notation typeclass for heterogeneous exponentiation. This enables the notation a ^ b : γ where a : α, b : β.

Instances

class HAppend (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a ++ b is the result of concatenation of a and b, usually read "append". The meaning of this notation is type-dependent.
hAppend : α → β → γ

The notation typeclass for heterogeneous append. This enables the notation a ++ b : γ where a : α, b : β.

Instances

class HOrElse (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a <|> b executes a and returns the result, unless it fails in which case it executes and returns b. Because b is not always executed, it is passed as a thunk so it can be forced only when needed. The meaning of this notation is type-dependent.
hOrElse : α → (Unit → β) → γ

The typeclass behind the notation a <|> b : γ where a : α, b : β. Because b is "lazy" in this notation, it is passed as Unit → β to the implementation so it can decide when to evaluate it.

Instances

class HAndThen (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a >> b executes a, ignores the result, and then executes b. If a fails then b is not executed. Because b is not always executed, it is passed as a thunk so it can be forced only when needed. The meaning of this notation is type-dependent.
hAndThen : α → (Unit → β) → γ

The typeclass behind the notation a >> b : γ where a : α, b : β. Because b is "lazy" in this notation, it is passed as Unit → β to the implementation so it can decide when to evaluate it.

Instances

class HAnd (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a &&& b computes the bitwise AND of a and b. The meaning of this notation is type-dependent.
hAnd : α → β → γ

The typeclass behind the notation a &&& b : γ where a : α, b : β.

Instances

class HXor (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a ^^^ b computes the bitwise XOR of a and b. The meaning of this notation is type-dependent.
hXor : α → β → γ

The typeclass behind the notation a ^^^ b : γ where a : α, b : β.

Instances

class HOr (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a ||| b computes the bitwise OR of a and b. The meaning of this notation is type-dependent.
hOr : α → β → γ

The typeclass behind the notation a ||| b : γ where a : α, b : β.

Instances

class HShiftLeft (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a <<< b computes a shifted to the left by b places. The meaning of this notation is type-dependent.
- On Nat, this is equivalent to a * 2 ^ b.
- On UInt8 and other fixed width unsigned types, this is the same but truncated to the bit width.
hShiftLeft : α → β → γ

The typeclass behind the notation a <<< b : γ where a : α, b : β.

Instances

class HShiftRight (α : Type u) (β : Type v) (γ : outParam (Type w)) :

Type (max(maxuv)w)

a >>> b computes a shifted to the right by b places. The meaning of this notation is type-dependent.
- On Nat and fixed width unsigned types like UInt8, this is equivalent to a / 2 ^ b.
hShiftRight : α → β → γ

The typeclass behind the notation a >>> b : γ where a : α, b : β.

Instances

class Add (α : Type u) :

a + b computes the sum of a and b. See HAdd.
add : α → α → α

The homogeneous version of HAdd: a + b : α where a b : α.

Instances

class Sub (α : Type u) :

a - b computes the difference of a and b. See HSub.
sub : α → α → α

The homogeneous version of HSub: a - b : α where a b : α.

Instances

class Mul (α : Type u) :

a * b computes the product of a and b. See HMul.
mul : α → α → α

The homogeneous version of HMul: a * b : α where a b : α.

Instances

class Neg (α : Type u) :

-a computes the negative or opposite of a. The meaning of this notation is type-dependent.
neg : α → α

The notation typeclass for negation. This enables the notation -a : α where a : α.

Instances

class Div (α : Type u) :

a / b computes the result of dividing a by b. See HDiv.
div : α → α → α

The homogeneous version of HDiv: a / b : α where a b : α.

Instances

class Mod (α : Type u) :

a % b computes the remainder upon dividing a by b. See HMod.
mod : α → α → α

The homogeneous version of HMod: a % b : α where a b : α.

Instances

class Pow (α : Type u) (β : Type v) :

Type (maxuv)

a ^ b computes a to the power of b. See HPow.
pow : α → β → α

The homogeneous version of HPow: a ^ b : α where a : α, b : β. (The right argument is not the same as the left since we often want this even in the homogeneous case.)

Instances

class Append (α : Type u) :

a ++ b is the result of concatenation of a and b. See HAppend.
append : α → α → α

The homogeneous version of HAppend: a ++ b : α where a b : α.

Instances

class OrElse (α : Type u) :

The implementation of a <|> b : α. See HOrElse.
orElse : α → (Unit → α) → α

The homogeneous version of HOrElse: a <|> b : α where a b : α. Because b is "lazy" in this notation, it is passed as Unit → α to the implementation so it can decide when to evaluate it.

Instances

class AndThen (α : Type u) :

The implementation of a >> b : α. See HAndThen.
andThen : α → (Unit → α) → α

The homogeneous version of HAndThen: a >> b : α where a b : α. Because b is "lazy" in this notation, it is passed as Unit → α to the implementation so it can decide when to evaluate it.

Instances

class AndOp (α : Type u) :

The implementation of a &&& b : α. See HAnd.
and : α → α → α

The homogeneous version of HAnd: a &&& b : α where a b : α. (It is called AndOp because And is taken for the propositional connective.)

Instances

class Xor (α : Type u) :

The implementation of a ^^^ b : α. See HXor.
xor : α → α → α

The homogeneous version of HXor: a ^^^ b : α where a b : α.

Instances

class OrOp (α : Type u) :

The implementation of a ||| b : α. See HOr.
or : α → α → α

The homogeneous version of HOr: a ||| b : α where a b : α. (It is called OrOp because Or is taken for the propositional connective.)

Instances

class Complement (α : Type u) :

The implementation of ~~~a : α.
complement : α → α

The typeclass behind the notation ~~~a : α where a : α.

Instances

class ShiftLeft (α : Type u) :

The implementation of a <<< b : α. See HShiftLeft.
shiftLeft : α → α → α

The homogeneous version of HShiftLeft: a <<< b : α where a b : α.

Instances

class ShiftRight (α : Type u) :

The implementation of a >>> b : α. See HShiftRight.
shiftRight : α → α → α

The homogeneous version of HShiftRight: a >>> b : α where a b : α.

Instances

@[defaultInstance 1000]

instance instHAdd {α : Type u_1} [inst : Add α] :

HAdd α α α

Equations

instHAdd = { hAdd := fun a b => Add.add a b }

@[defaultInstance 1000]

instance instHSub {α : Type u_1} [inst : Sub α] :

HSub α α α

Equations

instHSub = { hSub := fun a b => Sub.sub a b }

@[defaultInstance 1000]

instance instHMul {α : Type u_1} [inst : Mul α] :

HMul α α α

Equations

instHMul = { hMul := fun a b => Mul.mul a b }

@[defaultInstance 1000]

instance instHDiv {α : Type u_1} [inst : Div α] :

HDiv α α α

Equations

instHDiv = { hDiv := fun a b => Div.div a b }

@[defaultInstance 1000]

instance instHMod {α : Type u_1} [inst : Mod α] :

HMod α α α

Equations

instHMod = { hMod := fun a b => Mod.mod a b }

@[defaultInstance 1000]

instance instHPow {α : Type u_1} {β : Type u_2} [inst : Pow α β] :

HPow α β α

Equations

instHPow = { hPow := fun a b => Pow.pow a b }

@[defaultInstance 1000]

instance instHAppend {α : Type u_1} [inst : Append α] :

HAppend α α α

Equations

instHAppend = { hAppend := fun a b => Append.append a b }

@[defaultInstance 1000]

instance instHOrElse {α : Type u_1} [inst : OrElse α] :

HOrElse α α α

Equations

instHOrElse = { hOrElse := fun a b => OrElse.orElse a b }

@[defaultInstance 1000]

instance instHAndThen {α : Type u_1} [inst : AndThen α] :

HAndThen α α α

Equations

instHAndThen = { hAndThen := fun a b => AndThen.andThen a b }

@[defaultInstance 1000]

instance instHAnd {α : Type u_1} [inst : AndOp α] :

HAnd α α α

Equations

instHAnd = { hAnd := fun a b => AndOp.and a b }

@[defaultInstance 1000]

instance instHXor {α : Type u_1} [inst : Xor α] :

HXor α α α

Equations

instHXor = { hXor := fun a b => Xor.xor a b }

@[defaultInstance 1000]

instance instHOr {α : Type u_1} [inst : OrOp α] :

HOr α α α

Equations

instHOr = { hOr := fun a b => OrOp.or a b }

@[defaultInstance 1000]

instance instHShiftLeft {α : Type u_1} [inst : ShiftLeft α] :

HShiftLeft α α α

Equations

instHShiftLeft = { hShiftLeft := fun a b => ShiftLeft.shiftLeft a b }

@[defaultInstance 1000]

instance instHShiftRight {α : Type u_1} [inst : ShiftRight α] :

HShiftRight α α α

Equations

instHShiftRight = { hShiftRight := fun a b => ShiftRight.shiftRight a b }

class Membership (α : outParam (Type u)) (γ : Type v) :

Type (maxuv)

The membership relation a ∈ s : Prop where a : α, s : γ.
mem : α → γ → Prop

The typeclass behind the notation a ∈ s : Prop where a : α, s : γ. Because α is an outParam, the "container type" γ determines the type of the elements of the container.

Instances

@[match_pattern, extern lean_nat_add]

Nat → Nat → Nat

Addition of natural numbers.

This definition is overridden in both the kernel and the compiler to efficiently evaluate using the "bignum" representation (see Nat). The definition provided here is the logical model (and it is soundness-critical that they coincide).

Equations

Nat.add x Nat.zero = x
Nat.add x (Nat.succ b) = Nat.succ (Nat.add x b)

instance instAddNat :

Equations

instAddNat = { add := Nat.add }

@[extern lean_nat_mul]

Nat → Nat → Nat

Multiplication of natural numbers.

This definition is overridden in both the kernel and the compiler to efficiently evaluate using the "bignum" representation (see Nat). The definition provided here is the logical model (and it is soundness-critical that they coincide).

Equations

Nat.mul x 0 = 0
Nat.mul x (Nat.succ b) = Nat.add (Nat.mul x b) x

instance instMulNat :

Equations

instMulNat = { mul := Nat.mul }

@[extern lean_nat_pow]

def Nat.pow (m : Nat) :

The power operation on natural numbers.

This definition is overridden in the compiler to efficiently evaluate using the "bignum" representation (see Nat). The definition provided here is the logical model.

Equations

Nat.pow m 0 = 1
Nat.pow m (Nat.succ n) = Nat.mul (Nat.pow m n) m

instance instPowNat :

Equations

instPowNat = { pow := Nat.pow }

@[extern lean_nat_dec_eq]

Nat → Nat → Bool

(Boolean) equality of natural numbers.

This definition is overridden in both the kernel and the compiler to efficiently evaluate using the "bignum" representation (see Nat). The definition provided here is the logical model (and it is soundness-critical that they coincide).

Equations

Nat.beq Nat.zero Nat.zero = true
Nat.beq Nat.zero (Nat.succ n) = false
Nat.beq (Nat.succ n) Nat.zero = false
Nat.beq (Nat.succ n) (Nat.succ m) = Nat.beq n m

instance instBEqNat :

Equations

instBEqNat = { beq := Nat.beq }

theorem Nat.eq_of_beq_eq_true {n : Nat} {m : Nat} :

Nat.beq n m = true → n = m

theorem Nat.ne_of_beq_eq_false {n : Nat} {m : Nat} :

Nat.beq n m = false → ¬n = m

@[extern lean_nat_dec_eq]

def Nat.decEq (n : Nat) (m : Nat) :

Decidable (n = m)

A decision procedure for equality of natural numbers.

This definition is overridden in the compiler to efficiently evaluate using the "bignum" representation (see Nat). The definition provided here is the logical model.

Equations

Nat.decEq n m = match h : Nat.beq n m with | true => isTrue (_ : n = m) | false => isFalse (_ : ¬n = m)

@[inline]

instance instDecidableEqNat :

DecidableEq Nat

Equations

instDecidableEqNat = Nat.decEq

@[extern lean_nat_dec_le]

Nat → Nat → Bool

The (Boolean) less-equal relation on natural numbers.

This definition is overridden in both the kernel and the compiler to efficiently evaluate using the "bignum" representation (see Nat). The definition provided here is the logical model (and it is soundness-critical that they coincide).

Equations

Nat.ble Nat.zero Nat.zero = true
Nat.ble Nat.zero (Nat.succ n) = true
Nat.ble (Nat.succ n) Nat.zero = false
Nat.ble (Nat.succ n) (Nat.succ m) = Nat.ble n m

inductive Nat.le (n : Nat) :

Less-equal is reflexive: n ≤ n
refl: ∀ {n : Nat}, Nat.le n n
If n ≤ m, then n ≤ m + 1.
step: ∀ {n m : Nat}, Nat.le n m → Nat.le n (Nat.succ m)

An inductive definition of the less-equal relation on natural numbers, characterized as the least relation ≤ such that n ≤ n and n ≤ m → n ≤ m + 1.

Instances For

instance instLENat :

Equations

instLENat = { le := Nat.le }

def Nat.lt (n : Nat) (m : Nat) :

The strict less than relation on natural numbers is defined as n < m := n + 1 ≤ m.

Equations

Nat.lt n m = Nat.le (Nat.succ n) m

instance instLTNat :

Equations

instLTNat = { lt := Nat.lt }

theorem Nat.not_succ_le_zero (n : Nat) :

Nat.succ n ≤ 0 → False

theorem Nat.not_lt_zero (n : Nat) :

¬n < 0

@[simp]

theorem Nat.zero_le (n : Nat) :

0 ≤ n

theorem Nat.succ_le_succ {n : Nat} {m : Nat} :

n ≤ m → Nat.succ n ≤ Nat.succ m

theorem Nat.zero_lt_succ (n : Nat) :

theorem Nat.le_step {n : Nat} {m : Nat} (h : n ≤ m) :

n ≤ Nat.succ m

theorem Nat.le_trans {n : Nat} {m : Nat} {k : Nat} :

n ≤ m → m ≤ k → n ≤ k

theorem Nat.lt_trans {n : Nat} {m : Nat} {k : Nat} (h₁ : n < m) :

m < k → n < k

theorem Nat.le_succ (n : Nat) :

n ≤ Nat.succ n

theorem Nat.le_succ_of_le {n : Nat} {m : Nat} (h : n ≤ m) :

n ≤ Nat.succ m

@[simp]

theorem Nat.le_refl (n : Nat) :

n ≤ n

theorem Nat.succ_pos (n : Nat) :

@[extern c inline "lean_nat_sub(#1, lean_box(1))"]

The predecessor function on natural numbers.

This definition is overridden in the compiler to use n - 1 instead. The definition provided here is the logical model.

Equations

Nat.pred x = match x with | 0 => 0 | Nat.succ a => a

theorem Nat.pred_le_pred {n : Nat} {m : Nat} :

n ≤ m → Nat.pred n ≤ Nat.pred m

theorem Nat.le_of_succ_le_succ {n : Nat} {m : Nat} :

Nat.succ n ≤ Nat.succ m → n ≤ m

theorem Nat.le_of_lt_succ {m : Nat} {n : Nat} :

m < Nat.succ n → m ≤ n

theorem Nat.eq_or_lt_of_le {n : Nat} {m : Nat} :

n ≤ m → n = m ∨ n < m

theorem Nat.lt_or_ge (n : Nat) (m : Nat) :

n < m ∨ n ≥ m

theorem Nat.not_succ_le_self (n : Nat) :

¬Nat.succ n ≤ n

@[simp]

theorem Nat.lt_irrefl (n : Nat) :

¬n < n

theorem Nat.lt_of_le_of_lt {n : Nat} {m : Nat} {k : Nat} (h₁ : n ≤ m) (h₂ : m < k) :

n < k

theorem Nat.le_antisymm {n : Nat} {m : Nat} (h₁ : n ≤ m) (h₂ : m ≤ n) :

n = m

theorem Nat.lt_of_le_of_ne {n : Nat} {m : Nat} (h₁ : n ≤ m) (h₂ : ¬n = m) :

n < m

theorem Nat.le_of_ble_eq_true {n : Nat} {m : Nat} (h : Nat.ble n m = true) :

n ≤ m

theorem Nat.ble_self_eq_true (n : Nat) :

Nat.ble n n = true

theorem Nat.ble_succ_eq_true {n : Nat} {m : Nat} :

Nat.ble n m = true → Nat.ble n (Nat.succ m) = true

theorem Nat.ble_eq_true_of_le {n : Nat} {m : Nat} (h : n ≤ m) :

Nat.ble n m = true

theorem Nat.not_le_of_not_ble_eq_true {n : Nat} {m : Nat} (h : ¬Nat.ble n m = true) :

@[extern lean_nat_dec_le]

instance Nat.decLe (n : Nat) (m : Nat) :

Decidable (n ≤ m)

Equations

Nat.decLe n m = if h : Nat.ble n m = true then isTrue (_ : n ≤ m) else isFalse (_ : ¬n ≤ m)

@[extern lean_nat_dec_lt]

instance Nat.decLt (n : Nat) (m : Nat) :

Decidable (n < m)

Equations

Nat.decLt n m = Nat.decLe (Nat.succ n) m

@[extern lean_nat_sub]

Nat → Nat → Nat

(Truncated) subtraction of natural numbers. Because natural numbers are not closed under subtraction, we define m - n to be 0 when n < m.

This definition is overridden in both the kernel and the compiler to efficiently evaluate using the "bignum" representation (see Nat). The definition provided here is the logical model (and it is soundness-critical that they coincide).

Equations

Nat.sub x 0 = x
Nat.sub x (Nat.succ b) = Nat.pred (Nat.sub x b)

instance instSubNat :

Equations

instSubNat = { sub := Nat.sub }

@[extern lean_system_platform_nbits]

opaque System.Platform.getNumBits :

Unit → { n // n = 32 ∨ n = 64 }

Gets the word size of the platform. That is, whether the platform is 64 or 32 bits.

This function is opaque because we cannot guarantee at compile time that the target will have the same size as the host, and also because we would like to avoid typechecking being architecture-dependent. Nevertheless, lean only works on 64 and 32 bit systems so we can encode this as a fact available for proof purposes.

def System.Platform.numBits :

Gets the word size of the platform. That is, whether the platform is 64 or 32 bits.

Equations

System.Platform.numBits = (System.Platform.getNumBits ()).val

theorem System.Platform.numBits_eq :

System.Platform.numBits = 32 ∨ System.Platform.numBits = 64

structure Fin (n : Nat) :

If i : Fin n, then i.val : ℕ is the described number. It can also be written as i.1 or just i when the target type is known.
val : Nat
If i : Fin n, then i.2 is a proof that i.1 < n.
isLt : val < n

Fin n is a natural number i with the constraint that 0 ≤ i < n. It is the "canonical type with n elements".

Instances For

theorem Fin.eq_of_val_eq {n : Nat} {i : Fin n} {j : Fin n} :

i.val = j.val → i = j

theorem Fin.val_eq_of_eq {n : Nat} {i : Fin n} {j : Fin n} (h : i = j) :

i.val = j.val

theorem Fin.ne_of_val_ne {n : Nat} {i : Fin n} {j : Fin n} (h : ¬i.val = j.val) :

¬i = j

instance instDecidableEqFin (n : Nat) :

DecidableEq (Fin n)

Equations

instDecidableEqFin n i j = match decEq i.val j.val with | isTrue h => isTrue (_ : i = j) | isFalse h => isFalse (_ : ¬i = j)

instance instLTFin {n : Nat} :

LT (Fin n)

Equations

instLTFin = { lt := fun a b => a.val < b.val }

instance instLEFin {n : Nat} :

LE (Fin n)

Equations

instLEFin = { le := fun a b => a.val ≤ b.val }

instance Fin.decLt {n : Nat} (a : Fin n) (b : Fin n) :

Decidable (a < b)

Equations

Fin.decLt a b = Nat.decLt a.val b.val

instance Fin.decLe {n : Nat} (a : Fin n) (b : Fin n) :

Decidable (a ≤ b)

Equations

Fin.decLe a b = Nat.decLe a.val b.val

def UInt8.size :

The size of type UInt8, that is, 2^8 = 256.

Equations

UInt8.size = 256

structure UInt8 :

Unpack a UInt8 as a Nat less than 2^8. This function is overridden with a native implementation.
val : Fin UInt8.size

The type of unsigned 8-bit integers. This type has special support in the compiler to make it actually 8 bits rather than wrapping a Nat.

Instances For

@[extern lean_uint8_of_nat]

def UInt8.ofNatCore (n : Nat) (h : n < UInt8.size) :

Pack a Nat less than 2^8 into a UInt8. This function is overridden with a native implementation.

Equations

UInt8.ofNatCore n h = { val := { val := n, isLt := h } }

@[extern lean_uint8_dec_eq]

def UInt8.decEq (a : UInt8) (b : UInt8) :

Decidable (a = b)

Decides equality on UInt8. This function is overridden with a native implementation.

Equations

UInt8.decEq a b = match a, b with | { val := n }, { val := m } => if h : n = m then isTrue (_ : { val := n } = { val := m }) else isFalse (_ : { val := n } = { val := m } → False)

instance instDecidableEqUInt8 :

DecidableEq UInt8

Equations

instDecidableEqUInt8 = UInt8.decEq

instance instInhabitedUInt8 :

Inhabited UInt8

Equations

instInhabitedUInt8 = { default := UInt8.ofNatCore 0 instInhabitedUInt8.proof_1 }

def UInt16.size :

The size of type UInt16, that is, 2^16 = 65536.

Equations

UInt16.size = 65536

structure UInt16 :

Unpack a UInt16 as a Nat less than 2^16. This function is overridden with a native implementation.
val : Fin UInt16.size

The type of unsigned 16-bit integers. This type has special support in the compiler to make it actually 16 bits rather than wrapping a Nat.

Instances For

@[extern lean_uint16_of_nat]

def UInt16.ofNatCore (n : Nat) (h : n < UInt16.size) :

Pack a Nat less than 2^16 into a UInt16. This function is overridden with a native implementation.

Equations

UInt16.ofNatCore n h = { val := { val := n, isLt := h } }

@[extern lean_uint16_dec_eq]

def UInt16.decEq (a : UInt16) (b : UInt16) :

Decidable (a = b)

Decides equality on UInt16. This function is overridden with a native implementation.

Equations

UInt16.decEq a b = match a, b with | { val := n }, { val := m } => if h : n = m then isTrue (_ : { val := n } = { val := m }) else isFalse (_ : { val := n } = { val := m } → False)

instance instDecidableEqUInt16 :

DecidableEq UInt16

Equations

instDecidableEqUInt16 = UInt16.decEq

instance instInhabitedUInt16 :

Inhabited UInt16

Equations

instInhabitedUInt16 = { default := UInt16.ofNatCore 0 instInhabitedUInt16.proof_1 }

def UInt32.size :

The size of type UInt32, that is, 2^32 = 4294967296.

Equations

UInt32.size = 4294967296

structure UInt32 :

Unpack a UInt32 as a Nat less than 2^32. This function is overridden with a native implementation.
val : Fin UInt32.size

The type of unsigned 32-bit integers. This type has special support in the compiler to make it actually 32 bits rather than wrapping a Nat.

Instances For

@[extern lean_uint32_of_nat]

def UInt32.ofNatCore (n : Nat) (h : n < UInt32.size) :

Pack a Nat less than 2^32 into a UInt32. This function is overridden with a native implementation.

Equations

UInt32.ofNatCore n h = { val := { val := n, isLt := h } }

@[extern lean_uint32_to_nat]

def UInt32.toNat (n : UInt32) :

Unpack a UInt32 as a Nat. This function is overridden with a native implementation.

Equations

UInt32.toNat n = n.val.val

@[extern lean_uint32_dec_eq]

def UInt32.decEq (a : UInt32) (b : UInt32) :

Decidable (a = b)

Decides equality on UInt32. This function is overridden with a native implementation.

Equations

UInt32.decEq a b = match a, b with | { val := n }, { val := m } => if h : n = m then isTrue (_ : { val := n } = { val := m }) else isFalse (_ : { val := n } = { val := m } → False)

instance instDecidableEqUInt32 :

DecidableEq UInt32

Equations

instDecidableEqUInt32 = UInt32.decEq

instance instInhabitedUInt32 :

Inhabited UInt32

Equations

instInhabitedUInt32 = { default := UInt32.ofNatCore 0 instInhabitedUInt32.proof_1 }

instance instLTUInt32 :

Equations

instLTUInt32 = { lt := fun a b => a.val < b.val }

instance instLEUInt32 :

Equations

instLEUInt32 = { le := fun a b => a.val ≤ b.val }

@[extern lean_uint32_dec_lt]

def UInt32.decLt (a : UInt32) (b : UInt32) :

Decidable (a < b)

Decides less-equal on UInt32. This function is overridden with a native implementation.

Equations

UInt32.decLt a b = match a, b with | { val := n }, { val := m } => inferInstanceAs (Decidable (n < m))

@[extern lean_uint32_dec_le]

def UInt32.decLe (a : UInt32) (b : UInt32) :

Decidable (a ≤ b)

Decides less-than on UInt32. This function is overridden with a native implementation.

Equations

UInt32.decLe a b = match a, b with | { val := n }, { val := m } => inferInstanceAs (Decidable (n ≤ m))

instance instDecidableLtUInt32InstLTUInt32 (a : UInt32) (b : UInt32) :

Decidable (a < b)

Equations

instDecidableLtUInt32InstLTUInt32 a b = UInt32.decLt a b

instance instDecidableLeUInt32InstLEUInt32 (a : UInt32) (b : UInt32) :

Decidable (a ≤ b)

Equations

instDecidableLeUInt32InstLEUInt32 a b = UInt32.decLe a b

instance instMaxUInt32 :

Equations

instMaxUInt32 = maxOfLe

instance instMinUInt32 :

Equations

instMinUInt32 = minOfLe

def UInt64.size :

The size of type UInt64, that is, 2^64 = 18446744073709551616.

Equations

UInt64.size = 18446744073709551616

structure UInt64 :

Unpack a UInt64 as a Nat less than 2^64. This function is overridden with a native implementation.
val : Fin UInt64.size

The type of unsigned 64-bit integers. This type has special support in the compiler to make it actually 64 bits rather than wrapping a Nat.

Instances For

@[extern lean_uint64_of_nat]

def UInt64.ofNatCore (n : Nat) (h : n < UInt64.size) :

Pack a Nat less than 2^64 into a UInt64. This function is overridden with a native implementation.

Equations

UInt64.ofNatCore n h = { val := { val := n, isLt := h } }

@[extern lean_uint64_dec_eq]

def UInt64.decEq (a : UInt64) (b : UInt64) :

Decidable (a = b)

Decides equality on UInt64. This function is overridden with a native implementation.

Equations

UInt64.decEq a b = match a, b with | { val := n }, { val := m } => if h : n = m then isTrue (_ : { val := n } = { val := m }) else isFalse (_ : { val := n } = { val := m } → False)

instance instDecidableEqUInt64 :

DecidableEq UInt64

Equations

instDecidableEqUInt64 = UInt64.decEq

instance instInhabitedUInt64 :

Inhabited UInt64

Equations

instInhabitedUInt64 = { default := UInt64.ofNatCore 0 instInhabitedUInt64.proof_1 }

def USize.size :

The size of type UInt16, that is, 2^System.Platform.numBits, which may be either 2^32 or 2^64 depending on the platform's architecture.

Equations

USize.size = 2 ^ System.Platform.numBits

theorem usize_size_eq :

USize.size = 4294967296 ∨ USize.size = 18446744073709551616

structure USize :

Unpack a USize as a Nat less than USize.size. This function is overridden with a native implementation.
val : Fin USize.size

A USize is an unsigned integer with the size of a word for the platform's architecture.

For example, if running on a 32-bit machine, USize is equivalent to UInt32. Or on a 64-bit machine, UInt64.

Instances For

@[extern lean_usize_of_nat]

def USize.ofNatCore (n : Nat) (h : n < USize.size) :

Pack a Nat less than USize.size into a USize. This function is overridden with a native implementation.

Equations

USize.ofNatCore n h = { val := { val := n, isLt := h } }

@[extern lean_usize_dec_eq]

def USize.decEq (a : USize) (b : USize) :

Decidable (a = b)

Decides equality on USize. This function is overridden with a native implementation.

Equations

USize.decEq a b = match a, b with | { val := n }, { val := m } => if h : n = m then isTrue (_ : { val := n } = { val := m }) else isFalse (_ : { val := n } = { val := m } → False)

instance instDecidableEqUSize :

DecidableEq USize

Equations

instDecidableEqUSize = USize.decEq

instance instInhabitedUSize :

Inhabited USize

Equations

instInhabitedUSize = { default := USize.ofNatCore 0 instInhabitedUSize.proof_1 }

@[extern lean_usize_of_nat]

def USize.ofNat32 (n : Nat) (h : n < 4294967296) :

Upcast a Nat less than 2^32 to a USize. This is lossless because USize.size is either 2^32 or 2^64. This function is overridden with a native implementation.

Equations

USize.ofNat32 n h = { val := { val := n, isLt := (_ : n < USize.size) } }

@[inline]

abbrev Nat.isValidChar (n : Nat) :

A Nat denotes a valid unicode codepoint if it is less than 0x110000, and it is also not a "surrogate" character (the range 0xd800 to 0xdfff inclusive).

Equations

Nat.isValidChar n = (n < 55296 ∨ 57343 < n ∧ n < 1114112)

@[inline]

abbrev UInt32.isValidChar (n : UInt32) :

A UInt32 denotes a valid unicode codepoint if it is less than 0x110000, and it is also not a "surrogate" character (the range 0xd800 to 0xdfff inclusive).

Equations

UInt32.isValidChar n = Nat.isValidChar (UInt32.toNat n)

structure Char :

The underlying unicode scalar value as a UInt32.
val : UInt32
The value must be a legal codepoint.
valid : UInt32.isValidChar val

The Char Type represents an unicode scalar value. See http://www.unicode.org/glossary/#unicode_scalar_value).

Instances For

@[extern lean_uint32_of_nat]

def Char.ofNatAux (n : Nat) (h : Nat.isValidChar n) :

Pack a Nat encoding a valid codepoint into a Char. This function is overridden with a native implementation.

Equations

Char.ofNatAux n h = { val := { val := { val := n, isLt := (_ : n < UInt32.size) } }, valid := h }

@[match_pattern, noinline]

def Char.ofNat (n : Nat) :

Convert a Nat into a Char. If the Nat does not encode a valid unicode scalar value, '\0' is returned instead.

Equations

Char.ofNat n = if h : Nat.isValidChar n then Char.ofNatAux n h else { val := { val := { val := 0, isLt := Char.ofNat.proof_1 } }, valid := Char.ofNat.proof_2 }

theorem Char.eq_of_val_eq {c : Char} {d : Char} :

c.val = d.val → c = d

theorem Char.val_eq_of_eq {c : Char} {d : Char} :

c = d → c.val = d.val

theorem Char.ne_of_val_ne {c : Char} {d : Char} (h : ¬c.val = d.val) :

¬c = d

theorem Char.val_ne_of_ne {c : Char} {d : Char} (h : ¬c = d) :

¬c.val = d.val

instance instDecidableEqChar :

DecidableEq Char

Equations

instDecidableEqChar c d = match decEq c.val d.val with | isTrue h => isTrue (_ : c = d) | isFalse h => isFalse (_ : ¬c = d)

def Char.utf8Size (c : Char) :

Returns the number of bytes required to encode this Char in UTF-8.

Equations

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

@[unbox]

inductive Option (α : Type u) :

No value.
none: {α : Type u} → Option α
Some value of type α.
some: {α : Type u} → α → Option α

Option α is the type of values which are either some a for some a : α, or none. In functional programming languages, this type is used to represent the possibility of failure, or sometimes nullability.

For example, the function HashMap.find? : HashMap α β → α → Option β looks up a specified key a : α inside the map. Because we do not know in advance whether the key is actually in the map, the return type is Option β, where none means the value was not in the map, and some b means that the value was found and b is the value retrieved.

To extract a value from an Option α, we use pattern matching:

def map (f : α → β) (x : Option α) : Option β :=
  match x with
  | some a => some (f a)
  | none => none

We can also use if let to pattern match on Option and get the value in the branch:

def map (f : α → β) (x : Option α) : Option β :=
  if let some a := x then
    some (f a)
  else
    none

Instances For

instance instInhabitedOption {α : Type u_1} :

Inhabited (Option α)

Equations

instInhabitedOption = { default := none }

@[macro_inline]

def Option.getD {α : Type u_1} :

Option α → α → α

Get with default. If opt : Option α and dflt : α, then opt.getD dflt returns a if opt = some a and dflt otherwise.

This function is @[macro_inline], so dflt will not be evaluated unless opt turns out to be none.

Equations

Option.getD x x = match x, x with | some x, x_1 => x | none, e => e

@[inline]

def Option.map {α : Type u_1} {β : Type u_2} (f : α → β) :

Option α → Option β

Map a function over an Option by applying the function to the contained value if present.

Equations

Option.map f x = match x with | some x => some (f x) | none => none

inductive List (α : Type u) :

[] is the empty list.
nil: {α : Type u} → List α
If a : α and l : List α, then cons a l, or a :: l, is the list whose first element is a and with l as the rest of the list.
cons: {α : Type u} → α → List α → List α

List α is the type of ordered lists with elements of type α. It is implemented as a linked list.

List α is isomorphic to Array α, but they are useful for different things:

List α is easier for reasoning, and Array α is modeled as a wrapper around List α
List α works well as a persistent data structure, when many copies of the tail are shared. When the value is not shared, Array α will have better performance because it can do destructive updates.

Instances For

instance instInhabitedList {α : Type u_1} :

Inhabited (List α)

Equations

instInhabitedList = { default := [] }

def List.hasDecEq {α : Type u} [inst : DecidableEq α] (a : List α) (b : List α) :

Decidable (a = b)

Implements decidable equality for List α, assuming α has decidable equality.

Equations

One or more equations did not get rendered due to their size.
List.hasDecEq [] [] = isTrue (_ : [] = [])
List.hasDecEq (head :: tail) [] = isFalse (_ : head :: tail = [] → List.noConfusionType False (head :: tail) [])
List.hasDecEq [] (head :: tail) = isFalse (_ : [] = head :: tail → List.noConfusionType False [] (head :: tail))

instance instDecidableEqList {α : Type u} [inst : DecidableEq α] :

DecidableEq (List α)

Equations

instDecidableEqList = List.hasDecEq

@[specialize #[]]

def List.foldl {α : Type u} {β : Type v} (f : α → β → α) (init : α) :

List β → α

Folds a function over a list from the left: foldl f z [a, b, c] = f (f (f z a) b) c

Equations

List.foldl f x [] = x
List.foldl f x (b :: l) = List.foldl f (f x b) l

def List.set {α : Type u_1} :

List α → Nat → α → List α

l.set n a sets the value of list l at (zero-based) index n to a: [a, b, c, d].set 1 b' = [a, b', c, d]

Equations

List.set (head :: as) 0 x = x :: as
List.set (a :: as) (Nat.succ n) x = a :: List.set as n x
List.set [] x x = []

def List.length {α : Type u_1} :

List α → Nat

The length of a list: [].length = 0 and (a :: l).length = l.length + 1.

This function is overridden in the compiler to lengthTR, which uses constant stack space, while leaving this function to use the "naive" recursion which is easier for reasoning.

Equations

List.length [] = 0
List.length (head :: as) = List.length as + 1

def List.lengthTRAux {α : Type u_1} :

List α → Nat → Nat

Auxiliary function for List.lengthTR.

Equations

List.lengthTRAux [] x = x
List.lengthTRAux (head :: as) x = List.lengthTRAux as (Nat.succ x)

def List.lengthTR {α : Type u_1} (as : List α) :

A tail-recursive version of List.length, used to implement List.length without running out of stack space.

Equations

List.lengthTR as = List.lengthTRAux as 0

@[simp]

theorem List.length_cons {α : Type u_1} (a : α) (as : List α) :

List.length (a :: as) = Nat.succ (List.length as)

def List.concat {α : Type u} :

List α → α → List α

l.concat a appends a at the end of l, that is, l ++ [a].

Equations

List.concat [] x = [x]
List.concat (a :: as) x = a :: List.concat as x

def List.get {α : Type u} (as : List α) :

Fin (List.length as) → α

as.get i returns the i'th element of the list as. This version of the function uses i : Fin as.length to ensure that it will not index out of bounds.

Equations

List.get (a :: tail) { val := 0, isLt := isLt } = a
List.get (head :: as) { val := Nat.succ i, isLt := h } = List.get as { val := i, isLt := (_ : Nat.succ i ≤ List.length as) }

structure String :

Unpack String into a List Char. This function is overridden by the compiler and is O(n) in the length of the list.
data : List Char

String is the type of (UTF-8 encoded) strings.

The compiler overrides the data representation of this type to a byte sequence, and both String.utf8ByteSize and String.length are cached and O(1).

Instances For

@[extern lean_string_dec_eq]

def String.decEq (s₁ : String) (s₂ : String) :

Decidable (s₁ = s₂)

Decides equality on String. This function is overridden with a native implementation.

Equations

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

instance instDecidableEqString :

DecidableEq String

Equations

instDecidableEqString = String.decEq

structure String.Pos :

Get the underlying byte index of a String.Pos
byteIdx : Nat

A byte position in a String. Internally, Strings are UTF-8 encoded. Codepoint positions (counting the Unicode codepoints rather than bytes) are represented by plain Nats instead. Indexing a String by a byte position is constant-time, while codepoint positions need to be translated internally to byte positions in linear-time.

Instances For

instance instInhabitedPos :

Inhabited String.Pos

Equations

instInhabitedPos = { default := { byteIdx := 0 } }

instance instDecidableEqPos :

DecidableEq String.Pos

Equations

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

structure Substring :

The underlying string to slice.
str : String
The byte position of the start of the string slice.
startPos : String.Pos
The byte position of the end of the string slice.
stopPos : String.Pos

A Substring is a view into some subslice of a String. The actual string slicing is deferred because this would require copying the string; here we only store a reference to the original string for garbage collection purposes.

Instances For

instance instInhabitedSubstring :

Inhabited Substring

Equations

instInhabitedSubstring = { default := { str := "", startPos := { byteIdx := 0 }, stopPos := { byteIdx := 0 } } }

@[inline]

def Substring.bsize :

Substring → Nat

The byte length of the substring.

Equations

Substring.bsize x = match x with | { str := str, startPos := b, stopPos := e } => Nat.sub e.byteIdx b.byteIdx

def String.csize (c : Char) :

Returns the number of bytes required to encode this Char in UTF-8.

Equations

String.csize c = UInt32.toNat (Char.utf8Size c)

@[extern lean_string_utf8_byte_size]

def String.utf8ByteSize :

The UTF-8 byte length of this string. This is overridden by the compiler to be cached and O(1).

Equations

String.utf8ByteSize x = match x with | { data := s } => String.utf8ByteSize.go s

def String.utf8ByteSize.go :

List Char → Nat

Equations

String.utf8ByteSize.go [] = 0
String.utf8ByteSize.go (c :: cs) = String.utf8ByteSize.go cs + String.csize c

instance instHAddPos :

HAdd String.Pos String.Pos String.Pos

Equations

instHAddPos = { hAdd := fun p₁ p₂ => { byteIdx := p₁.byteIdx + p₂.byteIdx } }

instance instHSubPos :

HSub String.Pos String.Pos String.Pos

Equations

instHSubPos = { hSub := fun p₁ p₂ => { byteIdx := p₁.byteIdx - p₂.byteIdx } }

instance instHAddPosChar :

HAdd String.Pos Char String.Pos

Equations

instHAddPosChar = { hAdd := fun p c => { byteIdx := p.byteIdx + String.csize c } }

instance instHAddPosString :

HAdd String.Pos String String.Pos

Equations

instHAddPosString = { hAdd := fun p s => { byteIdx := p.byteIdx + String.utf8ByteSize s } }

instance instLEPos :

Equations

instLEPos = { le := fun p₁ p₂ => p₁.byteIdx ≤ p₂.byteIdx }

instance instLTPos :

Equations

instLTPos = { lt := fun p₁ p₂ => p₁.byteIdx < p₂.byteIdx }

instance instDecidableLePosInstLEPos (p₁ : String.Pos) (p₂ : String.Pos) :

Decidable (p₁ ≤ p₂)

Equations

instDecidableLePosInstLEPos p₁ p₂ = inferInstanceAs (Decidable (p₁.byteIdx ≤ p₂.byteIdx))

instance instDecidableLtPosInstLTPos (p₁ : String.Pos) (p₂ : String.Pos) :

Decidable (p₁ < p₂)

Equations

instDecidableLtPosInstLTPos p₁ p₂ = inferInstanceAs (Decidable (p₁.byteIdx < p₂.byteIdx))

@[inline]

def String.endPos (s : String) :

A String.Pos pointing at the end of this string.

Equations

String.endPos s = { byteIdx := String.utf8ByteSize s }

@[inline]

def String.toSubstring (s : String) :

Convert a String into a Substring denoting the entire string.

Equations

String.toSubstring s = { str := s, startPos := { byteIdx := 0 }, stopPos := String.endPos s }

def String.toSubstring' (s : String) :

String.toSubstring without [inline] annotation.

Equations

String.toSubstring' s = String.toSubstring s

unsafe def unsafeCast {α : Sort u} {β : Sort v} (a : α) :

β

This function will cast a value of type α to type β, and is a no-op in the compiler. This function is extremely dangerous because there is no guarantee that types α and β have the same data representation, and this can lead to memory unsafety. It is also logically unsound, since you could just cast True to False. For all those reasons this function is marked as unsafe.

It is implemented by lifting both α and β into a common universe, and then using cast (lcProof : ULift (PLift α) = ULift (PLift β)) to actually perform the cast. All these operations are no-ops in the compiler.

Using this function correctly requires some knowledge of the data representation of the source and target types. Some general classes of casts which are safe in the current runtime:

Array α to Array β where α and β have compatible representations, or more generally for other inductive types.
Quot α r and α.
@Subtype α p and α, or generally any structure containing only one non-Prop field of type α.
Casting α to/from NonScalar when α is a boxed generic type (i.e. a function that accepts an arbitrary type α and is not specialized to a scalar type like UInt8).

Equations

unsafeCast a = (cast (_ : ULift (PLift α) = ULift (PLift β)) { down := { down := a } }).down.down

@[never_extract, extern lean_panic_fn]

def panicCore {α : Type u} [inst : Inhabited α] (msg : String) :

α

Auxiliary definition for panic.

Equations

panicCore msg = default

@[never_extract, noinline]

def panic {α : Type u} [inst : Inhabited α] (msg : String) :

α

(panic "msg" : α) has a built-in implementation which prints msg to the error buffer. It does not terminate execution, and because it is a safe function, it still has to return an element of α, so it takes [Inhabited α] and returns default. It is primarily intended for debugging in pure contexts, and assertion failures.

Because this is a pure function with side effects, it is marked as @[never_extract] so that the compiler will not perform common sub-expression elimination and other optimizations that assume that the expression is pure.

Equations

panic msg = panicCore msg

class GetElem (cont : Type u) (idx : Type v) (elem : outParam (Type w)) (dom : outParam (cont → idx → Prop)) :

Type (max(maxuv)w)

The syntax arr[i] gets the i'th element of the collection arr. If there are proof side conditions to the application, they will be automatically inferred by the get_elem_tactic tactic.
The actual behavior of this class is type-dependent, but here are some important implementations:
- arr[i] : α where arr : Array α and i : Nat or i : USize: does array indexing with no bounds check and a proof side goal i < arr.size.
- l[i] : α where l : List α and i : Nat: index into a list, with proof side goal i < l.length.
- stx[i] : Syntax where stx : Syntax and i : Nat: get a syntax argument, no side goal (returns .missing out of range)
There are other variations on this syntax:
- arr[i]: proves the proof side goal by get_elem_tactic
- arr[i]!: panics if the side goal is false
- arr[i]?: returns none if the side goal is false
- arr[i]'h: uses h to prove the side goal
getElem : (xs : cont) → (i : idx) → dom xs i → elem

The class GetElem cont idx elem dom implements the xs[i] notation. When you write this, given xs : cont and i : idx, lean looks for an instance of GetElem cont idx elem dom. Here elem is the type of xs[i], while dom is whatever proof side conditions are required to make this applicable. For example, the instance for arrays looks like GetElem (Array α) Nat α (fun xs i => i < xs.size).

The proof side-condition dom xs i is automatically dispatched by the get_elem_tactic tactic, which can be extended by adding more clauses to get_elem_tactic_trivial.

Instances

structure Array (α : Type u) :

Convert an Array α into a List α. This function is overridden to Array.toList and is O(n) in the length of the list.
data : List α

Array α is the type of dynamic arrays with elements from α. This type has special support in the runtime.

An array has a size and a capacity; the size is Array.size but the capacity is not observable from lean code. Arrays perform best when unshared; as long as they are used "linearly" all updates will be performed destructively on the array, so it has comparable performance to mutable arrays in imperative programming languages.

Instances For

@[extern lean_mk_empty_array_with_capacity]

def Array.mkEmpty {α : Type u} (c : Nat) :

Construct a new empty array with initial capacity c.

Equations

Array.mkEmpty c = { data := [] }

def Array.empty {α : Type u} :

Construct a new empty array.

Equations

#[] = Array.mkEmpty 0

@[extern lean_array_get_size]

def Array.size {α : Type u} (a : Array α) :

Get the size of an array. This is a cached value, so it is O(1) to access.

Equations

Array.size a = List.length a.data

@[extern lean_array_fget]

def Array.get {α : Type u} (a : Array α) (i : Fin (Array.size a)) :

α

Access an element from an array without bounds checks, using a Fin index.

Equations

Array.get a i = List.get a.data i

@[inline]

abbrev Array.getD {α : Type u_1} (a : Array α) (i : Nat) (v₀ : α) :

α

Access an element from an array, or return v₀ if the index is out of bounds.

Equations

Array.getD a i v₀ = if h : i < Array.size a then Array.get a { val := i, isLt := h } else v₀

@[extern lean_array_get]

def Array.get! {α : Type u} [inst : Inhabited α] (a : Array α) (i : Nat) :

α

Access an element from an array, or panic if the index is out of bounds.

Equations

Array.get! a i = Array.getD a i default

instance instGetElemArrayNatLtInstLTNatSize {α : Type u_1} :

GetElem (Array α) Nat α fun xs i => i < Array.size xs

Equations

instGetElemArrayNatLtInstLTNatSize = { getElem := fun xs i h => Array.get xs { val := i, isLt := h } }

@[extern lean_array_push]

def Array.push {α : Type u} (a : Array α) (v : α) :

Push an element onto the end of an array. This is amortized O(1) because Array α is internally a dynamic array.

Equations

Array.push a v = { data := List.concat a.data v }

def Array.mkArray0 {α : Type u} :

Create array #[]

Equations

#[] = Array.mkEmpty 0

def Array.mkArray1 {α : Type u} (a₁ : α) :

Create array #[a₁]

Equations

#[a₁] = Array.push (Array.mkEmpty 1) a₁

def Array.mkArray2 {α : Type u} (a₁ : α) (a₂ : α) :

Create array #[a₁, a₂]

Equations

#[a₁, a₂] = Array.push (Array.push (Array.mkEmpty 2) a₁) a₂

def Array.mkArray3 {α : Type u} (a₁ : α) (a₂ : α) (a₃ : α) :

Create array #[a₁, a₂, a₃]

Equations

#[a₁, a₂, a₃] = Array.push (Array.push (Array.push (Array.mkEmpty 3) a₁) a₂) a₃

def Array.mkArray4 {α : Type u} (a₁ : α) (a₂ : α) (a₃ : α) (a₄ : α) :

Create array #[a₁, a₂, a₃, a₄]

Equations

#[a₁, a₂, a₃, a₄] = Array.push (Array.push (Array.push (Array.push (Array.mkEmpty 4) a₁) a₂) a₃) a₄

def Array.mkArray5 {α : Type u} (a₁ : α) (a₂ : α) (a₃ : α) (a₄ : α) (a₅ : α) :

Create array #[a₁, a₂, a₃, a₄, a₅]

Equations

#[a₁, a₂, a₃, a₄, a₅] = Array.push (Array.push (Array.push (Array.push (Array.push (Array.mkEmpty 5) a₁) a₂) a₃) a₄) a₅

def Array.mkArray6 {α : Type u} (a₁ : α) (a₂ : α) (a₃ : α) (a₄ : α) (a₅ : α) (a₆ : α) :

Create array #[a₁, a₂, a₃, a₄, a₅, a₆]

Equations

#[a₁, a₂, a₃, a₄, a₅, a₆] = Array.push (Array.push (Array.push (Array.push (Array.push (Array.push (Array.mkEmpty 6) a₁) a₂) a₃) a₄) a₅) a₆

def Array.mkArray7 {α : Type u} (a₁ : α) (a₂ : α) (a₃ : α) (a₄ : α) (a₅ : α) (a₆ : α) (a₇ : α) :

Create array #[a₁, a₂, a₃, a₄, a₅, a₆, a₇]

Equations

#[a₁, a₂, a₃, a₄, a₅, a₆, a₇] = Array.push (Array.push (Array.push (Array.push (Array.push (Array.push (Array.push (Array.mkEmpty 7) a₁) a₂) a₃) a₄) a₅) a₆) a₇

def Array.mkArray8 {α : Type u} (a₁ : α) (a₂ : α) (a₃ : α) (a₄ : α) (a₅ : α) (a₆ : α) (a₇ : α) (a₈ : α) :

Create array #[a₁, a₂, a₃, a₄, a₅, a₆, a₇, a₈]

Equations

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

@[extern lean_array_fset]

def Array.set {α : Type u_1} (a : Array α) (i : Fin (Array.size a)) (v : α) :

Set an element in an array without bounds checks, using a Fin index.

This will perform the update destructively provided that a has a reference count of 1 when called.

Equations

Array.set a i v = { data := List.set a.data i.val v }

@[inline]

def Array.setD {α : Type u_1} (a : Array α) (i : Nat) (v : α) :

Set an element in an array, or do nothing if the index is out of bounds.

This will perform the update destructively provided that a has a reference count of 1 when called.

Equations

Array.setD a i v = if h : i < Array.size a then Array.set a { val := i, isLt := h } v else a

@[extern lean_array_set]

def Array.set! {α : Type u_1} (a : Array α) (i : Nat) (v : α) :

Set an element in an array, or panic if the index is out of bounds.

This will perform the update destructively provided that a has a reference count of 1 when called.

Equations

Array.set! a i v = Array.setD a i v

def Array.appendCore {α : Type u} (as : Array α) (bs : Array α) :

Slower Array.append used in quotations.

Equations

Array.appendCore as bs = Array.appendCore.loop bs (Array.size bs) 0 as

def Array.appendCore.loop {α : Type u} (bs : Array α) (i : Nat) (j : Nat) (as : Array α) :

Equations

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

@[inline_if_reduce]

def List.toArrayAux {α : Type u_1} :

List α → Array α → Array α

Auxiliary definition for List.toArray.

Equations

List.toArrayAux [] x = x
List.toArrayAux (a :: as) x = List.toArrayAux as (Array.push x a)

@[inline_if_reduce]

def List.redLength {α : Type u_1} :

List α → Nat

A non-tail-recursive version of List.length, used for List.toArray.

Equations

List.redLength [] = 0
List.redLength (head :: as) = Nat.succ (List.redLength as)

@[match_pattern, inline, export lean_list_to_array]

def List.toArray {α : Type u_1} (as : List α) :

Convert a List α into an Array α. This is O(n) in the length of the list.

This function is exported to C, where it is called by Array.mk (the constructor) to implement this functionality.

Equations

List.toArray as = List.toArrayAux as (Array.mkEmpty (List.redLength as))

class Bind (m : Type u → Type v) :

Type (max(u+1)v)

If x : m α and f : α → m β, then x >>= f : m β represents the result of executing x to get a value of type α and then passing it to f.
bind : {α β : Type u} → m α → (α → m β) → m β

The typeclass which supplies the >>= "bind" function. See Monad.

Instances

class Pure (f : Type u → Type v) :

Type (max(u+1)v)

If a : α, then pure a : f α represents a monadic action that does nothing and returns a.
pure : {α : Type u} → α → f α

The typeclass which supplies the pure function. See Monad.

Instances

class Functor (f : Type u → Type v) :

Type (max(u+1)v)

If f : α → β and x : F α then f <$> x : F β.
map : {α β : Type u} → (α → β) → f α → f β
The special case const a <$> x, which can sometimes be implemented more efficiently.
mapConst : {α β : Type u} → α → f β → f α

In functional programming, a "functor" is a function on types F : Type u → Type v equipped with an operator called map or <$> such that if f : α → β then map f : F α → F β, so f <$> x : F β if x : F α. This corresponds to the category-theory notion of functor in the special case where the category is the category of types and functions between them, except that this class supplies only the operations and not the laws (see LawfulFunctor).

Instances

class Seq (f : Type u → Type v) :

Type (max(u+1)v)

If mf : F (α → β) and mx : F α, then mf <*> mx : F β. In a monad this is the same as do let f ← mf; x ← mx; pure (f x): it evaluates first the function, then the argument, and applies one to the other.
To avoid surprising evaluation semantics, mx is taken "lazily", using a Unit → f α function.
seq : {α β : Type u} → f (α → β) → (Unit → f α) → f β

The typeclass which supplies the <*> "seq" function. See Applicative.

Instances

class SeqLeft (f : Type u → Type v) :

Type (max(u+1)v)

If x : F α and y : F β, then x <* y evaluates x, then y, and returns the result of x.
To avoid surprising evaluation semantics, y is taken "lazily", using a Unit → f β function.
seqLeft : {α β : Type u} → f α → (Unit → f β) → f α

The typeclass which supplies the <* "seqLeft" function. See Applicative.

Instances

class SeqRight (f : Type u → Type v) :

Type (max(u+1)v)

If x : F α and y : F β, then x *> y evaluates x, then y, and returns the result of y.
To avoid surprising evaluation semantics, y is taken "lazily", using a Unit → f β function.
seqRight : {α β : Type u} → f α → (Unit → f β) → f β

The typeclass which supplies the *> "seqRight" function. See Applicative.

Instances

class Applicative (f : Type u → Type v) extends Functor , Pure , Seq , SeqLeft , SeqRight :

Type (max(u+1)v)

An applicative functor is an intermediate structure between Functor and Monad. It mainly consists of two operations:

pure : α → F α
seq : F (α → β) → F α → F β (written as <*>)

The seq operator gives a notion of evaluation order to the effects, where the first argument is executed before the second, but unlike a monad the results of earlier computations cannot be used to define later actions.

Instances

class Monad (m : Type u → Type v) extends Applicative , Bind :

Type (max(u+1)v)

A monad is a structure which abstracts the concept of sequential control flow. It mainly consists of two operations:

pure : α → F α
bind : F α → (α → F β) → F β (written as >>=)

Like many functional programming languages, Lean makes extensive use of monads for structuring programs. In particular, the do notation is a very powerful syntax over monad operations, and it depends on a Monad instance.

See the do notation chapter of the manual for details.

Instances

instance instInhabitedForAll_2 {α : Type u} {m : Type u → Type v} [inst : Monad m] :

Inhabited (α → m α)

Equations

instInhabitedForAll_2 = { default := pure }

instance instInhabited {α : Type u} {m : Type u → Type v} [inst : Monad m] [inst : Inhabited α] :

Inhabited (m α)

Equations

instInhabited = { default := pure default }

instance instForAllNonemptyNonempty {m : Type u_1 → Type u_2} {α : Type u_1} [inst : Monad m] [inst : Nonempty α] :

Nonempty (m α)

Equations

@instForAllNonemptyNonempty = @instForAllNonemptyNonempty.proof_1

def Array.sequenceMap {α : Type u} {β : Type v} {m : Type v → Type w} [inst : Monad m] (as : Array α) (f : α → m β) :

m (Array β)

A fusion of Haskell's sequence and map. Used in syntax quotations.

Equations

Array.sequenceMap as f = Array.sequenceMap.loop as f (Array.size as) 0 (Array.mkEmpty (Array.size as))

def Array.sequenceMap.loop {α : Type u} {β : Type v} {m : Type v → Type w} [inst : Monad m] (as : Array α) (f : α → m β) (i : Nat) (j : Nat) (bs : Array β) :

m (Array β)

Equations

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

class MonadLift (m : Type u → Type v) (n : Type u → Type w) :

Type (max(max(u+1)v)w)

Lifts a value from monad m into monad n.
monadLift : {α : Type u} → m α → n α

A function for lifting a computation from an inner Monad to an outer Monad. Like Haskell's MonadTrans, but n does not have to be a monad transformer. Alternatively, an implementation of MonadLayer without layerInvmap (so far).

Instances

class MonadLiftT (m : Type u → Type v) (n : Type u → Type w) :

Type (max(max(u+1)v)w)

Lifts a value from monad m into monad n.
monadLift : {α : Type u} → m α → n α

The reflexive-transitive closure of MonadLift. monadLift is used to transitively lift monadic computations such as StateT.get or StateT.put s. Corresponds to Haskell's MonadLift.

Instances

@[inline]

abbrev liftM {m : Type u_1 → Type u_2} {n : Type u_1 → Type u_3} [self : MonadLiftT m n] {α : Type u_1} :

m α → n α

Lifts a value from monad m into monad n.

Equations

@liftM = @monadLift

@[always_inline]

instance instMonadLiftT (m : Type u_1 → Type u_2) (n : Type u_1 → Type u_3) (o : Type u_1 → Type u_4) [inst : MonadLift n o] [inst : MonadLiftT m n] :

Equations

instMonadLiftT m n o = { monadLift := fun {α} x => MonadLift.monadLift (monadLift x) }

instance instMonadLiftT_1 (m : Type u_1 → Type u_2) :

Equations

instMonadLiftT_1 m = { monadLift := fun {α} x => x }

class MonadFunctor (m : Type u → Type v) (n : Type u → Type w) :

Type (max(max(u+1)v)w)

Lifts a monad morphism f : {β : Type u} → m β → m β to monadMap f : {α : Type u} → n α → n α.
monadMap : {α : Type u} → ({β : Type u} → m β → m β) → n α → n α

A functor in the category of monads. Can be used to lift monad-transforming functions. Based on MFunctor from the pipes Haskell package, but not restricted to monad transformers. Alternatively, an implementation of MonadTransFunctor.

Instances

class MonadFunctorT (m : Type u → Type v) (n : Type u → Type w) :

Type (max(max(u+1)v)w)

Lifts a monad morphism f : {β : Type u} → m β → m β to monadMap f : {α : Type u} → n α → n α.
monadMap : {α : Type u} → ({β : Type u} → m β → m β) → n α → n α

The reflexive-transitive closure of MonadFunctor. monadMap is used to transitively lift Monad morphisms.

Instances

@[always_inline]

instance instMonadFunctorT (m : Type u_1 → Type u_2) (n : Type u_1 → Type u_3) (o : Type u_1 → Type u_4) [inst : MonadFunctor n o] [inst : MonadFunctorT m n] :

MonadFunctorT m o

Equations

instMonadFunctorT m n o = { monadMap := fun {α} f => MonadFunctor.monadMap fun {β} => monadMap fun {β} => f β }

instance monadFunctorRefl (m : Type u_1 → Type u_2) :

MonadFunctorT m m

Equations

monadFunctorRefl m = { monadMap := fun {α} f => f α }

@[unbox]

inductive Except (ε : Type u) (α : Type v) :

Type (maxuv)

A failure value of type ε
error: {ε : Type u} → {α : Type v} → ε → Except ε α
A success value of type α
ok: {ε : Type u} → {α : Type v} → α → Except ε α

Except ε α is a type which represents either an error of type ε, or an "ok" value of type α. The error type is listed first because Except ε : Type → Type is a Monad: the pure operation is ok and the bind operation returns the first encountered error.

Instances For

instance instInhabitedExcept {ε : Type u} {α : Type v} [inst : Inhabited ε] :

Inhabited (Except ε α)

Equations

instInhabitedExcept = { default := Except.error default }

class MonadExceptOf (ε : Type u) (m : Type v → Type w) :

Type (max(maxu(v+1))w)

throw : ε → m α "throws an error" of type ε to the nearest enclosing catch block.
throw : {α : Type v} → ε → m α
tryCatch (body : m α) (handler : ε → m α) : m α will catch any errors in body and pass the resulting error to handler. Errors in handler will not be caught.
tryCatch : {α : Type v} → m α → (ε → m α) → m α

An implementation of Haskell's MonadError class. A MonadError ε m is a monad m with two operations:

throw : ε → m α "throws an error" of type ε to the nearest enclosing catch block
tryCatch (body : m α) (handler : ε → m α) : m α will catch any errors in body and pass the resulting error to handler. Errors in handler will not be caught.

The try ... catch e => ... syntax inside do blocks is sugar for the tryCatch operation.

Instances

@[inline]

abbrev throwThe (ε : Type u) {m : Type v → Type w} [inst : MonadExceptOf ε m] {α : Type v} (e : ε) :

m α

This is the same as throw, but allows specifying the particular error type in case the monad supports throwing more than one type of error.

Equations

throwThe ε e = MonadExceptOf.throw e

@[inline]

abbrev tryCatchThe (ε : Type u) {m : Type v → Type w} [inst : MonadExceptOf ε m] {α : Type v} (x : m α) (handle : ε → m α) :

m α

This is the same as tryCatch, but allows specifying the particular error type in case the monad supports throwing more than one type of error.

Equations

tryCatchThe ε x handle = MonadExceptOf.tryCatch x handle

class MonadExcept (ε : outParam (Type u)) (m : Type v → Type w) :

Type (max(maxu(v+1))w)

throw : ε → m α "throws an error" of type ε to the nearest enclosing catch block.
throw : {α : Type v} → ε → m α
tryCatch (body : m α) (handler : ε → m α) : m α will catch any errors in body and pass the resulting error to handler. Errors in handler will not be caught.
tryCatch : {α : Type v} → m α → (ε → m α) → m α

Similar to MonadExceptOf, but ε is an outParam for convenience.

Instances

def MonadExcept.ofExcept {m : Type u_1 → Type u_2} {ε : Type u_3} {α : Type u_1} [inst : Monad m] [inst : MonadExcept ε m] :

Except ε α → m α

"Unwraps" an Except ε α to get the α, or throws the exception otherwise.

Equations

ofExcept x = match x with | Except.ok a => pure a | Except.error e => throw e

instance instMonadExcept (ε : outParam (Type u)) (m : Type v → Type w) [inst : MonadExceptOf ε m] :

MonadExcept ε m

Equations

instMonadExcept ε m = { throw := fun {α} => throwThe ε, tryCatch := fun {α} => tryCatchThe ε }

@[inline]

def MonadExcept.orElse {ε : Type u} {m : Type v → Type w} [inst : MonadExcept ε m] {α : Type v} (t₁ : m α) (t₂ : Unit → m α) :

m α

A MonadExcept can implement t₁ <|> t₂ as try t₁ catch _ => t₂.

Equations

MonadExcept.orElse t₁ t₂ = tryCatch t₁ fun x => t₂ ()

instance MonadExcept.instOrElse {ε : Type u} {m : Type v → Type w} [inst : MonadExcept ε m] {α : Type v} :

OrElse (m α)

Equations

MonadExcept.instOrElse = { orElse := MonadExcept.orElse }

def ReaderT (ρ : Type u) (m : Type u → Type v) (α : Type u) :

Type (maxuv)

An implementation of Haskell's ReaderT. This is a monad transformer which equips a monad with additional read-only state, of type ρ.

Equations

ReaderT ρ m α = (ρ → m α)

instance instInhabitedReaderT (ρ : Type u) (m : Type u → Type v) (α : Type u) [inst : Inhabited (m α)] :

Inhabited (ReaderT ρ m α)

Equations

instInhabitedReaderT ρ m α = { default := fun x => default }

@[inline]

def ReaderT.run {ρ : Type u} {m : Type u → Type v} {α : Type u} (x : ReaderT ρ m α) (r : ρ) :

m α

If x : ReaderT ρ m α and r : ρ, then x.run r : ρ runs the monad with the given reader state.

Equations

ReaderT.run x r = x r

instance ReaderT.instMonadLiftReaderT {ρ : Type u} {m : Type u → Type v} :

MonadLift m (ReaderT ρ m)

Equations

ReaderT.instMonadLiftReaderT = { monadLift := fun {α} x x_1 => x }

@[always_inline]

instance ReaderT.instMonadExceptOfReaderT {ρ : Type u} {m : Type u → Type v} (ε : Type u_1) [inst : MonadExceptOf ε m] :

MonadExceptOf ε (ReaderT ρ m)

Equations

ReaderT.instMonadExceptOfReaderT ε = { throw := fun {α} e => liftM (throw e), tryCatch := fun {α} x c r => tryCatchThe ε (x r) fun e => c e r }

@[inline]

def ReaderT.read {ρ : Type u} {m : Type u → Type v} [inst : Monad m] :

ReaderT ρ m ρ

(← read) : ρ gets the read-only state of a ReaderT ρ.

Equations

ReaderT.read = pure

@[inline]

def ReaderT.pure {ρ : Type u} {m : Type u → Type v} [inst : Monad m] {α : Type u} (a : α) :

ReaderT ρ m α

The pure operation of the ReaderT monad.

Equations

ReaderT.pure a x = pure a

@[inline]

def ReaderT.bind {ρ : Type u} {m : Type u → Type v} [inst : Monad m] {α : Type u} {β : Type u} (x : ReaderT ρ m α) (f : α → ReaderT ρ m β) :

ReaderT ρ m β

The bind operation of the ReaderT monad.

Equations

ReaderT.bind x f r = do let a ← x r f a r

@[always_inline]

instance ReaderT.instFunctorReaderT {ρ : Type u} {m : Type u → Type v} [inst : Monad m] :

Functor (ReaderT ρ m)

Equations

ReaderT.instFunctorReaderT = { map := fun {α β} f x r => f <$> x r, mapConst := fun {α β} a x r => Functor.mapConst a (x r) }

@[always_inline]

instance ReaderT.instApplicativeReaderT {ρ : Type u} {m : Type u → Type v} [inst : Monad m] :

Applicative (ReaderT ρ m)

Equations

ReaderT.instApplicativeReaderT = Applicative.mk

instance ReaderT.instMonadReaderT {ρ : Type u} {m : Type u → Type v} [inst : Monad m] :

Monad (ReaderT ρ m)

Equations

ReaderT.instMonadReaderT = Monad.mk

instance ReaderT.instMonadFunctorReaderT (ρ : Type u_1) (m : Type u_1 → Type u_2) :

MonadFunctor m (ReaderT ρ m)

Equations

ReaderT.instMonadFunctorReaderT ρ m = { monadMap := fun {α} f x ctx => f α (x ctx) }

@[inline]

def ReaderT.adapt {ρ : Type u} {m : Type u → Type v} {ρ' : Type u} {α : Type u} (f : ρ' → ρ) :

ReaderT ρ m α → ReaderT ρ' m α

adapt (f : ρ' → ρ) precomposes function f on the reader state of a ReaderT ρ, yielding a ReaderT ρ'.

Equations

ReaderT.adapt f x r = x (f r)

class MonadReaderOf (ρ : Type u) (m : Type u → Type v) :

(← read) : ρ reads the state out of monad m.
read : m ρ

An implementation of Haskell's MonadReader (sans functional dependency; see also MonadReader in this module). It does not contain local because this function cannot be lifted using monadLift. local is instead provided by the MonadWithReader class as withReader.

Note: This class can be seen as a simplification of the more "principled" definition

class MonadReaderOf (ρ : Type u) (n : Type u → Type u) where
  lift {α : Type u} : ({m : Type u → Type u} → [Monad m] → ReaderT ρ m α) → n α

Instances

@[inline]

def readThe (ρ : Type u) {m : Type u → Type v} [inst : MonadReaderOf ρ m] :

m ρ

Like read, but with ρ explicit. This is useful if a monad supports MonadReaderOf for multiple different types ρ.

Equations

readThe ρ = MonadReaderOf.read

class MonadReader (ρ : outParam (Type u)) (m : Type u → Type v) :

(← read) : ρ reads the state out of monad m.
read : m ρ

Similar to MonadReaderOf, but ρ is an outParam for convenience.

Instances

instance instMonadReader (ρ : Type u) (m : Type u → Type v) [inst : MonadReaderOf ρ m] :

MonadReader ρ m

Equations

instMonadReader ρ m = { read := readThe ρ }

instance instMonadReaderOf {ρ : Type u} {m : Type u → Type v} {n : Type u → Type w} [inst : MonadLift m n] [inst : MonadReaderOf ρ m] :

MonadReaderOf ρ n

Equations

instMonadReaderOf = { read := liftM read }

instance instMonadReaderOfReaderT {ρ : Type u} {m : Type u → Type v} [inst : Monad m] :

MonadReaderOf ρ (ReaderT ρ m)

Equations

instMonadReaderOfReaderT = { read := ReaderT.read }

class MonadWithReaderOf (ρ : Type u) (m : Type u → Type v) :

Type (max(u+1)v)

withReader (f : ρ → ρ) (x : m α) : m α runs the inner x : m α inside a modified context after applying the function f : ρ → ρ.
withReader : {α : Type u} → (ρ → ρ) → m α → m α

MonadWithReaderOf ρ adds the operation withReader : (ρ → ρ) → m α → m α. This runs the inner x : m α inside a modified context after applying the function f : ρ → ρ. In addition to ReaderT itself, this operation lifts over most monad transformers, so it allows us to apply withReader to monads deeper in the stack.

Instances

@[inline]

def withTheReader (ρ : Type u) {m : Type u → Type v} [inst : MonadWithReaderOf ρ m] {α : Type u} (f : ρ → ρ) (x : m α) :

m α

Like withReader, but with ρ explicit. This is useful if a monad supports MonadWithReaderOf for multiple different types ρ.

Equations

withTheReader ρ f x = MonadWithReaderOf.withReader f x

class MonadWithReader (ρ : outParam (Type u)) (m : Type u → Type v) :

Type (max(u+1)v)

withReader (f : ρ → ρ) (x : m α) : m α runs the inner x : m α inside a modified context after applying the function f : ρ → ρ.
withReader : {α : Type u} → (ρ → ρ) → m α → m α

Similar to MonadWithReaderOf, but ρ is an outParam for convenience.

Instances

instance instMonadWithReader (ρ : Type u) (m : Type u → Type v) [inst : MonadWithReaderOf ρ m] :

MonadWithReader ρ m

Equations

instMonadWithReader ρ m = { withReader := fun {α} => withTheReader ρ }

instance instMonadWithReaderOf {ρ : Type u} {m : Type u → Type v} {n : Type u → Type v} [inst : MonadFunctor m n] [inst : MonadWithReaderOf ρ m] :

MonadWithReaderOf ρ n

Equations

instMonadWithReaderOf = { withReader := fun {α} f => monadMap fun {β} => withTheReader ρ f }

instance instMonadWithReaderOfReaderT {ρ : Type u} {m : Type u → Type v} [inst : Monad m] :

MonadWithReaderOf ρ (ReaderT ρ m)

Equations

instMonadWithReaderOfReaderT = { withReader := fun {α} f x ctx => x (f ctx) }

class MonadStateOf (σ : Type u) (m : Type u → Type v) :

Type (max(u+1)v)

(← get) : σ gets the state out of a monad m.
get : m σ
set (s : σ) replaces the state with value s.
set : σ → m PUnit
modifyGet (f : σ → α × σ) applies f to the current state, replaces the state with the return value, and returns a computed value.
It is equivalent to do let (a, s) := f (← get); put s; pure a, but modifyGet f may be preferable because the former does not use the state linearly (without sufficient inlining).
modifyGet : {α : Type u} → (σ → α × σ) → m α

An implementation of MonadState. In contrast to the Haskell implementation, we use overlapping instances to derive instances automatically from monadLift.

Instances

@[inline]

abbrev getThe (σ : Type u) {m : Type u → Type v} [inst : MonadStateOf σ m] :

m σ

Like withReader, but with ρ explicit. This is useful if a monad supports MonadWithReaderOf for multiple different types ρ.

Equations

getThe σ = MonadStateOf.get

@[inline]

abbrev modifyThe (σ : Type u) {m : Type u → Type v} [inst : MonadStateOf σ m] (f : σ → σ) :

Like modify, but with σ explicit. This is useful if a monad supports MonadStateOf for multiple different types σ.

Equations

modifyThe σ f = MonadStateOf.modifyGet fun s => (PUnit.unit, f s)

@[inline]

abbrev modifyGetThe {α : Type u} (σ : Type u) {m : Type u → Type v} [inst : MonadStateOf σ m] (f : σ → α × σ) :

m α

Like modifyGet, but with σ explicit. This is useful if a monad supports MonadStateOf for multiple different types σ.

Equations

modifyGetThe σ f = MonadStateOf.modifyGet f

class MonadState (σ : outParam (Type u)) (m : Type u → Type v) :

Type (max(u+1)v)

(← get) : σ gets the state out of a monad m.
get : m σ
set (s : σ) replaces the state with value s.
set : σ → m PUnit
modifyGet (f : σ → α × σ) applies f to the current state, replaces the state with the return value, and returns a computed value.
It is equivalent to do let (a, s) := f (← get); put s; pure a, but modifyGet f may be preferable because the former does not use the state linearly (without sufficient inlining).
modifyGet : {α : Type u} → (σ → α × σ) → m α

Similar to MonadStateOf, but σ is an outParam for convenience.

Instances

instance instMonadState (σ : Type u) (m : Type u → Type v) [inst : MonadStateOf σ m] :

MonadState σ m

Equations

instMonadState σ m = { get := getThe σ, set := set, modifyGet := fun {α} f => MonadStateOf.modifyGet f }

@[inline]

def modify {σ : Type u} {m : Type u → Type v} [inst : MonadState σ m] (f : σ → σ) :

modify (f : σ → σ) applies the function f to the state.

It is equivalent to do put (f (← get)), but modify f may be preferable because the former does not use the state linearly (without sufficient inlining).

Equations

modify f = modifyGet fun s => (PUnit.unit, f s)

@[inline]

def getModify {σ : Type u} {m : Type u → Type v} [inst : MonadState σ m] [inst : Monad m] (f : σ → σ) :

m σ

getModify f gets the state, applies function f, and returns the old value of the state. It is equivalent to get <* modify f but may be more efficient.

Equations

getModify f = modifyGet fun s => (s, f s)

@[always_inline]

instance instMonadStateOf {σ : Type u} {m : Type u → Type v} {n : Type u → Type w} [inst : MonadLift m n] [inst : MonadStateOf σ m] :

MonadStateOf σ n

Equations

instMonadStateOf = { get := liftM MonadStateOf.get, set := fun s => liftM (set s), modifyGet := fun {α} f => monadLift (modifyGet f) }

inductive EStateM.Result (ε : Type u) (σ : Type u) (α : Type u) :

A success value of type α, and a new state σ.
ok: {ε σ α : Type u} → α → σ → EStateM.Result ε σ α
A failure value of type ε, and a new state σ.
error: {ε σ α : Type u} → ε → σ → EStateM.Result ε σ α

Result ε σ α is equivalent to Except ε α × σ, but using a single combined inductive yields a more efficient data representation.

Instances For

instance EStateM.instInhabitedResult {ε : Type u} {σ : Type u} {α : Type u} [inst : Inhabited ε] [inst : Inhabited σ] :

Inhabited (EStateM.Result ε σ α)

Equations

EStateM.instInhabitedResult = { default := EStateM.Result.error default default }

def EStateM (ε : Type u) (σ : Type u) (α : Type u) :

EStateM ε σ is a combined error and state monad, equivalent to ExceptT ε (StateM σ) but more efficient.

Equations

EStateM ε σ α = (σ → EStateM.Result ε σ α)

instance EStateM.instInhabitedEStateM {ε : Type u} {σ : Type u} {α : Type u} [inst : Inhabited ε] :

Inhabited (EStateM ε σ α)

Equations

EStateM.instInhabitedEStateM = { default := fun s => EStateM.Result.error default s }

@[inline]

def EStateM.pure {ε : Type u} {σ : Type u} {α : Type u} (a : α) :

EStateM ε σ α

The pure operation of the EStateM monad.

Equations

EStateM.pure a s = EStateM.Result.ok a s

@[inline]

def EStateM.set {ε : Type u} {σ : Type u} (s : σ) :

EStateM ε σ PUnit

The set operation of the EStateM monad.

Equations

EStateM.set s x = EStateM.Result.ok PUnit.unit s

@[inline]

def EStateM.get {ε : Type u} {σ : Type u} :

EStateM ε σ σ

The get operation of the EStateM monad.

Equations

EStateM.get s = EStateM.Result.ok s s

@[inline]

def EStateM.modifyGet {ε : Type u} {σ : Type u} {α : Type u} (f : σ → α × σ) :

EStateM ε σ α

The modifyGet operation of the EStateM monad.

Equations

EStateM.modifyGet f s = match f s with | (a, s) => EStateM.Result.ok a s

@[inline]

def EStateM.throw {ε : Type u} {σ : Type u} {α : Type u} (e : ε) :

EStateM ε σ α

The throw operation of the EStateM monad.

Equations

EStateM.throw e s = EStateM.Result.error e s

class EStateM.Backtrackable (δ : outParam (Type u)) (σ : Type u) :

save s : δ retrieves a copy of the backtracking state out of the state.
save : σ → δ
restore (s : σ) (x : δ) : σ applies the old backtracking state x to the state s to get a backtracked state s'.
restore : σ → δ → σ

Auxiliary instance for saving/restoring the "backtrackable" part of the state. Here σ is the state, and δ is some subpart of it, and we have a getter and setter for it (a "lens" in the Haskell terminology).

Instances

@[inline]

def EStateM.tryCatch {ε : Type u} {σ : Type u} {δ : Type u} [inst : EStateM.Backtrackable δ σ] {α : Type u} (x : EStateM ε σ α) (handle : ε → EStateM ε σ α) :

EStateM ε σ α

Implementation of tryCatch for EStateM where the state is Backtrackable.

Equations

EStateM.tryCatch x handle s = let d := EStateM.Backtrackable.save s; match x s with | EStateM.Result.error e s => handle e (EStateM.Backtrackable.restore s d) | ok => ok

@[inline]

def EStateM.orElse {ε : Type u} {σ : Type u} {α : Type u} {δ : Type u} [inst : EStateM.Backtrackable δ σ] (x₁ : EStateM ε σ α) (x₂ : Unit → EStateM ε σ α) :

EStateM ε σ α

Implementation of orElse for EStateM where the state is Backtrackable.

Equations

EStateM.orElse x₁ x₂ s = let d := EStateM.Backtrackable.save s; match x₁ s with | EStateM.Result.error a s => x₂ () (EStateM.Backtrackable.restore s d) | ok => ok

@[inline]

def EStateM.adaptExcept {ε : Type u} {σ : Type u} {α : Type u} {ε' : Type u} (f : ε → ε') (x : EStateM ε σ α) :

EStateM ε' σ α

Map the exception type of a EStateM ε σ α by a function f : ε → ε'.

Equations

EStateM.adaptExcept f x s = match x s with | EStateM.Result.error e s => EStateM.Result.error (f e) s | EStateM.Result.ok a s => EStateM.Result.ok a s

@[inline]

def EStateM.bind {ε : Type u} {σ : Type u} {α : Type u} {β : Type u} (x : EStateM ε σ α) (f : α → EStateM ε σ β) :

EStateM ε σ β

The bind operation of the EStateM monad.

Equations

EStateM.bind x f s = match x s with | EStateM.Result.ok a s => f a s | EStateM.Result.error e s => EStateM.Result.error e s

@[inline]

def EStateM.map {ε : Type u} {σ : Type u} {α : Type u} {β : Type u} (f : α → β) (x : EStateM ε σ α) :

EStateM ε σ β

The map operation of the EStateM monad.

Equations

EStateM.map f x s = match x s with | EStateM.Result.ok a s => EStateM.Result.ok (f a) s | EStateM.Result.error e s => EStateM.Result.error e s

@[inline]

def EStateM.seqRight {ε : Type u} {σ : Type u} {α : Type u} {β : Type u} (x : EStateM ε σ α) (y : Unit → EStateM ε σ β) :

EStateM ε σ β

The seqRight operation of the EStateM monad.

Equations

EStateM.seqRight x y s = match x s with | EStateM.Result.ok a s => y () s | EStateM.Result.error e s => EStateM.Result.error e s

@[always_inline]

instance EStateM.instMonadEStateM {ε : Type u} {σ : Type u} :

Monad (EStateM ε σ)

Equations

EStateM.instMonadEStateM = Monad.mk

instance EStateM.instOrElseEStateM {ε : Type u} {σ : Type u} {α : Type u} {δ : Type u} [inst : EStateM.Backtrackable δ σ] :

OrElse (EStateM ε σ α)

Equations

EStateM.instOrElseEStateM = { orElse := EStateM.orElse }

instance EStateM.instMonadStateOfEStateM {ε : Type u} {σ : Type u} :

MonadStateOf σ (EStateM ε σ)

Equations

EStateM.instMonadStateOfEStateM = { get := EStateM.get, set := EStateM.set, modifyGet := fun {α} => EStateM.modifyGet }

instance EStateM.instMonadExceptOfEStateM {ε : Type u} {σ : Type u} {δ : Type u} [inst : EStateM.Backtrackable δ σ] :

MonadExceptOf ε (EStateM ε σ)

Equations

EStateM.instMonadExceptOfEStateM = { throw := fun {α} => EStateM.throw, tryCatch := fun {α} => EStateM.tryCatch }

@[inline]

def EStateM.run {ε : Type u} {σ : Type u} {α : Type u} (x : EStateM ε σ α) (s : σ) :

EStateM.Result ε σ α

Execute an EStateM on initial state s to get a Result.

Equations

EStateM.run x s = x s

@[inline]

def EStateM.run' {ε : Type u} {σ : Type u} {α : Type u} (x : EStateM ε σ α) (s : σ) :

Execute an EStateM on initial state s for the returned value α. If the monadic action throws an exception, returns none instead.

Equations

EStateM.run' x s = match EStateM.run x s with | EStateM.Result.ok v a => some v | EStateM.Result.error a a_1 => none

@[inline]

def EStateM.dummySave {σ : Type u} :

σ → PUnit

The save implementation for Backtrackable PUnit σ.

Equations

EStateM.dummySave x = PUnit.unit

@[inline]

def EStateM.dummyRestore {σ : Type u} :

σ → PUnit → σ

The restore implementation for Backtrackable PUnit σ.

Equations

EStateM.dummyRestore s x = s

instance EStateM.nonBacktrackable {σ : Type u} :

EStateM.Backtrackable PUnit σ

Dummy default instance. This makes every σ trivially "backtrackable" by doing nothing on backtrack. Because this is the first declared instance of Backtrackable _ σ, it will be picked only if there are no other Backtrackable _ σ instances registered.

Equations

EStateM.nonBacktrackable = { save := EStateM.dummySave, restore := EStateM.dummyRestore }

class Hashable (α : Sort u) :

Sort (max1u)

Hashes the value a : α into a UInt64.
hash : α → UInt64

A class for types that can be hashed into a UInt64.

Instances

@[extern lean_uint64_to_usize]

opaque UInt64.toUSize (u : UInt64) :

Converts a UInt64 to a USize by reducing modulo USize.size.

@[extern lean_usize_to_uint64]

def USize.toUInt64 (u : USize) :

Upcast a USize to a UInt64. This is lossless because USize.size is either 2^32 or 2^64. This function is overridden with a native implementation.

Equations

USize.toUInt64 u = { val := { val := u.val.val, isLt := (_ : u.val.val < UInt64.size) } }

@[extern lean_uint64_mix_hash]

opaque mixHash (u₁ : UInt64) (u₂ : UInt64) :

An opaque hash mixing operation, used to implement hashing for tuples.

instance instHashableSubtype {α : Sort u_1} [inst : Hashable α] {p : α → Prop} :

Hashable (Subtype p)

Equations

instHashableSubtype = { hash := fun a => hash a.val }

@[extern lean_string_hash]

opaque String.hash (s : String) :

A opaque string hash function.

instance instHashableString :

Hashable String

Equations

instHashableString = { hash := String.hash }

@[implemented_by Lean.Name.hash._override]

noncomputable def Lean.Name.hash :

Lean.Name → UInt64

A hash function for names, which is stored inside the name itself as a computed field.

Equations

Lean.Name.hash Lean.Name.anonymous = UInt64.ofNatCore 1723 (_ : 1723 < UInt64.size)
Lean.Name.hash (Lean.Name.str p s) = mixHash (Lean.Name.hash p) (String.hash s)
Lean.Name.hash (Lean.Name.num p v) = mixHash (Lean.Name.hash p) (if h : v < UInt64.size then UInt64.ofNatCore v h else UInt64.ofNatCore 17 (_ : 17 < UInt64.size))

inductive Lean.Name :

The "anonymous" name.
anonymous: Lean.Name
A string name. The name Lean.Meta.run is represented at
```
.str (.str (.str .anonymous "Lean") "Meta") "run"
```
str: Lean.Name → String → Lean.Name
A numerical name. This kind of name is used, for example, to create hierarchical names for free variables and metavariables. The identifier _uniq.231 is represented as
```
.num (.str .anonymous "_uniq") 231
```
num: Lean.Name → Nat → Lean.Name

Hierarchical names. We use hierarchical names to name declarations and for creating unique identifiers for free variables and metavariables.

You can create hierarchical names using the following quotation notation.

`Lean.Meta.whnf

It is short for .str (.str (.str .anonymous "Lean") "Meta") "whnf" You can use double quotes to request Lean to statically check whether the name corresponds to a Lean declaration in scope.

``Lean.Meta.whnf

If the name is not in scope, Lean will report an error.

Instances For

instance Lean.instInhabitedName :

Inhabited Lean.Name

Equations

Lean.instInhabitedName = { default := Lean.Name.anonymous }

instance Lean.instHashableName :

Hashable Lean.Name

Equations

Lean.instHashableName = { hash := Lean.Name.hash }

@[inline, export lean_name_mk_string]

abbrev Lean.Name.mkStr (p : Lean.Name) (s : String) :

.str p s is now the preferred form.

Equations

Lean.Name.mkStr p s = Lean.Name.str p s

@[inline, export lean_name_mk_numeral]

abbrev Lean.Name.mkNum (p : Lean.Name) (v : Nat) :

.num p v is now the preferred form.

Equations

Lean.Name.mkNum p v = Lean.Name.num p v

@[inline]

abbrev Lean.Name.mkSimple (s : String) :

Short for .str .anonymous s.

Equations

Lean.Name.mkSimple s = Lean.Name.str Lean.Name.anonymous s

def Lean.Name.mkStr1 (s₁ : String) :

Make name s₁

Equations

Lean.Name.mkStr1 s₁ = Lean.Name.str Lean.Name.anonymous s₁

def Lean.Name.mkStr2 (s₁ : String) (s₂ : String) :

Make name s₁.s₂

Equations

Lean.Name.mkStr2 s₁ s₂ = Lean.Name.str (Lean.Name.str Lean.Name.anonymous s₁) s₂

def Lean.Name.mkStr3 (s₁ : String) (s₂ : String) (s₃ : String) :

Make name s₁.s₂.s₃

Equations

Lean.Name.mkStr3 s₁ s₂ s₃ = Lean.Name.str (Lean.Name.str (Lean.Name.str Lean.Name.anonymous s₁) s₂) s₃

def Lean.Name.mkStr4 (s₁ : String) (s₂ : String) (s₃ : String) (s₄ : String) :

Make name s₁.s₂.s₃.s₄

Equations

Lean.Name.mkStr4 s₁ s₂ s₃ s₄ = Lean.Name.str (Lean.Name.str (Lean.Name.str (Lean.Name.str Lean.Name.anonymous s₁) s₂) s₃) s₄

def Lean.Name.mkStr5 (s₁ : String) (s₂ : String) (s₃ : String) (s₄ : String) (s₅ : String) :

Make name s₁.s₂.s₃.s₄.s₅

Equations

Lean.Name.mkStr5 s₁ s₂ s₃ s₄ s₅ = Lean.Name.str (Lean.Name.str (Lean.Name.str (Lean.Name.str (Lean.Name.str Lean.Name.anonymous s₁) s₂) s₃) s₄) s₅

def Lean.Name.mkStr6 (s₁ : String) (s₂ : String) (s₃ : String) (s₄ : String) (s₅ : String) (s₆ : String) :

Make name s₁.s₂.s₃.s₄.s₅.s₆

Equations

Lean.Name.mkStr6 s₁ s₂ s₃ s₄ s₅ s₆ = Lean.Name.str (Lean.Name.str (Lean.Name.str (Lean.Name.str (Lean.Name.str (Lean.Name.str Lean.Name.anonymous s₁) s₂) s₃) s₄) s₅) s₆

def Lean.Name.mkStr7 (s₁ : String) (s₂ : String) (s₃ : String) (s₄ : String) (s₅ : String) (s₆ : String) (s₇ : String) :

Make name s₁.s₂.s₃.s₄.s₅.s₆.s₇

Equations

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

def Lean.Name.mkStr8 (s₁ : String) (s₂ : String) (s₃ : String) (s₄ : String) (s₅ : String) (s₆ : String) (s₇ : String) (s₈ : String) :

Make name s₁.s₂.s₃.s₄.s₅.s₆.s₇.s₈

Equations

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

@[extern lean_name_eq]

def Lean.Name.beq :

Lean.Name → Lean.Name → Bool

(Boolean) equality comparator for names.

Equations

Lean.Name.beq Lean.Name.anonymous Lean.Name.anonymous = true
Lean.Name.beq (Lean.Name.str p₁ s₁) (Lean.Name.str p₂ s₂) = (s₁ == s₂ && Lean.Name.beq p₁ p₂)
Lean.Name.beq (Lean.Name.num p₁ n₁) (Lean.Name.num p₂ n₂) = (n₁ == n₂ && Lean.Name.beq p₁ p₂)
Lean.Name.beq x x = false

instance Lean.Name.instBEqName :

Equations

Lean.Name.instBEqName = { beq := Lean.Name.beq }

def Lean.Name.appendCore :

Lean.Name → Lean.Name → Lean.Name

This function does not have special support for macro scopes. See Name.append.

Equations

Lean.Name.appendCore x Lean.Name.anonymous = x
Lean.Name.appendCore x (Lean.Name.str p s) = Lean.Name.str (Lean.Name.appendCore x p) s
Lean.Name.appendCore x (Lean.Name.num p d) = Lean.Name.num (Lean.Name.appendCore x p) d

Syntax #

inductive Lean.SourceInfo :

Token from original input with whitespace and position information. leading will be inferred after parsing by Syntax.updateLeading. During parsing, it is not at all clear what the preceding token was, especially with backtracking.
original: Substring → String.Pos → Substring → String.Pos → Lean.SourceInfo
Synthesized syntax (e.g. from a quotation) annotated with a span from the original source. In the delaborator, we "misuse" this constructor to store synthetic positions identifying subterms.
The canonical flag on synthetic syntax is enabled for syntax that is not literally part of the original input syntax but should be treated "as if" the user really wrote it for the purpose of hovers and error messages. This is usually used on identifiers, to connect the binding site to the user's original syntax even if the name of the identifier changes during expansion, as well as on tokens where we will attach targeted messages.
The syntax token%$stx in a syntax quotation will annotate the token token with the span from stx and also mark it as canonical.
As a rough guide, a macro expansion should only use a given piece of input syntax in a single canonical token, although this is sometimes violated when the same identifier is used to declare two binders, as in the macro expansion for dependent if:
```
`(if $h : $cond then $t else $e) ~>
`(dite $cond (fun $h => $t) (fun $h => $t))
```
In these cases if the user hovers over h they will see information about both binding sites.
synthetic: String.Pos → String.Pos → optParam Bool false → Lean.SourceInfo
Synthesized token without position information.
none: Lean.SourceInfo

Source information of tokens.

Instances For

instance Lean.instInhabitedSourceInfo :

Inhabited Lean.SourceInfo

Equations

Lean.instInhabitedSourceInfo = { default := Lean.SourceInfo.none }

def Lean.SourceInfo.getPos? (info : Lean.SourceInfo) (canonicalOnly : optParam Bool false) :

Option String.Pos

Gets the position information from a SourceInfo, if available. If originalOnly is true, then .synthetic syntax will also return none.

Equations

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

@[inline]

abbrev Lean.SyntaxNodeKind :

A SyntaxNodeKind classifies Syntax.node values. It is an abbreviation for Name, and you can use name literals to construct SyntaxNodeKinds, but they need not refer to declarations in the environment. Conventionally, a SyntaxNodeKind will correspond to the Parser or ParserDesc declaration that parses it.

Equations

Lean.SyntaxNodeKind = Lean.Name

Syntax AST #

inductive Lean.Syntax.Preresolved :

A potential namespace reference
namespace: Lean.Name → Lean.Syntax.Preresolved
A potential global constant or section variable reference, with additional field accesses
decl: Lean.Name → List String → Lean.Syntax.Preresolved

Binding information resolved and stored at compile time of a syntax quotation. Note: We do not statically know whether a syntax expects a namespace or term name, so a Syntax.ident may contain both preresolution kinds.

Instances For

inductive Lean.Syntax :

A missing syntax corresponds to a portion of the syntax tree that is missing because of a parse error. The indexing operator on Syntax also returns missing for indexing out of bounds.
missing: Lean.Syntax
Node in the syntax tree.
The info field is used by the delaborator to store the position of the subexpression corresponding to this node. The parser sets the info field to none. The parser sets the info field to none, with position retrieval continuing recursively. Nodes created by quotatons use the result from SourceInfo.fromRef so that they are marked as synthetic even when the leading/trailing token is not. The delaborator uses the info field to store the position of the subexpression corresponding to this node.
(Remark: the node constructor did not have an info field in previous versions. This caused a bug in the interactive widgets, where the popup for a + b was the same as for a. The delaborator used to associate subexpressions with pretty-printed syntax by setting the (string) position of the first atom/identifier to the (expression) position of the subexpression. For example, both a and a + b have the same first identifier, and so their infos got mixed up.)
node: Lean.SourceInfo → Lean.SyntaxNodeKind → Array Lean.Syntax → Lean.Syntax
An atom corresponds to a keyword or piece of literal unquoted syntax. These correspond to quoted strings inside syntax declarations. For example, in (x + y), "(", "+" and ")" are atom and x and y are ident.
atom: Lean.SourceInfo → String → Lean.Syntax
An ident corresponds to an identifier as parsed by the ident or rawIdent parsers.
- rawVal is the literal substring from the input file
- val is the parsed identifier (with hygiene)
- preresolved is the list of possible declarations this could refer to
ident: Lean.SourceInfo → Substring → Lean.Name → List Lean.Syntax.Preresolved → Lean.Syntax

Syntax objects used by the parser, macro expander, delaborator, etc.

Instances For

def Lean.Syntax.node1 (info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ : Lean.Syntax) :

Create syntax node with 1 child

Equations

Lean.Syntax.node1 info kind a₁ = Lean.Syntax.node info kind #[a₁]

def Lean.Syntax.node2 (info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ : Lean.Syntax) (a₂ : Lean.Syntax) :

Create syntax node with 2 children

Equations

Lean.Syntax.node2 info kind a₁ a₂ = Lean.Syntax.node info kind #[a₁, a₂]

def Lean.Syntax.node3 (info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ : Lean.Syntax) (a₂ : Lean.Syntax) (a₃ : Lean.Syntax) :

Create syntax node with 3 children

Equations

Lean.Syntax.node3 info kind a₁ a₂ a₃ = Lean.Syntax.node info kind #[a₁, a₂, a₃]

def Lean.Syntax.node4 (info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ : Lean.Syntax) (a₂ : Lean.Syntax) (a₃ : Lean.Syntax) (a₄ : Lean.Syntax) :

Create syntax node with 4 children

Equations

Lean.Syntax.node4 info kind a₁ a₂ a₃ a₄ = Lean.Syntax.node info kind #[a₁, a₂, a₃, a₄]

def Lean.Syntax.node5 (info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ : Lean.Syntax) (a₂ : Lean.Syntax) (a₃ : Lean.Syntax) (a₄ : Lean.Syntax) (a₅ : Lean.Syntax) :

Create syntax node with 5 children

Equations

Lean.Syntax.node5 info kind a₁ a₂ a₃ a₄ a₅ = Lean.Syntax.node info kind #[a₁, a₂, a₃, a₄, a₅]

def Lean.Syntax.node6 (info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ : Lean.Syntax) (a₂ : Lean.Syntax) (a₃ : Lean.Syntax) (a₄ : Lean.Syntax) (a₅ : Lean.Syntax) (a₆ : Lean.Syntax) :

Create syntax node with 6 children

Equations

Lean.Syntax.node6 info kind a₁ a₂ a₃ a₄ a₅ a₆ = Lean.Syntax.node info kind #[a₁, a₂, a₃, a₄, a₅, a₆]

def Lean.Syntax.node7 (info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ : Lean.Syntax) (a₂ : Lean.Syntax) (a₃ : Lean.Syntax) (a₄ : Lean.Syntax) (a₅ : Lean.Syntax) (a₆ : Lean.Syntax) (a₇ : Lean.Syntax) :

Create syntax node with 7 children

Equations

Lean.Syntax.node7 info kind a₁ a₂ a₃ a₄ a₅ a₆ a₇ = Lean.Syntax.node info kind #[a₁, a₂, a₃, a₄, a₅, a₆, a₇]

def Lean.Syntax.node8 (info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ : Lean.Syntax) (a₂ : Lean.Syntax) (a₃ : Lean.Syntax) (a₄ : Lean.Syntax) (a₅ : Lean.Syntax) (a₆ : Lean.Syntax) (a₇ : Lean.Syntax) (a₈ : Lean.Syntax) :

Create syntax node with 8 children

Equations

Lean.Syntax.node8 info kind a₁ a₂ a₃ a₄ a₅ a₆ a₇ a₈ = Lean.Syntax.node info kind #[a₁, a₂, a₃, a₄, a₅, a₆, a₇, a₈]

def Lean.SyntaxNodeKinds :

SyntaxNodeKinds is a set of SyntaxNodeKind (implemented as a list).

Equations

Lean.SyntaxNodeKinds = List Lean.SyntaxNodeKind

structure Lean.TSyntax (ks : Lean.SyntaxNodeKinds) :

The underlying Syntax value.
raw : Lean.Syntax

A Syntax value of one of the given syntax kinds. Note that while syntax quotations produce/expect TSyntax values of the correct kinds, this is not otherwise enforced and can easily be circumvented by direct use of the constructor. The namespace TSyntax.Compat can be opened to expose a general coercion from Syntax to any TSyntax ks for porting older code.

Instances For

instance Lean.instInhabitedSyntax :

Inhabited Lean.Syntax

Equations

Lean.instInhabitedSyntax = { default := Lean.Syntax.missing }

instance Lean.instInhabitedTSyntax {ks : Lean.SyntaxNodeKinds} :

Inhabited (Lean.TSyntax ks)

Equations

Lean.instInhabitedTSyntax = { default := { raw := default } }

Builtin kinds

@[inline]

abbrev Lean.choiceKind :

Lean.SyntaxNodeKind

The choice kind is used when a piece of syntax has multiple parses, and the determination of which to use is deferred until typing information is available.

Equations

Lean.choiceKind = `choice

@[inline]

abbrev Lean.nullKind :

Lean.SyntaxNodeKind

The null kind is used for raw list parsers like many.

Equations

Lean.nullKind = `null

@[inline]

abbrev Lean.groupKind :

Lean.SyntaxNodeKind

The group kind is by the group parser, to avoid confusing with the null kind when used inside optional.

Equations

Lean.groupKind = `group

@[inline]

abbrev Lean.identKind :

Lean.SyntaxNodeKind

ident is not actually used as a node kind, but it is returned by getKind in the ident case so that things that handle different node kinds can also handle ident.

Equations

Lean.identKind = `ident

@[inline]

abbrev Lean.strLitKind :

Lean.SyntaxNodeKind

str is the node kind of string literals like "foo".

Equations

Lean.strLitKind = `str

@[inline]

abbrev Lean.charLitKind :

Lean.SyntaxNodeKind

char is the node kind of character literals like 'A'.

Equations

Lean.charLitKind = `char

@[inline]

abbrev Lean.numLitKind :

Lean.SyntaxNodeKind

num is the node kind of number literals like 42.

Equations

Lean.numLitKind = `num

@[inline]

abbrev Lean.scientificLitKind :

Lean.SyntaxNodeKind

scientific is the node kind of floating point literals like 1.23e-3.

Equations

Lean.scientificLitKind = `scientific

@[inline]

abbrev Lean.nameLitKind :

Lean.SyntaxNodeKind

name is the node kind of name literals like `foo.

Equations

Lean.nameLitKind = `name

@[inline]

abbrev Lean.fieldIdxKind :

Lean.SyntaxNodeKind

fieldIdx is the node kind of projection indices like the 2 in x.2.

Equations

Lean.fieldIdxKind = `fieldIdx

@[inline]

abbrev Lean.interpolatedStrLitKind :

Lean.SyntaxNodeKind

interpolatedStrLitKind is the node kind of interpolated string literal fragments like "value = { and }" in s!"value = {x}".

Equations

Lean.interpolatedStrLitKind = `interpolatedStrLitKind

@[inline]

abbrev Lean.interpolatedStrKind :

Lean.SyntaxNodeKind

interpolatedStrKind is the node kind of an interpolated string literal like "value = {x}" in s!"value = {x}".

Equations

Lean.interpolatedStrKind = `interpolatedStrKind

def Lean.Syntax.getKind (stx : Lean.Syntax) :

Lean.SyntaxNodeKind

Gets the kind of a Syntax node. For non-node syntax, we use "pseudo kinds": identKind for ident, missing for missing, and the atom's string literal for atoms.

Equations

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

def Lean.Syntax.setKind (stx : Lean.Syntax) (k : Lean.SyntaxNodeKind) :

Changes the kind at the root of a Syntax node to k. Does nothing for non-node nodes.

Equations

Lean.Syntax.setKind stx k = match stx with | Lean.Syntax.node info kind args => Lean.Syntax.node info k args | x => stx

def Lean.Syntax.isOfKind (stx : Lean.Syntax) (k : Lean.SyntaxNodeKind) :

Is this a syntax with node kind k?

Equations

Lean.Syntax.isOfKind stx k = (Lean.Syntax.getKind stx == k)

def Lean.Syntax.getArg (stx : Lean.Syntax) (i : Nat) :

Gets the i'th argument of the syntax node. This can also be written stx[i]. Returns missing if i is out of range.

Equations

Lean.Syntax.getArg stx i = match stx with | Lean.Syntax.node info kind args => Array.getD args i Lean.Syntax.missing | x => Lean.Syntax.missing

instance Lean.Syntax.instGetElemSyntaxNatTrue :

GetElem Lean.Syntax Nat Lean.Syntax fun x x => True

Equations

Lean.Syntax.instGetElemSyntaxNatTrue = { getElem := fun stx i x => Lean.Syntax.getArg stx i }

def Lean.Syntax.getArgs (stx : Lean.Syntax) :

Array Lean.Syntax

Gets the list of arguments of the syntax node, or #[] if it's not a node.

Equations

Lean.Syntax.getArgs stx = match stx with | Lean.Syntax.node info kind args => args | x => #[]

def Lean.Syntax.getNumArgs (stx : Lean.Syntax) :

Gets the number of arguments of the syntax node, or 0 if it's not a node.

Equations

Lean.Syntax.getNumArgs stx = match stx with | Lean.Syntax.node info kind args => Array.size args | x => 0

def Lean.Syntax.getOptional? (stx : Lean.Syntax) :

Option Lean.Syntax

Assuming stx was parsed by optional, returns the enclosed syntax if it parsed something and none otherwise.

Equations

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

def Lean.Syntax.isMissing :

Lean.Syntax → Bool

Is this syntax .missing?

Equations

Lean.Syntax.isMissing x = match x with | Lean.Syntax.missing => true | x => false

def Lean.Syntax.isNodeOf (stx : Lean.Syntax) (k : Lean.SyntaxNodeKind) (n : Nat) :

Is this syntax a node with kind k?

Equations

Lean.Syntax.isNodeOf stx k n = (Lean.Syntax.isOfKind stx k && Lean.Syntax.getNumArgs stx == n)

def Lean.Syntax.isIdent :

Lean.Syntax → Bool

stx.isIdent is true iff stx is an identifier.

Equations

Lean.Syntax.isIdent x = match x with | Lean.Syntax.ident info rawVal val preresolved => true | x => false

def Lean.Syntax.getId :

Lean.Syntax → Lean.Name

If this is a ident, return the parsed value, else .anonymous.

Equations

Lean.Syntax.getId x = match x with | Lean.Syntax.ident info rawVal val preresolved => val | x => Lean.Name.anonymous

def Lean.Syntax.setArgs (stx : Lean.Syntax) (args : Array Lean.Syntax) :

Updates the argument list without changing the node kind. Does nothing for non-node nodes.

Equations

Lean.Syntax.setArgs stx args = match stx with | Lean.Syntax.node info k args => Lean.Syntax.node info k args | stx => stx

def Lean.Syntax.setArg (stx : Lean.Syntax) (i : Nat) (arg : Lean.Syntax) :

Updates the i'th argument of the syntax. Does nothing for non-node nodes, or if i is out of bounds of the node list.

Equations

Lean.Syntax.setArg stx i arg = match stx with | Lean.Syntax.node info k args => Lean.Syntax.node info k (Array.setD args i arg) | stx => stx

partial def Lean.Syntax.getHeadInfo? :

Lean.Syntax → Option Lean.SourceInfo

Retrieve the left-most node or leaf's info in the Syntax tree.

partial def Lean.Syntax.getHeadInfo?.loop (args : Array Lean.Syntax) (i : Nat) :

Option Lean.SourceInfo

def Lean.Syntax.getHeadInfo (stx : Lean.Syntax) :

Lean.SourceInfo

Retrieve the left-most leaf's info in the Syntax tree, or none if there is no token.

Equations

Lean.Syntax.getHeadInfo stx = match Lean.Syntax.getHeadInfo? stx with | some info => info | none => Lean.SourceInfo.none

def Lean.Syntax.getPos? (stx : Lean.Syntax) (canonicalOnly : optParam Bool false) :

Option String.Pos

Get the starting position of the syntax, if possible. If canonicalOnly is true, non-canonical synthetic nodes are treated as not carrying position information.

Equations

Lean.Syntax.getPos? stx canonicalOnly = Lean.SourceInfo.getPos? (Lean.Syntax.getHeadInfo stx) canonicalOnly

partial def Lean.Syntax.getTailPos? (stx : Lean.Syntax) (canonicalOnly : optParam Bool false) :

Option String.Pos

Get the ending position of the syntax, if possible. If canonicalOnly is true, non-canonical synthetic nodes are treated as not carrying position information.

partial def Lean.Syntax.getTailPos?.loop (canonicalOnly : optParam Bool false) (args : Array Lean.Syntax) (i : Nat) :

Option String.Pos

structure Lean.Syntax.SepArray (sep : String) :

The array of elements and separators, ordered like #[el1, sep1, el2, sep2, el3].
elemsAndSeps : Array Lean.Syntax

An array of syntax elements interspersed with separators. Can be coerced to/from Array Syntax to automatically remove/insert the separators.

Instances For

structure Lean.Syntax.TSepArray (ks : Lean.SyntaxNodeKinds) (sep : String) :

The array of elements and separators, ordered like #[el1, sep1, el2, sep2, el3].
elemsAndSeps : Array Lean.Syntax

A typed version of SepArray.

Instances For

@[inline]

abbrev Lean.TSyntaxArray (ks : Lean.SyntaxNodeKinds) :

An array of syntaxes of kind ks.

Equations

Lean.TSyntaxArray ks = Array (Lean.TSyntax ks)

unsafe def Lean.TSyntaxArray.rawImpl {ks : Lean.SyntaxNodeKinds} :

Lean.TSyntaxArray ks → Array Lean.Syntax

Implementation of TSyntaxArray.raw.

Equations

Lean.TSyntaxArray.rawImpl = unsafeCast

@[implemented_by Lean.TSyntaxArray.rawImpl]

opaque Lean.TSyntaxArray.raw {ks : Lean.SyntaxNodeKinds} (as : Lean.TSyntaxArray ks) :

Array Lean.Syntax

Converts a TSyntaxArray to an Array Syntax, without reallocation.

unsafe def Lean.TSyntaxArray.mkImpl {ks : Lean.SyntaxNodeKinds} :

Array Lean.Syntax → Lean.TSyntaxArray ks

Implementation of TSyntaxArray.mk.

Equations

Lean.TSyntaxArray.mkImpl = unsafeCast

@[implemented_by Lean.TSyntaxArray.mkImpl]

opaque Lean.TSyntaxArray.mk {ks : Lean.SyntaxNodeKinds} (as : Array Lean.Syntax) :

Lean.TSyntaxArray ks

Converts an Array Syntax to a TSyntaxArray, without reallocation.

def Lean.SourceInfo.fromRef (ref : Lean.Syntax) (canonical : optParam Bool false) :

Lean.SourceInfo

Constructs a synthetic SourceInfo using a ref : Syntax for the span.

Equations

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

def Lean.mkAtom (val : String) :

Constructs a synthetic atom with no source info.

Equations

Lean.mkAtom val = Lean.Syntax.atom Lean.SourceInfo.none val

def Lean.mkAtomFrom (src : Lean.Syntax) (val : String) (canonical : optParam Bool false) :

Constructs a synthetic atom with source info coming from src.

Equations

Lean.mkAtomFrom src val canonical = Lean.Syntax.atom (Lean.SourceInfo.fromRef src canonical) val

Parser descriptions #

inductive Lean.ParserDescr :

A (named) nullary parser, like ppSpace
const: Lean.Name → Lean.ParserDescr
A (named) unary parser, like group(p)
unary: Lean.Name → Lean.ParserDescr → Lean.ParserDescr
A (named) binary parser, like orelse or andthen (written as p1 <|> p2 and p1 p2 respectively in syntax)
binary: Lean.Name → Lean.ParserDescr → Lean.ParserDescr → Lean.ParserDescr
Parses using p, then pops the stack to create a new node with kind kind. The precedence prec is used to determine whether the parser should apply given the current precedence level.
node: Lean.SyntaxNodeKind → Nat → Lean.ParserDescr → Lean.ParserDescr
Like node but for trailing parsers (which start with a nonterminal). Assumes the lhs is already on the stack, and parses using p, then pops the stack including the lhs to create a new node with kind kind. The precedence prec and lhsPrec are used to determine whether the parser should apply.
trailingNode: Lean.SyntaxNodeKind → Nat → Nat → Lean.ParserDescr → Lean.ParserDescr
A literal symbol parser: parses val as a literal. This parser does not work on identifiers, so symbol arguments are declared as "keywords" and cannot be used as identifiers anywhere in the file.
symbol: String → Lean.ParserDescr
Like symbol, but without reserving val as a keyword. If includeIdent is true then ident will be reinterpreted as atom if it matches.
nonReservedSymbol: String → Bool → Lean.ParserDescr
Parses using the category parser catName with right binding power (i.e. precedence) rbp.
cat: Lean.Name → Nat → Lean.ParserDescr
Parses using another parser declName, which can be either a Parser or ParserDescr.
parser: Lean.Name → Lean.ParserDescr
Like node, but also declares that the body can be matched using an antiquotation with name name. For example, def $id:declId := 1 uses an antiquotation with name declId in the place where a declId is expected.
nodeWithAntiquot: String → Lean.SyntaxNodeKind → Lean.ParserDescr → Lean.ParserDescr
A sepBy(p, sep) parses 0 or more occurrences of p separated by sep. psep is usually the same as symbol sep, but it can be overridden. sep is only used in the antiquot syntax: $x;* would match if sep is ";". allowTrailingSep is true if e.g. a, b, is also allowed to match.
sepBy: Lean.ParserDescr → String → Lean.ParserDescr → optParam Bool false → Lean.ParserDescr
sepBy1 is just like sepBy, except it takes 1 or more instead of 0 or more occurrences of p.
sepBy1: Lean.ParserDescr → String → Lean.ParserDescr → optParam Bool false → Lean.ParserDescr

A ParserDescr is a grammar for parsers. This is used by the syntax command to produce parsers without having to import Lean.

Instances For

instance Lean.instInhabitedParserDescr :

Inhabited Lean.ParserDescr

Equations

Lean.instInhabitedParserDescr = { default := Lean.ParserDescr.symbol "" }

@[inline]

abbrev Lean.TrailingParserDescr :

Although TrailingParserDescr is an abbreviation for ParserDescr, Lean will look at the declared type in order to determine whether to add the parser to the leading or trailing parser table. The determination is done automatically by the syntax command.

Equations

Lean.TrailingParserDescr = Lean.ParserDescr

Runtime support for making quotation terms auto-hygienic, by mangling identifiers introduced by them with a "macro scope" supplied by the context. Details to appear in a paper soon.

@[inline]

abbrev Lean.MacroScope :

A macro scope identifier is just a Nat that gets bumped every time we enter a new macro scope. Within a macro scope, all occurrences of identifier x parse to the same thing, but x parsed from different macro scopes will produce different identifiers.

Equations

Lean.MacroScope = Nat

def Lean.reservedMacroScope :

Macro scope used internally. It is not available for our frontend.

Equations

Lean.reservedMacroScope = 0

def Lean.firstFrontendMacroScope :

First macro scope available for our frontend

Equations

Lean.firstFrontendMacroScope = Lean.reservedMacroScope + 1

class Lean.MonadRef (m : Type → Type) :

Get the current value of the ref
getRef : m Lean.Syntax
Run x : m α with a modified value for the ref
withRef : {α : Type} → Lean.Syntax → m α → m α

A MonadRef is a monad that has a ref : Syntax in the read-only state. This is used to keep track of the location where we are working; if an exception is thrown, the ref gives the location where the error will be reported, assuming no more specific location is provided.

Instances

instance Lean.instMonadRef (m : Type → Type) (n : Type → Type) [inst : MonadLift m n] [inst : MonadFunctor m n] [inst : Lean.MonadRef m] :

Lean.MonadRef n

Equations

Lean.instMonadRef m n = { getRef := liftM Lean.getRef, withRef := fun {α} ref x => monadMap (fun {β} => Lean.MonadRef.withRef ref) x }

def Lean.replaceRef (ref : Lean.Syntax) (oldRef : Lean.Syntax) :

Replaces oldRef with ref, unless ref has no position info. This biases us to having a valid span to report an error on.

Equations

Lean.replaceRef ref oldRef = match Lean.Syntax.getPos? ref with | some val => ref | x => oldRef

@[inline]

def Lean.withRef {m : Type → Type} [inst : Monad m] [inst : Lean.MonadRef m] {α : Type} (ref : Lean.Syntax) (x : m α) :

m α

Run x : m α with a modified value for the ref. This is not exactly the same as MonadRef.withRef, because it uses replaceRef to avoid putting syntax with bad spans in the state.

Equations

Lean.withRef ref x = do let oldRef ← Lean.getRef let ref : Lean.Syntax := Lean.replaceRef ref oldRef Lean.MonadRef.withRef ref x

class Lean.MonadQuotation (m : Type → Type) extends Lean.MonadRef :

Get the fresh scope of the current macro invocation
getCurrMacroScope : m Lean.MacroScope
Get the module name of the current file. This is used to ensure that hygienic names don't clash across multiple files.
getMainModule : m Lean.Name
Execute action in a new macro invocation context. This transformer should be used at all places that morally qualify as the beginning of a "macro call", e.g. elabCommand and elabTerm in the case of the elaborator. However, it can also be used internally inside a "macro" if identifiers introduced by e.g. different recursive calls should be independent and not collide. While returning an intermediate syntax tree that will recursively be expanded by the elaborator can be used for the same effect, doing direct recursion inside the macro guarded by this transformer is often easier because one is not restricted to passing a single syntax tree. Modelling this helper as a transformer and not just a monadic action ensures that the current macro scope before the recursive call is restored after it, as expected.
withFreshMacroScope : {α : Type} → m α → m α

A monad that supports syntax quotations. Syntax quotations (in term position) are monadic values that when executed retrieve the current "macro scope" from the monad and apply it to every identifier they introduce (independent of whether this identifier turns out to be a reference to an existing declaration, or an actually fresh binding during further elaboration). We also apply the position of the result of getRef to each introduced symbol, which results in better error positions than not applying any position.

Instances

@[inline]

def Lean.MonadRef.mkInfoFromRefPos {m : Type → Type} [inst : Monad m] [inst : Lean.MonadRef m] :

m Lean.SourceInfo

Construct a synthetic SourceInfo from the ref in the monad state.

Equations

Lean.MonadRef.mkInfoFromRefPos = do let __do_lift ← Lean.getRef pure (Lean.SourceInfo.fromRef __do_lift)

instance Lean.instMonadQuotation {m : Type → Type} {n : Type → Type} [inst : MonadFunctor m n] [inst : MonadLift m n] [inst : Lean.MonadQuotation m] :

Lean.MonadQuotation n

Equations

Lean.instMonadQuotation = Lean.MonadQuotation.mk (liftM Lean.getCurrMacroScope) (liftM Lean.getMainModule) fun {α} => monadMap fun {β} => Lean.withFreshMacroScope

We represent a name with macro scopes as

._@.(.)*.._hyg.

Example: suppose the module name is Init.Data.List.Basic, and name is foo.bla, and macroscopes [2, 5]

foo.bla._@.Init.Data.List.Basic._hyg.2.5

We may have to combine scopes from different files/modules. The main modules being processed is always the right most one. This situation may happen when we execute a macro generated in an imported file in the current file.

foo.bla._@.Init.Data.List.Basic.2.1.Init.Lean.Expr._hyg.4

The delimiter _hyg is used just to improve the hasMacroScopes performance.

def Lean.Name.hasMacroScopes :

Lean.Name → Bool

Does this name have hygienic macro scopes?

Equations

Lean.Name.hasMacroScopes (Lean.Name.str pre s) = (s == "_hyg")
Lean.Name.hasMacroScopes (Lean.Name.num p i) = Lean.Name.hasMacroScopes p
Lean.Name.hasMacroScopes x = false

@[export lean_erase_macro_scopes]

def Lean.Name.eraseMacroScopes (n : Lean.Name) :

Remove the macro scopes from the name.

Equations

Lean.Name.eraseMacroScopes n = match Lean.Name.hasMacroScopes n with | true => Lean.eraseMacroScopesAux n | false => n

@[export lean_simp_macro_scopes]

def Lean.Name.simpMacroScopes (n : Lean.Name) :

Helper function we use to create binder names that do not need to be unique.

Equations

Lean.Name.simpMacroScopes n = match Lean.Name.hasMacroScopes n with | true => Lean.simpMacroScopesAux n | false => n

structure Lean.MacroScopesView :

The original (unhygienic) name.
name : Lean.Name
All the name components (.)* from the imports concatenated together.
imported : Lean.Name
The main module in which this identifier was parsed.
mainModule : Lean.Name
The list of macro scopes.
scopes : List Lean.MacroScope

A MacroScopesView represents a parsed hygienic name. extractMacroScopes will decode it from a Name, and .review will re-encode it. The grammar of a hygienic name is:

._@.(.)*.._hyg.

Instances For

instance Lean.instInhabitedMacroScopesView :

Inhabited Lean.MacroScopesView

Equations

Lean.instInhabitedMacroScopesView = { default := { name := default, imported := default, mainModule := default, scopes := default } }

def Lean.MacroScopesView.review (view : Lean.MacroScopesView) :

Encode a hygienic name from the parsed pieces.

Equations

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

def Lean.extractMacroScopes (n : Lean.Name) :

Lean.MacroScopesView

Revert all addMacroScope calls. v = extractMacroScopes n → n = v.review. This operation is useful for analyzing/transforming the original identifiers, then adding back the scopes (via MacroScopesView.review).

Equations

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

def Lean.addMacroScope (mainModule : Lean.Name) (n : Lean.Name) (scp : Lean.MacroScope) :

Add a new macro scope onto the name n, in the given mainModule.

Equations

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

def Lean.Name.append (a : Lean.Name) (b : Lean.Name) :

Append two names that may have macro scopes. The macro scopes in b are always erased. If a has macro scopes, then the are propagated to result of append a b

Equations

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

instance Lean.instAppendName :

Append Lean.Name

Equations

Lean.instAppendName = { append := Lean.Name.append }

@[inline]

def Lean.MonadQuotation.addMacroScope {m : Type → Type} [inst : Lean.MonadQuotation m] [inst : Monad m] (n : Lean.Name) :

Add a new macro scope onto the name n, using the monad state to supply the main module and current macro scope.

Equations

Lean.MonadQuotation.addMacroScope n = do let mainModule ← Lean.getMainModule let scp ← Lean.getCurrMacroScope pure (Lean.addMacroScope mainModule n scp)

def Lean.defaultMaxRecDepth :

The default maximum recursion depth. This is adjustable using the maxRecDepth option.

Equations

Lean.defaultMaxRecDepth = 512

def Lean.maxRecDepthErrorMessage :

The message to display on stack overflow.

Equations

Lean.maxRecDepthErrorMessage = "maximum recursion depth has been reached (use `set_option maxRecDepth <num>` to increase limit)"

def Lean.Syntax.matchesNull (stx : Lean.Syntax) (n : Nat) :

Is this syntax a null node?

Equations

Lean.Syntax.matchesNull stx n = Lean.Syntax.isNodeOf stx Lean.nullKind n

def Lean.Syntax.matchesIdent (stx : Lean.Syntax) (id : Lean.Name) :

Function used for determining whether a syntax pattern `(id) is matched. There are various conceivable notions of when two syntactic identifiers should be regarded as identical, but semantic definitions like whether they refer to the same global name cannot be implemented without context information (i.e. MonadResolveName). Thus in patterns we default to the structural solution of comparing the identifiers' Name values, though we at least do so modulo macro scopes so that identifiers that "look" the same match. This is particularly useful when dealing with identifiers that do not actually refer to Lean bindings, e.g. in the stx pattern `(many($p)).

Equations

Lean.Syntax.matchesIdent stx id = (Lean.Syntax.isIdent stx && Lean.Name.eraseMacroScopes (Lean.Syntax.getId stx) == Lean.Name.eraseMacroScopes id)

def Lean.Syntax.matchesLit (stx : Lean.Syntax) (k : Lean.SyntaxNodeKind) (val : String) :

Is this syntax a node kind k wrapping an atom _ val?

Equations

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

instance Lean.Macro.instNonemptyMethodsRef :

Nonempty Lean.Macro.MethodsRef

Equations

Lean.Macro.instNonemptyMethodsRef = Lean.Macro.instNonemptyMethodsRef.proof_1

structure Lean.Macro.Context :

An opaque reference to the Methods object. This is done to break a dependency cycle: the Methods involve MacroM which has not been defined yet.
methods : Lean.Macro.MethodsRef
The currently parsing module.
mainModule : Lean.Name
The current macro scope.
currMacroScope : Lean.MacroScope
The current recursion depth.
currRecDepth : Nat
The maximum recursion depth.
maxRecDepth : Nat
The syntax which supplies the position of error messages.
ref : Lean.Syntax

The read-only context for the MacroM monad.

Instances For

inductive Lean.Macro.Exception :

A general error, given a message and a span (expressed as a Syntax).
error: Lean.Syntax → String → Lean.Macro.Exception
An unsupported syntax exception. We keep this separate because it is used for control flow: if one macro does not support a syntax then we try the next one.
unsupportedSyntax: Lean.Macro.Exception

An exception in the MacroM monad.

Instances For

structure Lean.Macro.State :

The global macro scope counter, used for producing fresh scope names.
macroScope : Lean.MacroScope
The list of trace messages that have been produced, each with a trace class and a message.
traceMsgs : List (Lean.Name × String)

The mutable state for the MacroM monad.

Instances For

instance Lean.Macro.instInhabitedState :

Inhabited Lean.Macro.State

Equations

Lean.Macro.instInhabitedState = { default := { macroScope := default, traceMsgs := default } }

@[inline]

abbrev Lean.MacroM (α : Type) :

The MacroM monad is the main monad for macro expansion. It has the information needed to handle hygienic name generation, and is the monad that macro definitions live in.

Notably, this is a (relatively) pure monad: there is no IO and no access to the Environment. That means that things like declaration lookup are impossible here, as well as IO.Ref or other side-effecting operations. For more capabilities, macros can instead be written as elab using adaptExpander.

Equations

Lean.MacroM = ReaderT Lean.Macro.Context (EStateM Lean.Macro.Exception Lean.Macro.State)

@[inline]

abbrev Lean.Macro :

A macro has type Macro, which is a Syntax → MacroM Syntax: it receives an input syntax and is supposed to "expand" it into another piece of syntax.

Equations

Lean.Macro = (Lean.Syntax → Lean.MacroM Lean.Syntax)

instance Lean.Macro.instMonadRefMacroM :

Lean.MonadRef Lean.MacroM

Equations

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

def Lean.Macro.addMacroScope (n : Lean.Name) :

Lean.MacroM Lean.Name

Add a new macro scope to the name n.

Equations

Lean.Macro.addMacroScope n = do let ctx ← read pure (Lean.addMacroScope ctx.mainModule n ctx.currMacroScope)

def Lean.Macro.throwUnsupported {α : Type} :

Throw an unsupportedSyntax exception.

Equations

Lean.Macro.throwUnsupported = throw Lean.Macro.Exception.unsupportedSyntax

def Lean.Macro.throwError {α : Type} (msg : String) :

Throw a error with the given message, using the ref for the location information.

Equations

Lean.Macro.throwError msg = do let ref ← Lean.getRef throw (Lean.Macro.Exception.error ref msg)

def Lean.Macro.throwErrorAt {α : Type} (ref : Lean.Syntax) (msg : String) :

Throw a error with the given message and location information.

Equations

Lean.Macro.throwErrorAt ref msg = Lean.withRef ref (Lean.Macro.throwError msg)

@[inline]

def Lean.Macro.withFreshMacroScope {α : Type} (x : Lean.MacroM α) :

Increments the macro scope counter so that inside the body of x the macro scope is fresh.

Equations

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

@[inline]

def Lean.Macro.withIncRecDepth {α : Type} (ref : Lean.Syntax) (x : Lean.MacroM α) :

Run x with an incremented recursion depth counter.

Equations

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

instance Lean.Macro.instMonadQuotationMacroM :

Lean.MonadQuotation Lean.MacroM

Equations

Lean.Macro.instMonadQuotationMacroM = Lean.MonadQuotation.mk (fun ctx => pure ctx.currMacroScope) (fun ctx => pure ctx.mainModule) fun {α} => Lean.Macro.withFreshMacroScope

structure Lean.Macro.Methods :

Expands macros in the given syntax. A return value of none means there was nothing to expand.
expandMacro? : Lean.Syntax → Lean.MacroM (Option Lean.Syntax)
Get the current namespace in the file.
getCurrNamespace : Lean.MacroM Lean.Name
Check if a given name refers to a declaration.
hasDecl : Lean.Name → Lean.MacroM Bool
Resolves the given name to an overload list of namespaces.
resolveNamespace : Lean.Name → Lean.MacroM (List Lean.Name)
Resolves the given name to a overload list of global definitions. The List String in each alternative is the deduced list of projections (which are ambiguous with name components).
resolveGlobalName : Lean.Name → Lean.MacroM (List (Lean.Name × List String))

The opaque methods that are available to MacroM.

Instances For

instance Lean.Macro.instInhabitedMethods :

Inhabited Lean.Macro.Methods

Equations

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

unsafe def Lean.Macro.mkMethodsImp (methods : Lean.Macro.Methods) :

Lean.Macro.MethodsRef

Implementation of mkMethods.

Equations

Lean.Macro.mkMethodsImp methods = unsafeCast methods

@[implemented_by Lean.Macro.mkMethodsImp]

opaque Lean.Macro.mkMethods (methods : Lean.Macro.Methods) :

Lean.Macro.MethodsRef

Make an opaque reference to a Methods.

instance Lean.Macro.instInhabitedMethodsRef :

Inhabited Lean.Macro.MethodsRef

Equations

Lean.Macro.instInhabitedMethodsRef = { default := Lean.Macro.mkMethods default }

unsafe def Lean.Macro.getMethodsImp :

Lean.MacroM Lean.Macro.Methods

Implementation of getMethods.

Equations

Lean.Macro.getMethodsImp = do let ctx ← read pure (unsafeCast ctx.methods)

@[implemented_by Lean.Macro.getMethodsImp]

opaque Lean.Macro.getMethods :

Lean.MacroM Lean.Macro.Methods

Extract the methods list from the MacroM state.

def Lean.Macro.expandMacro? (stx : Lean.Syntax) :

Lean.MacroM (Option Lean.Syntax)

expandMacro? stx returns some stxNew if stx is a macro, and stxNew is its expansion.

Equations

Lean.expandMacro? stx = do let __do_lift ← Lean.Macro.getMethods Lean.Macro.Methods.expandMacro? __do_lift stx

def Lean.Macro.hasDecl (declName : Lean.Name) :

Lean.MacroM Bool

Returns true if the environment contains a declaration with name declName

Equations

Lean.Macro.hasDecl declName = do let __do_lift ← Lean.Macro.getMethods Lean.Macro.Methods.hasDecl __do_lift declName

def Lean.Macro.getCurrNamespace :

Lean.MacroM Lean.Name

Gets the current namespace given the position in the file.

Equations

Lean.Macro.getCurrNamespace = do let __do_lift ← Lean.Macro.getMethods __do_lift.getCurrNamespace

def Lean.Macro.resolveNamespace (n : Lean.Name) :

Lean.MacroM (List Lean.Name)

Resolves the given name to an overload list of namespaces.

Equations

Lean.Macro.resolveNamespace n = do let __do_lift ← Lean.Macro.getMethods Lean.Macro.Methods.resolveNamespace __do_lift n

def Lean.Macro.resolveGlobalName (n : Lean.Name) :

Lean.MacroM (List (Lean.Name × List String))

Resolves the given name to a overload list of global definitions. The List String in each alternative is the deduced list of projections (which are ambiguous with name components).

Equations

Lean.Macro.resolveGlobalName n = do let __do_lift ← Lean.Macro.getMethods Lean.Macro.Methods.resolveGlobalName __do_lift n

def Lean.Macro.trace (clsName : Lean.Name) (msg : String) :

Lean.MacroM Unit

Add a new trace message, with the given trace class and message.

Equations

Lean.Macro.trace clsName msg = modify fun s => { macroScope := s.macroScope, traceMsgs := (clsName, msg) :: s.traceMsgs }

@[inline]

abbrev Lean.PrettyPrinter.UnexpandM (α : Type) :

The unexpander monad, essentially Syntax → Option α. The Syntax is the ref, and it has the possibility of failure without an error message.

Equations

Lean.PrettyPrinter.UnexpandM = ReaderT Lean.Syntax (EStateM Unit Unit)

@[inline]

abbrev Lean.PrettyPrinter.Unexpander :

Function that tries to reverse macro expansions as a post-processing step of delaboration. While less general than an arbitrary delaborator, it can be declared without importing Lean. Used by the [app_unexpander] attribute.

Equations

Lean.PrettyPrinter.Unexpander = (Lean.Syntax → Lean.PrettyPrinter.UnexpandM Lean.Syntax)

instance Lean.PrettyPrinter.instMonadQuotationUnexpandM :

Lean.MonadQuotation Lean.PrettyPrinter.UnexpandM

Equations

Lean.PrettyPrinter.instMonadQuotationUnexpandM = Lean.MonadQuotation.mk (pure 0) (pure `_fakeMod) fun {α} => id