structure Std.Range : Type

• start : Nat
• stop : Nat
• step : Nat

instance Std.instMembershipNatRange : Membership Nat Std.Range

Equations

• Std.instMembershipNatRange = { mem := fun (i : Nat) (r : Std.Range) => r.start ≤ i ∧ i < r.stop }

@[inline]

def Std.Range.forIn {β : Type u} {m : Type u → Type v} [Monad m] (range : Std.Range) (init : β) (f : Nat → β → m (ForInStep β)) : m β

Equations

• Std.Range.forIn range init f = Std.Range.forIn.loop f range.stop range.start range.stop range.step init

@[specialize #[]]

def Std.Range.forIn.loop {β : Type u} {m : Type u → Type v} [Monad m] (f : Nat → β → m (ForInStep β)) (fuel : Nat) (i : Nat) (stop : Nat) (step : Nat) (b : β) : m β

Equations

• One or more equations did not get rendered due to their size.
• Std.Range.forIn.loop f 0 i stop step b = if i ≥ stop then pure b else pure b

instance Std.Range.instForInRangeNat {m : Type u_1 → Type u_2} : ForIn m Std.Range Nat

Equations

• Std.Range.instForInRangeNat = { forIn := fun {β : Type u_1} [Monad m] => Std.Range.forIn }

@[inline]

def Std.Range.forIn' {β : Type u} {m : Type u → Type v} [Monad m] (range : Std.Range) (init : β) (f : (i : Nat) → i ∈ range → β → m (ForInStep β)) : m β

Equations

• Std.Range.forIn' range init f = Std.Range.forIn'.loop range.start range.stop range.step f range.stop range.start (_ : range.start ≤ range.start) init

@[specialize #[]]

def Std.Range.forIn'.loop {β : Type u} {m : Type u → Type v} [Monad m] (start : Nat) (stop : Nat) (step : Nat) (f : (i : Nat) → start ≤ i ∧ i < stop → β → m (ForInStep β)) (fuel : Nat) (i : Nat) (hl : start ≤ i) (b : β) : m β

Equations

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

instance Std.Range.instForIn'RangeNatInferInstanceMembershipInstMembershipNatRange {m : Type u_1 → Type u_2} : ForIn' m Std.Range Nat inferInstance

Equations

• Std.Range.instForIn'RangeNatInferInstanceMembershipInstMembershipNatRange = { forIn' := fun {β : Type u_1} [Monad m] => Std.Range.forIn' }

@[inline]

def Std.Range.forM {m : Type u → Type v} [Monad m] (range : Std.Range) (f : Nat → m PUnit) : m PUnit

Equations

• Std.Range.forM range f = Std.Range.forM.loop f range.stop range.start range.stop range.step

@[specialize #[]]

def Std.Range.forM.loop {m : Type u → Type v} [Monad m] (f : Nat → m PUnit) (fuel : Nat) (i : Nat) (stop : Nat) (step : Nat) : m PUnit

Equations

• Std.Range.forM.loop f 0 i stop step = if i ≥ stop then pure PUnit.unit else pure PUnit.unit
• Std.Range.forM.loop f (Nat.succ fuel_2) i stop step = if i ≥ stop then pure PUnit.unit else do f i Std.Range.forM.loop f fuel_2 (i + step) stop step

instance Std.Range.instForMRangeNat {m : Type u_1 → Type u_2} : ForM m Std.Range Nat

Equations

• Std.Range.instForMRangeNat = { forM := fun [Monad m] => Std.Range.forM }

def Std.Range.«term[:_]» : Lean.ParserDescr

Equations

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

def Std.Range.«term[_:_]» : Lean.ParserDescr

Equations

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

def Std.Range.«term[:_:_]» : Lean.ParserDescr

Equations

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

def Std.Range.«term[_:_:_]» : Lean.ParserDescr

Equations

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

theorem Membership.mem.upper {i : Nat} {r : Std.Range} (h : i ∈ r) : i < r.stop

theorem Membership.mem.lower {i : Nat} {r : Std.Range} (h : i ∈ r) : r.start ≤ i

theorem Membership.get_elem_helper {i : Nat} {n : Nat} {r : Std.Range} (h₁ : i ∈ r) (h₂ : r.stop = n) : i < n