Array literal syntax

def «term#[_,]» : Lean.ParserDescr

@[reducible, inline, deprecated Array.toList]

abbrev Array.data {α : Type u_1} (self : Array α) : List α

Preliminary theorems

@[simp]

theorem Array.size_set {α : Type u} (a : Array α) (i : Nat) (v : α) (h : i < a.size) : (a.set i v h).size = a.size

@[simp]

theorem Array.size_push {α : Type u} (a : Array α) (v : α) : (a.push v).size = a.size + 1

theorem Array.ext {α : Type u} (a b : Array α) (h₁ : a.size = b.size) (h₂ : ∀ (i : Nat) (hi₁ : i < a.size) (hi₂ : i < b.size), a[i] = b[i]) : a = b

theorem Array.ext.extAux {α : Type u} (a b : List α) (h₁ : a.length = b.length) (h₂ : ∀ (i : Nat) (hi₁ : i < a.length) (hi₂ : i < b.length), a.get ⟨i, hi₁⟩ = b.get ⟨i, hi₂⟩) : a = b

theorem Array.ext' {α : Type u} {as bs : Array α} (h : as.toList = bs.toList) : as = bs

@[simp]

theorem Array.toArrayAux_eq {α : Type u} (as : List α) (acc : Array α) : (as.toArrayAux acc).toList = acc.toList ++ as

@[simp]

theorem Array.toList_toArray {α : Type u} (as : List α) : as.toArray.toList = as

@[simp]

theorem Array.size_toArray {α : Type u} (as : List α) : as.toArray.size = as.length

@[simp]

theorem Array.getElem_toList {α : Type u} {a : Array α} {i : Nat} (h : i < a.size) : a.toList[i] = a[i]

structure Array.Mem {α : Type u} (as : Array α) (a : α) : Prop

a ∈ as is a predicate which asserts that a is in the array as.

• val : a ∈ as.toList

instance Array.instMembership {α : Type u} : Membership α (Array α)

Equations

• Array.instMembership = { mem := Array.Mem }

theorem Array.mem_def {α : Type u} {a : α} {as : Array α} : a ∈ as ↔ a ∈ as.toList

@[simp]

theorem Array.getElem_mem {α : Type u} {l : Array α} {i : Nat} (h : i < l.size) : l[i] ∈ l

@[simp]

theorem List.toArray_toList {α : Type u} (a : Array α) : a.toList.toArray = a

@[simp]

theorem List.getElem_toArray {α : Type u} {a : List α} {i : Nat} (h : i < a.toArray.size) : a.toArray[i] = a[i]

@[simp]

theorem List.getElem?_toArray {α : Type u} {a : List α} {i : Nat} : a.toArray[i]? = a[i]?

@[simp]

theorem List.getElem!_toArray {α : Type u} [Inhabited α] {a : List α} {i : Nat} : a.toArray[i]! = a[i]!

@[reducible, inline, deprecated Array.toList_toArray]

abbrev Array.data_toArray {α : Type u_1} (as : List α) : as.toArray.toList = as

Equations

• @Array.data_toArray = @Array.toList_toArray

@[reducible, inline, deprecated Array.toList]

abbrev Array.Array.data {α : Type u_1} (self : Array α) : List α

Externs

@[extern lean_array_size]

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

Low-level version of size that directly queries the C array object cached size. While this is not provable, usize always returns the exact size of the array since the implementation only supports arrays of size less than USize.size.

Equations

• a.usize = a.size.toUSize

@[extern lean_array_uget]

def Array.uget {α : Type u} (a : Array α) (i : USize) (h : i.toNat < a.size) : α

Low-level version of fget which is as fast as a C array read. Fin values are represented as tag pointers in the Lean runtime. Thus, fget may be slightly slower than uget.

Equations

• a.uget i h = a[i.toNat]

@[extern lean_array_uset]

def Array.uset {α : Type u} (a : Array α) (i : USize) (v : α) (h : i.toNat < a.size) : Array α

Low-level version of fset which is as fast as a C array fset. Fin values are represented as tag pointers in the Lean runtime. Thus, fset may be slightly slower than uset.

Equations

• a.uset i v h = a.set i.toNat v h

@[extern lean_array_pop]

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

Equations

• a.pop = { toList := a.toList.dropLast }

@[simp]

theorem Array.size_pop {α : Type u} (a : Array α) : a.pop.size = a.size - 1

@[extern lean_mk_array]

def Array.mkArray {α : Type u} (n : Nat) (v : α) : Array α

Equations

• mkArray n v = { toList := List.replicate n v }

@[extern lean_array_fswap]

def Array.swap {α : Type u} (a : Array α) (i j : Nat) (hi : i < a.size := by get_elem_tactic) (hj : j < a.size := by get_elem_tactic) : Array α

Swaps two entries in an array.

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

Equations

• a.swap i j hi hj = (a.set i a[j] hi).set j a[i] ⋯

@[simp]

theorem Array.size_swap {α : Type u} (a : Array α) (i j : Nat) {hi : i < a.size} {hj : j < a.size} : (a.swap i j hi hj).size = a.size

@[extern lean_array_swap]

def Array.swapIfInBounds {α : Type u} (a : Array α) (i j : Nat) : Array α

Swaps two entries in an array, or returns the array unchanged if either index is out of bounds.

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

Equations

• a.swapIfInBounds i j = if h₁ : i < a.size then if h₂ : j < a.size then a.swap i j h₁ h₂ else a else a

@[reducible, inline, deprecated Array.swapIfInBounds]

abbrev Array.swap! {α : Type u_1} (a : Array α) (i j : Nat) : Array α

Equations

• @Array.swap! = @Array.swapIfInBounds

GetElem instance for USize, backed by uget

instance Array.instGetElemUSizeLtNatToNatSize {α : Type u} : GetElem (Array α) USize α fun (xs : Array α) (i : USize) => i.toNat < xs.size

Equations

• Array.instGetElemUSizeLtNatToNatSize = { getElem := fun (xs : Array α) (i : USize) (h : i.toNat < xs.size) => xs.uget i h }

Definitions

instance Array.instEmptyCollection {α : Type u} : EmptyCollection (Array α)

instance Array.instInhabited {α : Type u} : Inhabited (Array α)

Equations

• Array.instInhabited = { default := #[] }

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

Equations

• a.isEmpty = decide (a.size = 0)

@[specialize #[]]

def Array.isEqvAux {α : Type u} (a b : Array α) (hsz : a.size = b.size) (p : α → α → Bool) (i : Nat) : i ≤ a.size → Bool

Equations

• a.isEqvAux b hsz p 0 x_2 = true
• a.isEqvAux b hsz p i.succ h = (p a[i] b[i] && a.isEqvAux b hsz p i ⋯)

@[inline]

def Array.isEqv {α : Type u} (a b : Array α) (p : α → α → Bool) : Bool

Equations

• a.isEqv b p = if h : a.size = b.size then a.isEqvAux b h p a.size ⋯ else false

instance Array.instBEq {α : Type u} [BEq α] : BEq (Array α)

Equations

• Array.instBEq = { beq := fun (a b : Array α) => a.isEqv b BEq.beq }

def Array.ofFn {α : Type u} {n : Nat} (f : Fin n → α) : Array α

ofFn f with f : Fin n → α returns the list whose ith element is f i.

ofFn f = #[f 0, f 1, ... , f(n - 1)]

Equations

• Array.ofFn f = Array.ofFn.go f 0 (Array.mkEmpty n)

def Array.ofFn.go {α : Type u} {n : Nat} (f : Fin n → α) (i : Nat) (acc : Array α) : Array α

Auxiliary for ofFn. ofFn.go f i acc = acc ++ #[f i, ..., f(n - 1)]

Equations

• Array.ofFn.go f i acc = if h : i < n then Array.ofFn.go f (i + 1) (acc.push (f ⟨i, h⟩)) else acc

def Array.range (n : Nat) : Array Nat

The array #[0, 1, ..., n - 1].

Equations

• Array.range n = Array.ofFn fun (i : Fin n) => ↑i

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

Equations

• Array.singleton v = mkArray 1 v

def Array.back! {α : Type u} [Inhabited α] (a : Array α) : α

Equations

• a.back! = a.get! (a.size - 1)

@[reducible, inline, deprecated Array.back!]

abbrev Array.back {α : Type u_1} [Inhabited α] (a : Array α) : α

def Array.get? {α : Type u} (a : Array α) (i : Nat) : Option α

Equations

• a.get? i = if h : i < a.size then some a[i] else none

def Array.back? {α : Type u} (a : Array α) : Option α

Equations

• a.back? = a[a.size - 1]?

@[inline]

def Array.swapAt {α : Type u} (a : Array α) (i : Nat) (v : α) (hi : i < a.size := by get_elem_tactic) : α × Array α

Equations

• a.swapAt i v hi = (a[i], a.set i v hi)

@[inline]

def Array.swapAt! {α : Type u} (a : Array α) (i : Nat) (v : α) : α × Array α

Equations

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

def Array.take {α : Type u} (a : Array α) (n : Nat) : Array α

take a n returns the first n elements of a.

Equations

• a.take n = Array.take.loop (a.size - n) a

def Array.take.loop {α : Type u} : Nat → Array α → Array α

Equations

• Array.take.loop 0 x = x
• Array.take.loop n.succ x = Array.take.loop n x.pop

@[reducible, inline, deprecated Array.take]

abbrev Array.shrink {α : Type u_1} (a : Array α) (n : Nat) : Array α

@[inline]

unsafe def Array.modifyMUnsafe {α : Type u} {m : Type u → Type u_1} [Monad m] (a : Array α) (i : Nat) (f : α → m α) : m (Array α)

@[implemented_by Array.modifyMUnsafe]

def Array.modifyM {α : Type u} {m : Type u → Type u_1} [Monad m] (a : Array α) (i : Nat) (f : α → m α) : m (Array α)

Equations

• a.modifyM i f = if h : i < a.size then let v := a[i]; do let v ← f v pure (a.set i v h) else pure a

@[inline]

def Array.modify {α : Type u} (a : Array α) (i : Nat) (f : α → α) : Array α

Equations

• a.modify i f = (a.modifyM i f).run

@[inline]

def Array.modifyOp {α : Type u} (self : Array α) (idx : Nat) (f : α → α) : Array α

@[inline]

unsafe def Array.forIn'Unsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (b : β) (f : (a : α) → a ∈ as → β → m (ForInStep β)) : m β

We claim this unsafe implementation is correct because an array cannot have more than usizeSz elements in our runtime.

This kind of low level trick can be removed with a little bit of compiler support. For example, if the compiler simplifies as.size < usizeSz to true.

@[specialize #[]]

unsafe def Array.forIn'Unsafe.loop {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (f : (a : α) → a ∈ as → β → m (ForInStep β)) (sz i : USize) (b : β) : m β

@[implemented_by Array.forIn'Unsafe]

def Array.forIn' {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (b : β) (f : (a : α) → a ∈ as → β → m (ForInStep β)) : m β

Reference implementation for forIn'

Equations

• as.forIn' b f = Array.forIn'.loop as f as.size ⋯ b

def Array.forIn'.loop {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (f : (a : α) → a ∈ as → β → m (ForInStep β)) (i : Nat) (h : i ≤ as.size) (b : β) : m β

Equations

• One or more equations did not get rendered due to their size.
• Array.forIn'.loop as f 0 x_2 b = pure b

instance Array.instForIn'InferInstanceMembership {α : Type u} {m : Type u_1 → Type u_2} : ForIn' m (Array α) α inferInstance

Equations

• Array.instForIn'InferInstanceMembership = { forIn' := fun {β : Type ?u.19} [Monad m] => Array.forIn' }

@[inline]

unsafe def Array.foldlMUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : β → α → m β) (init : β) (as : Array α) (start : Nat := 0) (stop : Nat := as.size) : m β

See comment at forIn'Unsafe

@[specialize #[]]

unsafe def Array.foldlMUnsafe.fold {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : β → α → m β) (as : Array α) (i stop : USize) (b : β) : m β

@[implemented_by Array.foldlMUnsafe]

def Array.foldlM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : β → α → m β) (init : β) (as : Array α) (start : Nat := 0) (stop : Nat := as.size) : m β

Reference implementation for foldlM

Equations

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

def Array.foldlM.loop {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : β → α → m β) (as : Array α) (stop : Nat) (h : stop ≤ as.size) (i j : Nat) (b : β) : m β

Equations

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

@[inline]

unsafe def Array.foldrMUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → β → m β) (init : β) (as : Array α) (start : Nat := as.size) (stop : Nat := 0) : m β

See comment at forIn'Unsafe

@[specialize #[]]

unsafe def Array.foldrMUnsafe.fold {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → β → m β) (as : Array α) (i stop : USize) (b : β) : m β

@[implemented_by Array.foldrMUnsafe]

def Array.foldrM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → β → m β) (init : β) (as : Array α) (start : Nat := as.size) (stop : Nat := 0) : m β

Reference implementation for foldrM

Equations

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

def Array.foldrM.fold {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → β → m β) (as : Array α) (stop : Nat := 0) (i : Nat) (h : i ≤ as.size) (b : β) : m β

Equations

• One or more equations did not get rendered due to their size.
• Array.foldrM.fold f as stop 0 x_2 b = if (0 == stop) = true then pure b else pure b

@[inline]

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

See comment at forIn'Unsafe

@[specialize #[]]

unsafe def Array.mapMUnsafe.map {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → m β) (sz i : USize) (r : Array NonScalar) : m (Array PNonScalar)

@[implemented_by Array.mapMUnsafe]

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

Reference implementation for mapM

Equations

• Array.mapM f as = Array.mapM.map f as 0 (Array.mkEmpty as.size)

def Array.mapM.map {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → m β) (as : Array α) (i : Nat) (r : Array β) : m (Array β)

Equations

• Array.mapM.map f as i r = if hlt : i < as.size then do let __do_lift ← f as[i] Array.mapM.map f as (i + 1) (r.push __do_lift) else pure r

@[reducible, inline, deprecated Array.mapM]

abbrev Array.sequenceMap {α : Type u_1} {β : Type u_2} {m : Type u_2 → Type u_3} [Monad m] (f : α → m β) (as : Array α) : m (Array β)

Equations

• @Array.sequenceMap = @Array.mapM

@[inline]

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

Variant of mapIdxM which receives the index as a Fin as.size.

Equations

• as.mapFinIdxM f = Array.mapFinIdxM.map as f as.size 0 ⋯ (Array.mkEmpty as.size)

@[specialize #[]]

def Array.mapFinIdxM.map {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (f : Fin as.size → α → m β) (i j : Nat) (inv : i + j = as.size) (bs : Array β) : m (Array β)

Equations

• Array.mapFinIdxM.map as f 0 j x bs = pure bs
• Array.mapFinIdxM.map as f i_2.succ j inv_2 bs = do let __do_lift ← f ⟨j, ⋯⟩ (as.get j ⋯) Array.mapFinIdxM.map as f i_2 (j + 1) ⋯ (bs.push __do_lift)

@[inline]

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

Equations

• Array.mapIdxM f as = as.mapFinIdxM fun (i : Fin as.size) (a : α) => f (↑i) a

@[inline]

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

Equations

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

@[inline]

def Array.findM? {α : Type} {m : Type → Type} [Monad m] (p : α → m Bool) (as : Array α) : m (Option α)

Equations

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

@[inline]

def Array.findIdxM? {α : Type u} {m : Type → Type u_1} [Monad m] (p : α → m Bool) (as : Array α) : m (Option Nat)

Equations

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

@[inline]

unsafe def Array.anyMUnsafe {α : Type u} {m : Type → Type w} [Monad m] (p : α → m Bool) (as : Array α) (start : Nat := 0) (stop : Nat := as.size) : m Bool

@[specialize #[]]

unsafe def Array.anyMUnsafe.any {α : Type u} {m : Type → Type w} [Monad m] (p : α → m Bool) (as : Array α) (i stop : USize) : m Bool

@[implemented_by Array.anyMUnsafe]

def Array.anyM {α : Type u} {m : Type → Type w} [Monad m] (p : α → m Bool) (as : Array α) (start : Nat := 0) (stop : Nat := as.size) : m Bool

Equations

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

def Array.anyM.loop {α : Type u} {m : Type → Type w} [Monad m] (p : α → m Bool) (as : Array α) (stop : Nat) (h : stop ≤ as.size) (j : Nat) : m Bool

Equations

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

@[inline]

def Array.allM {α : Type u} {m : Type → Type w} [Monad m] (p : α → m Bool) (as : Array α) (start : Nat := 0) (stop : Nat := as.size) : m Bool

Equations

• Array.allM p as start stop = do let __do_lift ← Array.anyM (fun (v : α) => do let __do_lift ← p v pure !__do_lift) as start stop pure !__do_lift

@[inline]

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

Equations

• Array.findSomeRevM? f as = Array.findSomeRevM?.find f as as.size ⋯

@[specialize #[]]

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

Equations

• Array.findSomeRevM?.find f as 0 x_2 = pure none
• Array.findSomeRevM?.find f as i.succ h = do let r ← f as[i] match r with | some val => pure r | none => let_fun this := ⋯; Array.findSomeRevM?.find f as i this

@[inline]

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

Equations

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

@[inline]

def Array.forM {α : Type u} {m : Type v → Type w} [Monad m] (f : α → m PUnit) (as : Array α) (start : Nat := 0) (stop : Nat := as.size) : m PUnit

@[inline]

def Array.forRevM {α : Type u} {m : Type v → Type w} [Monad m] (f : α → m PUnit) (as : Array α) (start : Nat := as.size) (stop : Nat := 0) : m PUnit

Equations

• Array.forRevM f as start stop = Array.foldrM (fun (a : α) (x : PUnit) => f a) PUnit.unit as start stop

@[inline]

def Array.foldl {α : Type u} {β : Type v} (f : β → α → β) (init : β) (as : Array α) (start : Nat := 0) (stop : Nat := as.size) : β

Equations

• Array.foldl f init as start stop = (Array.foldlM f init as start stop).run

@[inline]

def Array.foldr {α : Type u} {β : Type v} (f : α → β → β) (init : β) (as : Array α) (start : Nat := as.size) (stop : Nat := 0) : β

Equations

• Array.foldr f init as start stop = (Array.foldrM f init as start stop).run

@[inline]

def Array.map {α : Type u} {β : Type v} (f : α → β) (as : Array α) : Array β

Equations

• Array.map f as = (Array.mapM f as).run

@[inline]

def Array.mapFinIdx {α : Type u} {β : Type v} (as : Array α) (f : Fin as.size → α → β) : Array β

Variant of mapIdx which receives the index as a Fin as.size.

Equations

• as.mapFinIdx f = (as.mapFinIdxM f).run

@[inline]

def Array.mapIdx {α : Type u} {β : Type v} (f : Nat → α → β) (as : Array α) : Array β

def Array.zipWithIndex {α : Type u} (arr : Array α) : Array (α × Nat)

Turns #[a, b] into #[(a, 0), (b, 1)].

Equations

• arr.zipWithIndex = Array.mapIdx (fun (i : Nat) (a : α) => (a, i)) arr

@[inline]

def Array.find? {α : Type} (p : α → Bool) (as : Array α) : Option α

Equations

• Array.find? p as = (Array.findM? p as).run

@[inline]

def Array.findSome? {α : Type u} {β : Type v} (f : α → Option β) (as : Array α) : Option β

Equations

• Array.findSome? f as = (Array.findSomeM? f as).run

@[inline]

def Array.findSome! {α : Type u} {β : Type v} [Inhabited β] (f : α → Option β) (a : Array α) : β

Equations

• Array.findSome! f a = match Array.findSome? f a with | some b => b | none => panicWithPosWithDecl "Init.Data.Array.Basic" "Array.findSome!" 599 14 "failed to find element"

@[inline]

def Array.findSomeRev? {α : Type u} {β : Type v} (f : α → Option β) (as : Array α) : Option β

Equations

• Array.findSomeRev? f as = (Array.findSomeRevM? f as).run

@[inline]

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

Equations

• Array.findRev? p as = (Array.findRevM? p as).run

@[inline]

def Array.findIdx? {α : Type u} (p : α → Bool) (as : Array α) : Option Nat

Equations

• Array.findIdx? p as = Array.findIdx?.loop p as 0

def Array.findIdx?.loop {α : Type u} (p : α → Bool) (as : Array α) (j : Nat) : Option Nat

@[inline]

def Array.findFinIdx? {α : Type u} (p : α → Bool) (as : Array α) : Option (Fin as.size)

def Array.findFinIdx?.loop {α : Type u} (p : α → Bool) (as : Array α) (j : Nat) : Option (Fin as.size)

Equations

• Array.findFinIdx?.loop p as j = if h : j < as.size then if p as[j] = true then some ⟨j, h⟩ else Array.findFinIdx?.loop p as (j + 1) else none

def Array.indexOfAux {α : Type u} [BEq α] (a : Array α) (v : α) (i : Nat) : Option (Fin a.size)

Equations

• a.indexOfAux v i = if h : i < a.size then if (a[i] == v) = true then some ⟨i, h⟩ else a.indexOfAux v (i + 1) else none

def Array.indexOf? {α : Type u} [BEq α] (a : Array α) (v : α) : Option (Fin a.size)

Equations

• a.indexOf? v = a.indexOfAux v 0

@[deprecated Array.indexOf?]

def Array.getIdx? {α : Type u} [BEq α] (a : Array α) (v : α) : Option Nat

@[inline]

def Array.any {α : Type u} (as : Array α) (p : α → Bool) (start : Nat := 0) (stop : Nat := as.size) : Bool

Equations

• as.any p start stop = (Array.anyM p as start stop).run

@[inline]

def Array.all {α : Type u} (as : Array α) (p : α → Bool) (start : Nat := 0) (stop : Nat := as.size) : Bool

def Array.contains {α : Type u} [BEq α] (as : Array α) (a : α) : Bool

Equations

• as.contains a = as.any fun (x : α) => x == a

def Array.elem {α : Type u} [BEq α] (a : α) (as : Array α) : Bool

Equations

• Array.elem a as = as.contains a

@[export lean_array_to_list_impl]

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

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

Equations

• as.toListImpl = Array.foldr List.cons [] as

@[inline]

def Array.toListAppend {α : Type u} (as : Array α) (l : List α) : List α

Prepends an Array α onto the front of a list. Equivalent to as.toList ++ l.

Equations

• as.toListAppend l = Array.foldr List.cons l as

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

instance Array.instAppend {α : Type u} : Append (Array α)

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

instance Array.instHAppendList {α : Type u} : HAppend (Array α) (List α) (Array α)

Equations

• Array.instHAppendList = { hAppend := Array.appendList }

@[inline]

def Array.flatMapM {α : Type u} {m : Type u_1 → Type u_2} {β : Type u_1} [Monad m] (f : α → m (Array β)) (as : Array α) : m (Array β)

Equations

• Array.flatMapM f as = Array.foldlM (fun (bs : Array β) (a : α) => do let __do_lift ← f a pure (bs ++ __do_lift)) #[] as

@[reducible, inline, deprecated Array.flatMapM]

abbrev Array.concatMapM {α : Type u_1} {m : Type u_2 → Type u_3} {β : Type u_2} [Monad m] (f : α → m (Array β)) (as : Array α) : m (Array β)

Equations

• @Array.concatMapM = @Array.flatMapM

@[inline]

def Array.flatMap {α : Type u} {β : Type u_1} (f : α → Array β) (as : Array α) : Array β

Equations

• Array.flatMap f as = Array.foldl (fun (bs : Array β) (a : α) => bs ++ f a) #[] as

@[reducible, inline, deprecated Array.flatMap]

abbrev Array.concatMap {α : Type u_1} {β : Type u_2} (f : α → Array β) (as : Array α) : Array β

@[inline]

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

Joins array of array into a single array.

flatten #[#[a₁, a₂, ⋯], #[b₁, b₂, ⋯], ⋯] = #[a₁, a₂, ⋯, b₁, b₂, ⋯]

Equations

• as.flatten = Array.foldl (fun (r a : Array α) => r ++ a) #[] as

@[inline]

def Array.filter {α : Type u} (p : α → Bool) (as : Array α) (start : Nat := 0) (stop : Nat := as.size) : Array α

Equations

• Array.filter p as start stop = Array.foldl (fun (r : Array α) (a : α) => if p a = true then r.push a else r) #[] as start stop

@[inline]

def Array.filterM {m : Type → Type u_1} {α : Type} [Monad m] (p : α → m Bool) (as : Array α) (start : Nat := 0) (stop : Nat := as.size) : m (Array α)

@[specialize #[]]

def Array.filterMapM {α : Type u} {m : Type u_1 → Type u_2} {β : Type u_1} [Monad m] (f : α → m (Option β)) (as : Array α) (start : Nat := 0) (stop : Nat := as.size) : m (Array β)

Equations

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

@[inline]

def Array.filterMap {α : Type u} {β : Type u_1} (f : α → Option β) (as : Array α) (start : Nat := 0) (stop : Nat := as.size) : Array β

@[specialize #[]]

def Array.getMax? {α : Type u} (as : Array α) (lt : α → α → Bool) : Option α

Equations

• as.getMax? lt = if h : 0 < as.size then let a0 := as[0]; some (Array.foldl (fun (best a : α) => if lt best a = true then a else best) a0 as 1) else none

@[inline]

def Array.partition {α : Type u} (p : α → Bool) (as : Array α) : Array α × Array α

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

Equations

• as.reverse = if h : as.size ≤ 1 then as else Array.reverse.loop as 0 ⟨as.size - 1, ⋯⟩

theorem Array.reverse.termination {i j : Nat} (h : i < j) : j - 1 - (i + 1) < j - i

@[irreducible]

def Array.reverse.loop {α : Type u} (as : Array α) (i : Nat) (j : Fin as.size) : Array α

Equations

• Array.reverse.loop as i j = if h : i < ↑j then let_fun this := ⋯; let as_1 := as.swap i ↑j ⋯ ⋯; let_fun this := ⋯; Array.reverse.loop as_1 (i + 1) ⟨↑j - 1, this⟩ else as

def Array.popWhile {α : Type u} (p : α → Bool) (as : Array α) : Array α

Equations

• Array.popWhile p as = if h : as.size > 0 then if p as[as.size - 1] = true then Array.popWhile p as.pop else as else as

def Array.takeWhile {α : Type u} (p : α → Bool) (as : Array α) : Array α

Equations

• Array.takeWhile p as = Array.takeWhile.go p as 0 #[]

def Array.takeWhile.go {α : Type u} (p : α → Bool) (as : Array α) (i : Nat) (r : Array α) : Array α

Equations

• Array.takeWhile.go p as i r = if h : i < as.size then let a := as[i]; if p a = true then Array.takeWhile.go p as (i + 1) (r.push a) else r else r

def Array.eraseIdx {α : Type u} (a : Array α) (i : Nat) (h : i < a.size := by get_elem_tactic) : Array α

Remove the element at a given index from an array without a runtime bounds checks, using a Nat index and a tactic-provided bound.

This function takes worst case O(n) time because it has to backshift all elements at positions greater than i.

Equations

• a.eraseIdx i h = if h' : i + 1 < a.size then let a' := a.swap (i + 1) i h' h; a'.eraseIdx (i + 1) ⋯ else a.pop

@[simp]

theorem Array.size_eraseIdx {α : Type u} (a : Array α) (i : Nat) (h : i < a.size) : (a.eraseIdx i h).size = a.size - 1

def Array.eraseIdxIfInBounds {α : Type u} (a : Array α) (i : Nat) : Array α

Remove the element at a given index from an array, or do nothing if the index is out of bounds.

This function takes worst case O(n) time because it has to backshift all elements at positions greater than i.

Equations

• a.eraseIdxIfInBounds i = if h : i < a.size then a.eraseIdx i h else a

def Array.eraseIdx! {α : Type u} (a : Array α) (i : Nat) : Array α

Remove the element at a given index from an array, or panic if the index is out of bounds.

This function takes worst case O(n) time because it has to backshift all elements at positions greater than i.

def Array.erase {α : Type u} [BEq α] (as : Array α) (a : α) : Array α

Equations

• as.erase a = match as.indexOf? a with | none => as | some i => as.eraseIdx ↑i ⋯

def Array.eraseP {α : Type u} (as : Array α) (p : α → Bool) : Array α

Erase the first element that satisfies the predicate p.

@[inline]

def Array.insertIdx {α : Type u} (as : Array α) (i : Nat) (a : α) : autoParam (i ≤ as.size) _auto✝ → Array α

Insert element a at position i.

Equations

• as.insertIdx i a x = Array.insertIdx.loop i (as.push a) ⟨as.size, ⋯⟩

def Array.insertIdx.loop {α : Type u} (i : Nat) (as : Array α) (j : Fin as.size) : Array α

Equations

• Array.insertIdx.loop i as j = if i < ↑j then let j' := ⟨↑j - 1, ⋯⟩; let as_1 := as.swap ↑j' ↑j ⋯ ⋯; Array.insertIdx.loop i as_1 ⟨↑j', ⋯⟩ else as

@[reducible, inline, deprecated Array.insertIdx]

abbrev Array.insertAt {α : Type u_1} (as : Array α) (i : Nat) (a : α) : autoParam (i ≤ as.size) _auto✝ → Array α

Equations

• @Array.insertAt = @Array.insertIdx

def Array.insertIdx! {α : Type u} (as : Array α) (i : Nat) (a : α) : Array α

Insert element a at position i. Panics if i is not i ≤ as.size.

@[reducible, inline, deprecated Array.insertIdx!]

abbrev Array.insertAt! {α : Type u_1} (as : Array α) (i : Nat) (a : α) : Array α

def Array.insertIdxIfInBounds {α : Type u} (as : Array α) (i : Nat) (a : α) : Array α

Insert element a at position i, or do nothing if as.size < i.

Equations

• as.insertIdxIfInBounds i a = if h : i ≤ as.size then as.insertIdx i a h else as

def Array.isPrefixOfAux {α : Type u} [BEq α] (as bs : Array α) (hle : as.size ≤ bs.size) (i : Nat) : Bool

Equations

• as.isPrefixOfAux bs hle i = if h : i < as.size then let a := as[i]; let_fun this := ⋯; let b := bs[i]; if (a == b) = true then as.isPrefixOfAux bs hle (i + 1) else false else true

def Array.isPrefixOf {α : Type u} [BEq α] (as bs : Array α) : Bool

Return true iff as is a prefix of bs. That is, bs = as ++ t for some t : List α.

Equations

• as.isPrefixOf bs = if h : as.size ≤ bs.size then as.isPrefixOfAux bs h 0 else false

@[specialize #[]]

def Array.zipWithAux {α : Type u} {β : Type u_1} {γ : Type u_2} (as : Array α) (bs : Array β) (f : α → β → γ) (i : Nat) (cs : Array γ) : Array γ

Equations

• as.zipWithAux bs f i cs = if h : i < as.size then let a := as[i]; if h : i < bs.size then let b := bs[i]; as.zipWithAux bs f (i + 1) (cs.push (f a b)) else cs else cs

@[inline]

def Array.zipWith {α : Type u} {β : Type u_1} {γ : Type u_2} (as : Array α) (bs : Array β) (f : α → β → γ) : Array γ

Equations

• as.zipWith bs f = as.zipWithAux bs f 0 #[]

def Array.zip {α : Type u} {β : Type u_1} (as : Array α) (bs : Array β) : Array (α × β)

Equations

• as.zip bs = as.zipWith bs Prod.mk

def Array.zipWithAll {α : Type u} {β : Type u_1} {γ : Type u_2} (as : Array α) (bs : Array β) (f : Option α → Option β → γ) : Array γ

Equations

• as.zipWithAll bs f = Array.zipWithAll.go f as bs 0 #[]

@[irreducible]

def Array.zipWithAll.go {α : Type u} {β : Type u_1} {γ : Type u_2} (f : Option α → Option β → γ) (as : Array α) (bs : Array β) (i : Nat) (cs : Array γ) : Array γ

Equations

• Array.zipWithAll.go f as bs i cs = if i < max as.size bs.size then let a := as[i]?; let b := bs[i]?; Array.zipWithAll.go f as bs (i + 1) (cs.push (f a b)) else cs

def Array.unzip {α : Type u} {β : Type u_1} (as : Array (α × β)) : Array α × Array β

Equations

• as.unzip = Array.foldl (fun (x : Array α × Array β) (x_1 : α × β) => match x with | (as, bs) => match x_1 with | (a, b) => (as.push a, bs.push b)) (#[], #[]) as

@[deprecated Array.partition]

def Array.split {α : Type u} (as : Array α) (p : α → Bool) : Array α × Array α

Equations

• as.split p = Array.foldl (fun (x : Array α × Array α) (a : α) => match x with | (as, bs) => if p a = true then (as.push a, bs) else (as, bs.push a)) (#[], #[]) as

Auxiliary functions used in metaprogramming.

We do not currently intend to provide verification theorems for these functions.

@[inline]

def Array.reduceOption {α : Type u} (as : Array (Option α)) : Array α

Drop nones from a Array, and replace each remaining some a with a.

Equations

• as.reduceOption = Array.filterMap id as

eraseReps

def Array.eraseReps {α : Type u_1} [BEq α] (as : Array α) : Array α

O(|l|). Erase repeated adjacent elements. Keeps the first occurrence of each run.

• eraseReps #[1, 3, 2, 2, 2, 3, 5] = #[1, 3, 2, 3, 5]

allDiff

def Array.allDiff {α : Type u} [BEq α] (as : Array α) : Bool

getEvenElems

@[inline]

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

Repr and ToString

instance Array.instRepr {α : Type u} [Repr α] : Repr (Array α)

instance Array.instToString {α : Type u} [ToString α] : ToString (Array α)

Equations

• Array.instToString = { toString := fun (a : Array α) => "#" ++ toString a.toList }