File: .lake/packages/lean4/src/lean/Init/Data/FloatArray/Basic.lean

full_name: FloatArray.data
code: structure FloatArray where
  data : Array Float
goal: Array Float

full_name: FloatArray
code: structure FloatArray where
  data : Array Float
goal: Type

full_name: FloatArray.mkEmpty
code: @[extern "lean_mk_empty_float_array"]
def mkEmpty (c : @& Nat) : FloatArray 
goal: FloatArray

full_name: FloatArray.empty
code: def empty : FloatArray 
goal: FloatArray

full_name: FloatArray.instInhabited
code: instance : Inhabited FloatArray 
goal: Inhabited FloatArray

full_name: FloatArray.instEmptyCollection
code: instance : EmptyCollection FloatArray 
goal: EmptyCollection FloatArray

full_name: FloatArray.push
code: @[extern "lean_float_array_push"]
def push : FloatArray → Float → FloatArray
  
goal: FloatArray → Float → FloatArray

full_name: FloatArray.size
code: @[extern "lean_float_array_size"]
def size : (@& FloatArray) → Nat
  
goal: FloatArray → Nat

full_name: FloatArray.uget
code: @[extern "lean_float_array_uget"]
def uget : (a : @& FloatArray) → (i : USize) → i.toNat < a.size → Float
  
goal: i.toNat < a.size → Float

full_name: FloatArray.get
code: @[extern "lean_float_array_fget"]
def get : (ds : @& FloatArray) → (@& Fin ds.size) → Float
  
goal: Fin ds.size → Float

full_name: FloatArray.get!
code: @[extern "lean_float_array_get"]
def get! : (@& FloatArray) → (@& Nat) → Float
  
goal: FloatArray → Nat → Float

full_name: FloatArray.get?
code: def get? (ds : FloatArray) (i : Nat) : Option Float 
goal: Option Float

full_name: FloatArray.instGetElemNatFloatLtSize
code: instance : GetElem FloatArray Nat Float fun xs i => i < xs.size 
goal: GetElem FloatArray Nat Float fun xs i => i < xs.size

full_name: FloatArray.instGetElemUSizeFloatLtNatValValSize
code: instance : GetElem FloatArray USize Float fun xs i => i.val < xs.size 
goal: GetElem FloatArray USize Float fun xs i => ↑i.val < xs.size

full_name: FloatArray.uset
code: @[extern "lean_float_array_uset"]
def uset : (a : FloatArray) → (i : USize) → Float → i.toNat < a.size → FloatArray
  
goal: Float → i.toNat < a.size → FloatArray

full_name: FloatArray.set
code: @[extern "lean_float_array_fset"]
def set : (ds : FloatArray) → (@& Fin ds.size) → Float → FloatArray
  
goal: Fin ds.size → Float → FloatArray

full_name: FloatArray.set!
code: @[extern "lean_float_array_set"]
def set! : FloatArray → (@& Nat) → Float → FloatArray
  
goal: FloatArray → Nat → Float → FloatArray

full_name: FloatArray.isEmpty
code: def isEmpty (s : FloatArray) : Bool 
goal: Bool

full_name: FloatArray.toList.loop
code: partial def toList (ds : FloatArray) : List Float 
goal: List Float

full_name: FloatArray.toList
code: partial def toList (ds : FloatArray) : List Float 
goal: List Float

full_name: FloatArray.forInUnsafe.loop
code: /--
  We claim this unsafe implementation is correct because an array cannot have more than `usizeSz` elements in our runtime.
  This is similar to the `Array` version.
-/
-- TODO: avoid code duplication in the future after we improve the compiler.
@[inline] unsafe def forInUnsafe {β : Type v} {m : Type v → Type w} [Monad m] (as : FloatArray) (b : β) (f : Float → β → m (ForInStep β)) : m β 
goal: m β

full_name: FloatArray.forInUnsafe
code: /--
  We claim this unsafe implementation is correct because an array cannot have more than `usizeSz` elements in our runtime.
  This is similar to the `Array` version.
-/
-- TODO: avoid code duplication in the future after we improve the compiler.
@[inline] unsafe def forInUnsafe {β : Type v} {m : Type v → Type w} [Monad m] (as : FloatArray) (b : β) (f : Float → β → m (ForInStep β)) : m β 
goal: m β

full_name: FloatArray.forIn.loop
code: /-- Reference implementation for `forIn` -/
@[implemented_by FloatArray.forInUnsafe]
protected def forIn {β : Type v} {m : Type v → Type w} [Monad m] (as : FloatArray) (b : β) (f : Float → β → m (ForInStep β)) : m β 
goal: m β

full_name: FloatArray.forIn
code: /-- Reference implementation for `forIn` -/
@[implemented_by FloatArray.forInUnsafe]
protected def forIn {β : Type v} {m : Type v → Type w} [Monad m] (as : FloatArray) (b : β) (f : Float → β → m (ForInStep β)) : m β 
goal: m β

full_name: FloatArray.instForInFloat
code: instance : ForIn m FloatArray Float 
goal: ForIn m FloatArray Float

full_name: FloatArray.foldlMUnsafe
code: /-- See comment at `forInUnsafe` -/
-- TODO: avoid code duplication.
@[inline]
unsafe def foldlMUnsafe {β : Type v} {m : Type v → Type w} [Monad m] (f : β → Float → m β) (init : β) (as : FloatArray) (start := 0) (stop := as.size) : m β 
goal: m β

full_name: FloatArray.foldlMUnsafe.fold
code: /-- See comment at `forInUnsafe` -/
-- TODO: avoid code duplication.
@[inline]
unsafe def foldlMUnsafe {β : Type v} {m : Type v → Type w} [Monad m] (f : β → Float → m β) (init : β) (as : FloatArray) (start := 0) (stop := as.size) : m β 
goal: m β

full_name: FloatArray.foldlM.loop
code: /-- Reference implementation for `foldlM` -/
@[implemented_by foldlMUnsafe]
def foldlM {β : Type v} {m : Type v → Type w} [Monad m] (f : β → Float → m β) (init : β) (as : FloatArray) (start := 0) (stop := as.size) : m β 
goal: m β

full_name: FloatArray.foldlM
code: /-- Reference implementation for `foldlM` -/
@[implemented_by foldlMUnsafe]
def foldlM {β : Type v} {m : Type v → Type w} [Monad m] (f : β → Float → m β) (init : β) (as : FloatArray) (start := 0) (stop := as.size) : m β 
goal: m β

full_name: FloatArray.foldl
code: @[inline]
def foldl {β : Type v} (f : β → Float → β) (init : β) (as : FloatArray) (start := 0) (stop := as.size) : β 
goal: β

full_name: List.toFloatArray
code: def List.toFloatArray (ds : List Float) : FloatArray 
goal: FloatArray

full_name: List.toFloatArray.loop
code: def List.toFloatArray (ds : List Float) : FloatArray 
goal: List Float → FloatArray → FloatArray

full_name: instToStringFloatArray
code: instance : ToString FloatArray 
goal: ToString FloatArray