File: .lake/packages/lean4/src/lean/Init/Data/Array/Subarray.lean

full_name: Subarray.stop_le_array_size
code: structure Subarray (α : Type u)  where
  array : Array α
  start : Nat
  stop : Nat
  start_le_stop : start ≤ stop
  stop_le_array_size : stop ≤ array.size
goal: self.stop ≤ self.array.size

full_name: Subarray.start
code: structure Subarray (α : Type u)  where
  array : Array α
  start : Nat
  stop : Nat
  start_le_stop : start ≤ stop
  stop_le_array_size : stop ≤ array.size
goal: Nat

full_name: Subarray.stop
code: structure Subarray (α : Type u)  where
  array : Array α
  start : Nat
  stop : Nat
  start_le_stop : start ≤ stop
  stop_le_array_size : stop ≤ array.size
goal: Nat

full_name: Subarray.array
code: structure Subarray (α : Type u)  where
  array : Array α
  start : Nat
  stop : Nat
  start_le_stop : start ≤ stop
  stop_le_array_size : stop ≤ array.size
goal: Array α

full_name: Subarray
code: structure Subarray (α : Type u)  where
  array : Array α
  start : Nat
  stop : Nat
  start_le_stop : start ≤ stop
  stop_le_array_size : stop ≤ array.size
goal: Type u

full_name: Subarray.start_le_stop
code: structure Subarray (α : Type u)  where
  array : Array α
  start : Nat
  stop : Nat
  start_le_stop : start ≤ stop
  stop_le_array_size : stop ≤ array.size
goal: self.start ≤ self.stop

full_name: Subarray.as
code: @[deprecated Subarray.array (since := "2024-04-13")]
abbrev Subarray.as (s : Subarray α) : Array α 
goal: Array α

full_name: Subarray.h₁
code: @[deprecated Subarray.start_le_stop (since := "2024-04-13")]
theorem Subarray.h₁ (s : Subarray α) : s.start ≤ s.stop 
goal: s.start ≤ s.stop

full_name: Subarray.h₂
code: @[deprecated Subarray.stop_le_array_size (since := "2024-04-13")]
theorem Subarray.h₂ (s : Subarray α) : s.stop ≤ s.array.size 
goal: s.stop ≤ s.array.size

full_name: Subarray.size
code: def size (s : Subarray α) : Nat 
goal: Nat

full_name: Subarray.size_le_array_size
code: theorem size_le_array_size {s : Subarray α} : s.size ≤ s.array.size 
goal: s.size ≤ s.array.size

full_name: Subarray.get
code: def get (s : Subarray α) (i : Fin s.size) : α 
goal: α

full_name: Subarray.instGetElemNatLtSize
code: instance : GetElem (Subarray α) Nat α fun xs i => i < xs.size 
goal: GetElem (Subarray α) Nat α fun xs i => i < xs.size

full_name: Subarray.getD
code: @[inline] def getD (s : Subarray α) (i : Nat) (v₀ : α) : α 
goal: α

full_name: Subarray.get!
code: abbrev get! [Inhabited α] (s : Subarray α) (i : Nat) : α 
goal: α

full_name: Subarray.popFront
code: def popFront (s : Subarray α) : Subarray α 
goal: Subarray α

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

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

full_name: Subarray.forIn
code: @[implemented_by Subarray.forInUnsafe]
protected opaque forIn {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (s : Subarray α) (b : β) (f : α → β → m (ForInStep β)) : m β 
goal: m β

full_name: Subarray.instForIn
code: instance : ForIn m (Subarray α) α 
goal: ForIn m (Subarray α) α

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

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

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

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

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

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

full_name: Subarray.foldl
code: @[inline]
def foldl {α : Type u} {β : Type v} (f : β → α → β) (init : β) (as : Subarray α) : β 
goal: β

full_name: Subarray.foldr
code: @[inline]
def foldr {α : Type u} {β : Type v} (f : α → β → β) (init : β) (as : Subarray α) : β 
goal: β

full_name: Subarray.any
code: @[inline]
def any {α : Type u} (p : α → Bool) (as : Subarray α) : Bool 
goal: Bool

full_name: Subarray.all
code: @[inline]
def all {α : Type u} (p : α → Bool) (as : Subarray α) : Bool 
goal: Bool

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

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

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

full_name: Subarray.findRev?
code: @[inline]
def findRev? {α : Type} (as : Subarray α) (p : α → Bool) : Option α 
goal: Option α

full_name: Array.toSubarray
code: def toSubarray (as : Array α) (start : Nat := 0) (stop : Nat := as.size) : Subarray α 
goal: Subarray α

full_name: Array.ofSubarray
code: @[coe]
def ofSubarray (s : Subarray α) : Array α 
goal: Array α

full_name: Array.instCoeSubarray
code: instance : Coe (Subarray α) (Array α) 
goal: Coe (Subarray α) (Array α)

full_name: Array.«term__[_:_]»
code: syntax:max term noWs "[" withoutPosition(term ":" term) "]" : term
goal: Lean.TrailingParserDescr

full_name: Array.«term__[_:]»
code: syntax:max term noWs "[" withoutPosition(term ":") "]" : term
goal: Lean.TrailingParserDescr

full_name: Array.«term__[:_]»
code: syntax:max term noWs "[" withoutPosition(":" term) "]" : term
goal: Lean.TrailingParserDescr

full_name: Array.«_aux_.lake_packages_lean4_src_lean_Init_Data_Array_Subarray___macroRules_Array_term__[_:]_1»
code: macro_rules
  | `($a[$start : $stop]) => `(Array.toSubarray $a $start $stop)
  | `($a[ : $stop])       => `(Array.toSubarray $a 0 $stop)
  | `($a[$start : ])      => `(let a := $a; Array.toSubarray a $start a.size)
goal: Lean.Macro

full_name: Array.«_aux_.lake_packages_lean4_src_lean_Init_Data_Array_Subarray___macroRules_Array_term__[:_]_1»
code: macro_rules
  | `($a[$start : $stop]) => `(Array.toSubarray $a $start $stop)
  | `($a[ : $stop])       => `(Array.toSubarray $a 0 $stop)
  | `($a[$start : ])      => `(let a := $a; Array.toSubarray a $start a.size)
goal: Lean.Macro

full_name: Array.«_aux_.lake_packages_lean4_src_lean_Init_Data_Array_Subarray___macroRules_Array_term__[_:_]_1»
code: macro_rules
  | `($a[$start : $stop]) => `(Array.toSubarray $a $start $stop)
  | `($a[ : $stop])       => `(Array.toSubarray $a 0 $stop)
  | `($a[$start : ])      => `(let a := $a; Array.toSubarray a $start a.size)
goal: Lean.Macro

full_name: Subarray.toArray
code: def Subarray.toArray (s : Subarray α) : Array α 
goal: Array α

full_name: instAppendSubarray
code: instance : Append (Subarray α) 
goal: Append (Subarray α)

full_name: instReprSubarray
code: instance [Repr α] : Repr (Subarray α) 
goal: Repr (Subarray α)

full_name: instToStringSubarray
code: instance [ToString α] : ToString (Subarray α) 
goal: ToString (Subarray α)