structure Subarray (α : Type u) : Type u

• as : Array α
• start : Nat
• stop : Nat
• h₁ : s.start ≤ s.stop
• h₂ : s.stop ≤ Array.size s.as

def Subarray.size {α : Type u_1} (s : Subarray α) : Nat

Equations

• Subarray.size s = s.stop - s.start

def Subarray.get {α : Type u_1} (s : Subarray α) (i : Fin (Subarray.size s)) : α

Equations

• Subarray.get s i = let_fun this := (_ : s.start + i.val < Array.size s.as); s.as[s.start + i.val]

instance Subarray.instGetElemSubarrayNatLtInstLTNatSize {α : Type u_1} : GetElem (Subarray α) Nat α fun xs i => i < Subarray.size xs

Equations

• Subarray.instGetElemSubarrayNatLtInstLTNatSize = { getElem := fun xs i h => Subarray.get xs { val := i, isLt := h } }

@[inline]

def Subarray.getD {α : Type u_1} (s : Subarray α) (i : Nat) (v₀ : α) : α

Equations

• Subarray.getD s i v₀ = if h : i < Subarray.size s then Subarray.get s { val := i, isLt := h } else v₀

@[inline, reducible]

abbrev Subarray.get! {α : Type u_1} [Inhabited α] (s : Subarray α) (i : Nat) : α

Equations

• Subarray.get! s i = Subarray.getD s i default

def Subarray.popFront {α : Type u_1} (s : Subarray α) : Subarray α

Equations

• Subarray.popFront s = if h : s.start < s.stop then { as := s.as, start := s.start + 1, stop := s.stop, h₁ := (_ : s.start + 1 ≤ s.stop), h₂ := (_ : s.stop ≤ Array.size s.as) } else s

@[inline]

unsafe def Subarray.forInUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (s : Subarray α) (b : β) (f : α → β → m (ForInStep β)) : m β

Equations

• Subarray.forInUnsafe s b f = let sz := USize.ofNat s.stop; Subarray.forInUnsafe.loop s f sz (USize.ofNat s.start) b

@[specialize #[]]

unsafe def Subarray.forInUnsafe.loop {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (s : Subarray α) (f : α → β → m (ForInStep β)) (sz : USize) (i : USize) (b : β) : m β

Equations

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

@[implemented_by Subarray.forInUnsafe]

opaque Subarray.forIn {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (s : Subarray α) (b : β) (f : α → β → m (ForInStep β)) : m β

instance Subarray.instForInSubarray {m : Type u_1 → Type u_2} {α : Type u_3} : ForIn m (Subarray α) α

Equations

• Subarray.instForInSubarray = { forIn := fun {β} [Monad m] => Subarray.forIn }

@[inline]

def Subarray.foldlM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : β → α → m β) (init : β) (as : Subarray α) : m β

Equations

• Subarray.foldlM f init as = Array.foldlM f init as.as as.start as.stop

@[inline]

def Subarray.foldrM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → β → m β) (init : β) (as : Subarray α) : m β

Equations

• Subarray.foldrM f init as = Array.foldrM f init as.as as.stop as.start

@[inline]

def Subarray.anyM {α : Type u} {m : Type → Type w} [Monad m] (p : α → m Bool) (as : Subarray α) : m Bool

Equations

• Subarray.anyM p as = Array.anyM p as.as as.start as.stop

@[inline]

def Subarray.allM {α : Type u} {m : Type → Type w} [Monad m] (p : α → m Bool) (as : Subarray α) : m Bool

Equations

• Subarray.allM p as = Array.allM p as.as as.start as.stop

@[inline]

def Subarray.forM {α : Type u} {m : Type v → Type w} [Monad m] (f : α → m PUnit) (as : Subarray α) : m PUnit

Equations

• Subarray.forM f as = Array.forM f as.as as.start as.stop

@[inline]

def Subarray.forRevM {α : Type u} {m : Type v → Type w} [Monad m] (f : α → m PUnit) (as : Subarray α) : m PUnit

Equations

• Subarray.forRevM f as = Array.forRevM f as.as as.stop as.start

@[inline]

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

Equations

• Subarray.foldl f init as = Id.run (Subarray.foldlM f init as)

@[inline]

def Subarray.foldr {α : Type u} {β : Type v} (f : α → β → β) (init : β) (as : Subarray α) : β

Equations

• Subarray.foldr f init as = Id.run (Subarray.foldrM f init as)

@[inline]

def Subarray.any {α : Type u} (p : α → Bool) (as : Subarray α) : Bool

Equations

• Subarray.any p as = Id.run (Subarray.anyM p as)

@[inline]

def Subarray.all {α : Type u} (p : α → Bool) (as : Subarray α) : Bool

Equations

• Subarray.all p as = Id.run (Subarray.allM p as)

@[inline]

def Subarray.findSomeRevM? {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Subarray α) (f : α → m (Option β)) : m (Option β)

Equations

• Subarray.findSomeRevM? as f = Subarray.findSomeRevM?.find as f (Subarray.size as) (_ : Subarray.size as ≤ Subarray.size as)

@[specialize #[]]

def Subarray.findSomeRevM?.find {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Subarray α) (f : α → m (Option β)) (i : Nat) : i ≤ Subarray.size as → m (Option β)

Equations

• One or more equations did not get rendered due to their size.
• Subarray.findSomeRevM?.find as f 0 x_2 = pure none

@[inline]

def Subarray.findRevM? {α : Type} {m : Type → Type w} [Monad m] (as : Subarray α) (p : α → m Bool) : m (Option α)

Equations

• Subarray.findRevM? as p = Subarray.findSomeRevM? as fun a => do let __do_lift ← p a pure (if __do_lift = true then some a else none)

@[inline]

def Subarray.findRev? {α : Type} (as : Subarray α) (p : α → Bool) : Option α

Equations

• Subarray.findRev? as p = Id.run (Subarray.findRevM? as p)

def Array.toSubarray {α : Type u} (as : Array α) (start : optParam Nat 0) (stop : optParam Nat (Array.size as)) : Subarray α

Equations

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

def Array.ofSubarray {α : Type u} (s : Subarray α) : Array α

Equations

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

instance Array.instCoeSubarrayArray {α : Type u} : Coe (Subarray α) (Array α)

Equations

• Array.instCoeSubarrayArray = { coe := Array.ofSubarray }

def Array.«term__[_:_]» : Lean.TrailingParserDescr

Equations

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

def Array.«term__[_:]» : Lean.TrailingParserDescr

Equations

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

def Array.«term__[:_]» : Lean.TrailingParserDescr

Equations

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

def Subarray.toArray {α : Type u_1} (s : Subarray α) : Array α

Equations

• Subarray.toArray s = Array.ofSubarray s

instance instAppendSubarray {α : Type u_1} : Append (Subarray α)

Equations

• instAppendSubarray = { append := fun x y => let a := Subarray.toArray x ++ Subarray.toArray y; Array.toSubarray a 0 (Array.size a) }

instance instReprSubarray {α : Type u_1} [Repr α] : Repr (Subarray α)

Equations

• instReprSubarray = { reprPrec := fun s x => repr (Subarray.toArray s) ++ Std.Format.text ".toSubarray" }

instance instToStringSubarray {α : Type u_1} [ToString α] : ToString (Subarray α)

Equations

• instToStringSubarray = { toString := fun s => toString (Subarray.toArray s) }