File: .lake/packages/lean4/src/lean/lake/Lake/Toml/Data/Dict.lean

full_name: Lake.Toml.RBDict.indices
code: structure RBDict (α : Type u) (β : Type v) (cmp : α → α → Ordering)  where
  items : Array (α × β)
  indices : RBMap α Nat cmp
  deriving Inhabited
goal: Lean.RBMap α Nat cmp

full_name: Lake.Toml.instInhabitedRBDict
code: structure RBDict (α : Type u) (β : Type v) (cmp : α → α → Ordering)  where
  items : Array (α × β)
  indices : RBMap α Nat cmp
  deriving Inhabited
goal: {a : Type u_1} → {a_1 : Type u_2} → {a_2 : a → a → Ordering} → Inhabited (Lake.Toml.RBDict a a_1 a_2)

full_name: Lake.Toml.RBDict.items
code: structure RBDict (α : Type u) (β : Type v) (cmp : α → α → Ordering)  where
  items : Array (α × β)
  indices : RBMap α Nat cmp
  deriving Inhabited
goal: Array (α × β)

full_name: Lake.Toml.RBDict
code: structure RBDict (α : Type u) (β : Type v) (cmp : α → α → Ordering)  where
  items : Array (α × β)
  indices : RBMap α Nat cmp
  deriving Inhabited
goal: Type (max u v)

full_name: Lake.Toml.NameDict
code: abbrev NameDict (α : Type u) 
goal: Type u

full_name: Lake.Toml.RBDict.empty
code: def empty : RBDict α β cmp 
goal: Lake.Toml.RBDict α β cmp

full_name: Lake.Toml.RBDict.instEmptyCollection
code: instance : EmptyCollection (RBDict α β cmp) 
goal: EmptyCollection (Lake.Toml.RBDict α β cmp)

full_name: Lake.Toml.RBDict.mkEmpty
code: def mkEmpty (capacity : Nat) : RBDict α β cmp 
goal: Lake.Toml.RBDict α β cmp

full_name: Lake.Toml.RBDict.ofArray
code: def ofArray (items : Array (α × β)) : RBDict α β cmp 
goal: Lake.Toml.RBDict α β cmp

full_name: Lake.Toml.RBDict.beq
code: protected def beq [BEq (α × β)] (self other : RBDict α β cmp) : Bool 
goal: Bool

full_name: Lake.Toml.RBDict.instBEqOfProd
code: instance [BEq (α × β)] : BEq (RBDict α β cmp) 
goal: BEq (Lake.Toml.RBDict α β cmp)

full_name: Lake.Toml.RBDict.size
code: abbrev size (t : RBDict α β cmp) : Nat 
goal: Nat

full_name: Lake.Toml.RBDict.isEmpty
code: abbrev isEmpty (t : RBDict α β cmp) : Bool 
goal: Bool

full_name: Lake.Toml.RBDict.keys
code: def keys (t : RBDict α β cmp) : Array α 
goal: Array α

full_name: Lake.Toml.RBDict.values
code: def values (t : RBDict α β cmp) : Array β 
goal: Array β

full_name: Lake.Toml.RBDict.contains
code: def contains (k : α) (t : RBDict α β cmp) : Bool 
goal: Bool

full_name: Lake.Toml.RBDict.findIdx?
code: def findIdx? (k : α) (t : RBDict α β cmp) : Option (Fin t.size) 
goal: Option (Fin t.size)

full_name: Lake.Toml.RBDict.findEntry?
code: def findEntry? (k : α) (t : RBDict α β cmp) : Option (α × β) 
goal: Option (α × β)

full_name: Lake.Toml.RBDict.find?
code: @[inline] def find? (k : α) (t : RBDict α β cmp) : Option β 
goal: Option β

full_name: Lake.Toml.RBDict.push
code: def push (k : α) (v : β) (t : RBDict α β cmp) : RBDict α β cmp 
goal: Lake.Toml.RBDict α β cmp

full_name: Lake.Toml.RBDict.alter
code: @[specialize] def alter (k : α) (f : Option β → β) (t : RBDict α β cmp) : RBDict α β cmp 
goal: Lake.Toml.RBDict α β cmp

full_name: Lake.Toml.RBDict.insert
code: def insert (k : α) (v : β) (t : RBDict α β cmp) : RBDict α β cmp 
goal: Lake.Toml.RBDict α β cmp

full_name: Lake.Toml.RBDict.insertIf
code: /-- Inserts the value into the dictionary if `p` is `true`. -/
@[macro_inline] def insertIf (p : Bool) (k : α) (v : β) (t : RBDict α β cmp) : RBDict α β cmp 
goal: Lake.Toml.RBDict α β cmp

full_name: Lake.Toml.RBDict.insertUnless
code: /-- Inserts the value into the dictionary if `p` is `false`. -/
@[macro_inline] def insertUnless (p : Bool) (k : α) (v : β) (t : RBDict α β cmp) : RBDict α β cmp 
goal: Lake.Toml.RBDict α β cmp

full_name: Lake.Toml.RBDict.insertSome
code: /-- Insert the value into the dictionary if it is not `none`. -/
@[macro_inline] def insertSome (k : α) (v? : Option β) (t : RBDict α β cmp) : RBDict α β cmp 
goal: Lake.Toml.RBDict α β cmp

full_name: Lake.Toml.RBDict.appendArray
code: def appendArray (self : RBDict α β cmp) (other : Array (α × β)): RBDict α β cmp 
goal: Lake.Toml.RBDict α β cmp

full_name: Lake.Toml.RBDict.instHAppendArrayProd
code: instance : HAppend (RBDict α β cmp) (Array (α × β)) (RBDict α β cmp) 
goal: HAppend (Lake.Toml.RBDict α β cmp) (Array (α × β)) (Lake.Toml.RBDict α β cmp)

full_name: Lake.Toml.RBDict.append
code: @[inline] def append (self other : RBDict α β cmp) : RBDict α β cmp 
goal: Lake.Toml.RBDict α β cmp

full_name: Lake.Toml.RBDict.instAppend
code: instance : Append (RBDict α β cmp) 
goal: Append (Lake.Toml.RBDict α β cmp)

full_name: Lake.Toml.RBDict.map
code: @[inline] def map (f : α → β → γ) (t : RBDict α β cmp) : RBDict α γ cmp 
goal: Lake.Toml.RBDict α γ cmp

full_name: Lake.Toml.RBDict.filter
code: @[inline] def filter (p : α → β → Bool) (t : RBDict α β cmp) : RBDict α β cmp 
goal: Lake.Toml.RBDict α β cmp

full_name: Lake.Toml.RBDict.filterMap
code: @[inline] def filterMap (f : α → β → Option γ) (t : RBDict α β cmp) : RBDict α γ cmp 
goal: Lake.Toml.RBDict α γ cmp