Documentation

Init.Data.Array.Subarray

structure Subarray (α : Type u) :

Type u

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

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

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); Array.get s.as { val := s.start + i.val, isLt := this }

@[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₀

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

α

Equations

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

def Subarray.getOp {α : Type u_1} [inst : Inhabited α] (self : Subarray α) (idx : Nat) :

α

Equations

Subarray.getOp self idx = Subarray.get! self idx

def Subarray.popFront {α : Type u_1} (s : 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} [inst : 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} [inst : 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.

@[implementedBy Subarray.forInUnsafe]

opaque Subarray.forIn {α : Type u} {β : Type v} {m : Type v → Type w} [inst : 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} [inst : 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} [inst : 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} [inst : Monad m] (p : α → m Bool) (as : Subarray α) :

Equations

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

@[inline]

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

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} [inst : Monad m] (f : α → m PUnit) (as : Subarray α) :

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} [inst : Monad m] (f : α → m PUnit) (as : Subarray α) :

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 α) :

Equations

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

@[inline]

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

Equations

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

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

Equations

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

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

Equations

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

def Array.extract {α : Type u} (as : Array α) (start : Nat) (stop : Nat) :

Equations

Array.extract as start stop = Array.ofSubarray (Array.toSubarray as start stop)

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 α) :

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} [inst : Repr α] :

Repr (Subarray α)

Equations

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

instance instToStringSubarray {α : Type u_1} [inst : ToString α] :

ToString (Subarray α)

Equations

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