Documentation

Init.Data.Array.OfFn

Theorems about Array.ofFn #

ofFn #

source
@[simp]
theorem Array.ofFn_zero {α : Type u_1} {f : Fin 0 → α} :
ofFn f = #[]
source
theorem Array.ofFn_succ {n : Nat} {α : Type u_1} {f : Fin (n + 1) → α} :
ofFn f = (ofFn fun (i : Fin n) => f i.castSucc).push (f ⟨n, ⋯⟩)
source
theorem Array.ofFn_add {α : Type u_1} {n m : Nat} {f : Fin (n + m) → α} :
ofFn f = (ofFn fun (i : Fin n) => f (Fin.castLE ⋯ i)) ++ ofFn fun (i : Fin m) => f (Fin.natAdd n i)
source
@[simp]
theorem List.toArray_ofFn {n : Nat} {α : Type u_1} {f : Fin n → α} :
(ofFn f).toArray = Array.ofFn f
source
@[simp]
theorem Array.toList_ofFn {n : Nat} {α : Type u_1} {f : Fin n → α} :
(ofFn f).toList = List.ofFn f
source
theorem Array.ofFn_succ' {n : Nat} {α : Type u_1} {f : Fin (n + 1) → α} :
ofFn f = #[f 0] ++ ofFn fun (i : Fin n) => f i.succ
source
@[simp]
theorem Array.ofFn_getElem {α : Type u_1} {xs : Array α} :
(ofFn fun (i : Fin xs.size) => xs[↑i]) = xs
source
@[simp]
theorem Array.ofFn_eq_empty_iff {n : Nat} {α : Type u_1} {f : Fin n → α} :
ofFn f = #[] ↔ n = 0
source
@[simp]
theorem Array.mem_ofFn {α : Type u_1} {n : Nat} {f : Fin n → α} {a : α} :
a ∈ ofFn f ↔ ∃ (i : Fin n), f i = a
source
@[simp]
theorem Array.map_ofFn {n : Nat} {α : Type u_1} {β : Type u_2} {f : Fin n → α} {g : α → β} :
map g (ofFn f) = ofFn (g ∘ f)

ofFnM #

source
def Array.ofFnM {m : Type u_1 → Type u_2} {α : Type u_1} {n : Nat} [Monad m] (f : Fin n → m α) :
m (Array α)

Construct (in a monadic context) an array by applying a monadic function to each index.

Equations
Instances For
    source
    @[simp]
    theorem Array.ofFnM_zero {m : Type u_1 → Type u_2} {α : Type u_1} [Monad m] {f : Fin 0 → m α} :
    ofFnM f = pure #[]
    source
    theorem Array.ofFnM_succ' {m : Type u_1 → Type u_2} {α : Type u_1} {n : Nat} [Monad m] [LawfulMonad m] {f : Fin (n + 1) → m α} :
    ofFnM f = do let a ← f 0 let as ← ofFnM fun (i : Fin n) => f i.succ pure (#[a] ++ as)
    source
    theorem Array.ofFnM_succ {m : Type u_1 → Type u_2} {α : Type u_1} {n : Nat} [Monad m] [LawfulMonad m] {f : Fin (n + 1) → m α} :
    ofFnM f = do let as ← ofFnM fun (i : Fin n) => f i.castSucc let a ← f (Fin.last n) pure (as.push a)
    source
    theorem Array.ofFnM_add {k : Nat} {α : Type u_1} {n : Nat} {m : Type u_1 → Type u_2} [Monad m] [LawfulMonad m] {f : Fin (n + k) → m α} :
    ofFnM f = do let as ← ofFnM fun (i : Fin n) => f (Fin.castLE ⋯ i) let bs ← ofFnM fun (i : Fin k) => f (Fin.natAdd n i) pure (as ++ bs)
    source
    @[simp]
    theorem Array.toList_ofFnM {m : Type u_1 → Type u_2} {n : Nat} {α : Type u_1} [Monad m] [LawfulMonad m] {f : Fin n → m α} :
    toList <$> ofFnM f = List.ofFnM f
    source
    @[simp]
    theorem Array.ofFnM_pure_comp {m : Type u_1 → Type u_2} {α : Type u_1} [Monad m] [LawfulMonad m] {n : Nat} {f : Fin n → α} :
    ofFnM (pure ∘ f) = pure (ofFn f)
    source
    theorem Array.ofFnM_pure {m : Type u_1 → Type u_2} {α : Type u_1} [Monad m] [LawfulMonad m] {n : Nat} {f : Fin n → α} :
    (ofFnM fun (i : Fin n) => pure (f i)) = pure (ofFn f)
    source
    @[simp]
    theorem Array.idRun_ofFnM {n : Nat} {α : Type u_1} {f : Fin n → Id α} :
    (ofFnM f).run = ofFn fun (i : Fin n) => (f i).run