File: .lake/packages/lean4/src/lean/Lean/Data/HashSet.lean

full_name: Lean.HashSetBucket
code: def HashSetBucket (α : Type u) 
goal: Type u

full_name: Lean.HashSetBucket.update
code: def HashSetBucket.update {α : Type u} (data : HashSetBucket α) (i : USize) (d : List α) (h : i.toNat < data.val.size) : HashSetBucket α 
goal: Lean.HashSetBucket α

full_name: Lean.HashSetBucket.size_update
code: @[simp] theorem HashSetBucket.size_update {α : Type u} (data : HashSetBucket α) (i : USize) (d : List α) (h : i.toNat < data.val.size) :
    (data.update i d h).val.size = data.val.size 
goal: (data.update i d h).val.size = data.val.size

full_name: Lean.HashSetImp.buckets
code: structure HashSetImp (α : Type u) where
  size       : Nat
  buckets    : HashSetBucket α
goal: Lean.HashSetBucket α

full_name: Lean.HashSetImp
code: structure HashSetImp (α : Type u) where
  size       : Nat
  buckets    : HashSetBucket α
goal: Type u

full_name: Lean.HashSetImp.size
code: structure HashSetImp (α : Type u) where
  size       : Nat
  buckets    : HashSetBucket α
goal: Nat

full_name: Lean.mkHashSetImp
code: def mkHashSetImp {α : Type u} (capacity := 8) : HashSetImp α 
goal: Lean.HashSetImp α

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.HashSet.0.Lean.HashSetImp.mkIdx
code: @[extern "lean_hashset_mk_idx"]
private def mkIdx {sz : Nat} (hash : UInt64) (h : sz.isPowerOfTwo) : { u : USize // u.toNat < sz } 
goal: { u // u.toNat < sz }

full_name: Lean.HashSetImp.reinsertAux
code: @[inline] def reinsertAux (hashFn : α → UInt64) (data : HashSetBucket α) (a : α) : HashSetBucket α 
goal: Lean.HashSetBucket α

full_name: Lean.HashSetImp.foldBucketsM
code: @[inline] def foldBucketsM {δ : Type w} {m : Type w → Type w} [Monad m] (data : HashSetBucket α) (d : δ) (f : δ → α → m δ) : m δ 
goal: m δ

full_name: Lean.HashSetImp.foldBuckets
code: @[inline] def foldBuckets {δ : Type w} (data : HashSetBucket α) (d : δ) (f : δ → α → δ) : δ 
goal: δ

full_name: Lean.HashSetImp.foldM
code: @[inline] def foldM {δ : Type w} {m : Type w → Type w} [Monad m] (f : δ → α → m δ) (d : δ) (h : HashSetImp α) : m δ 
goal: m δ

full_name: Lean.HashSetImp.fold
code: @[inline] def fold {δ : Type w} (f : δ → α → δ) (d : δ) (m : HashSetImp α) : δ 
goal: δ

full_name: Lean.HashSetImp.forBucketsM
code: @[inline] def forBucketsM {m : Type w → Type w} [Monad m] (data : HashSetBucket α) (f : α → m PUnit) : m PUnit 
goal: m PUnit

full_name: Lean.HashSetImp.forM
code: @[inline] def forM {m : Type w → Type w} [Monad m] (f : α → m PUnit) (h : HashSetImp α) : m PUnit 
goal: m PUnit

full_name: Lean.HashSetImp.find?
code: def find? [BEq α] [Hashable α] (m : HashSetImp α) (a : α) : Option α 
goal: Option α

full_name: Lean.HashSetImp.contains
code: def contains [BEq α] [Hashable α] (m : HashSetImp α) (a : α) : Bool 
goal: Bool

full_name: Lean.HashSetImp.moveEntries
code: def moveEntries [Hashable α] (i : Nat) (source : Array (List α)) (target : HashSetBucket α) : HashSetBucket α 
goal: Lean.HashSetBucket α

full_name: Lean.HashSetImp.expand
code: def expand [Hashable α] (size : Nat) (buckets : HashSetBucket α) : HashSetImp α 
goal: Lean.HashSetImp α

full_name: Lean.HashSetImp.insert
code: def insert [BEq α] [Hashable α] (m : HashSetImp α) (a : α) : HashSetImp α 
goal: Lean.HashSetImp α

full_name: Lean.HashSetImp.erase
code: def erase [BEq α] [Hashable α] (m : HashSetImp α) (a : α) : HashSetImp α 
goal: Lean.HashSetImp α

full_name: Lean.HashSetImp.WellFormed.insertWff
code: inductive WellFormed [BEq α] [Hashable α] : HashSetImp α → Prop where
  | mkWff     : ∀ n,                  WellFormed (mkHashSetImp n)
  | insertWff : ∀ m a, WellFormed m → WellFormed (insert m a)
  | eraseWff  : ∀ m a, WellFormed m → WellFormed (erase m a)
goal: m.WellFormed → (m.insert a).WellFormed

full_name: Lean.HashSetImp.WellFormed.eraseWff
code: inductive WellFormed [BEq α] [Hashable α] : HashSetImp α → Prop where
  | mkWff     : ∀ n,                  WellFormed (mkHashSetImp n)
  | insertWff : ∀ m a, WellFormed m → WellFormed (insert m a)
  | eraseWff  : ∀ m a, WellFormed m → WellFormed (erase m a)
goal: m.WellFormed → (m.erase a).WellFormed

full_name: Lean.HashSetImp.WellFormed
code: inductive WellFormed [BEq α] [Hashable α] : HashSetImp α → Prop where
  | mkWff     : ∀ n,                  WellFormed (mkHashSetImp n)
  | insertWff : ∀ m a, WellFormed m → WellFormed (insert m a)
  | eraseWff  : ∀ m a, WellFormed m → WellFormed (erase m a)
goal: Lean.HashSetImp α → Prop

full_name: Lean.HashSetImp.WellFormed.mkWff
code: inductive WellFormed [BEq α] [Hashable α] : HashSetImp α → Prop where
  | mkWff     : ∀ n,                  WellFormed (mkHashSetImp n)
  | insertWff : ∀ m a, WellFormed m → WellFormed (insert m a)
  | eraseWff  : ∀ m a, WellFormed m → WellFormed (erase m a)
goal: (Lean.mkHashSetImp n).WellFormed

full_name: Lean.HashSet
code: def HashSet (α : Type u) [BEq α] [Hashable α] 
goal: Type u

full_name: Lean.mkHashSet
code: def mkHashSet {α : Type u} [BEq α] [Hashable α] (capacity := 8) : HashSet α 
goal: Lean.HashSet α

full_name: Lean.HashSet.empty
code: @[inline] def empty [BEq α] [Hashable α] : HashSet α 
goal: Lean.HashSet α

full_name: Lean.HashSet.instInhabited
code: instance [BEq α] [Hashable α] : Inhabited (HashSet α) 
goal: Inhabited (Lean.HashSet α)

full_name: Lean.HashSet.instEmptyCollection
code: instance [BEq α] [Hashable α] : EmptyCollection (HashSet α) 
goal: EmptyCollection (Lean.HashSet α)

full_name: Lean.HashSet.insert
code: @[inline] def insert (m : HashSet α) (a : α) : HashSet α 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.HashSet α → α → Lean.HashSet α

full_name: Lean.HashSet.erase
code: @[inline] def erase (m : HashSet α) (a : α) : HashSet α 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.HashSet α → α → Lean.HashSet α

full_name: Lean.HashSet.find?
code: @[inline] def find? (m : HashSet α) (a : α) : Option α 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.HashSet α → α → Option α

full_name: Lean.HashSet.contains
code: @[inline] def contains (m : HashSet α) (a : α) : Bool 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.HashSet α → α → Bool

full_name: Lean.HashSet.foldM
code: @[inline] def foldM {δ : Type w} {m : Type w → Type w} [Monad m] (f : δ → α → m δ) (init : δ) (h : HashSet α) : m δ 
goal: {x : BEq α} →
  {x_1 : Hashable α} →
    {δ : Type w} → {m : Type w → Type w} → [inst : Monad m] → (δ → α → m δ) → δ → Lean.HashSet α → m δ

full_name: Lean.HashSet.fold
code: @[inline] def fold {δ : Type w} (f : δ → α → δ) (init : δ) (m : HashSet α) : δ 
goal: {x : BEq α} → {x_1 : Hashable α} → {δ : Type w} → (δ → α → δ) → δ → Lean.HashSet α → δ

full_name: Lean.HashSet.forM
code: @[inline] def forM {m : Type w → Type w} [Monad m] (h : HashSet α) (f : α → m PUnit) : m PUnit 
goal: {x : BEq α} → {x_1 : Hashable α} → {m : Type w → Type w} → [inst : Monad m] → Lean.HashSet α → (α → m PUnit) → m PUnit

full_name: Lean.HashSet.instForM
code: instance : ForM m (HashSet α) α 
goal: {x : BEq α} → {x_1 : Hashable α} → {m : Type u_1 → Type u_1} → ForM m (Lean.HashSet α) α

full_name: Lean.HashSet.instForIn
code: instance : ForIn m (HashSet α) α 
goal: {x : BEq α} → {x_1 : Hashable α} → {m : Type (max u_1 u_2) → Type u_1} → ForIn m (Lean.HashSet α) α

full_name: Lean.HashSet.size
code: @[inline] def size (m : HashSet α) : Nat 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.HashSet α → Nat

full_name: Lean.HashSet.isEmpty
code: @[inline] def isEmpty (m : HashSet α) : Bool 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.HashSet α → Bool

full_name: Lean.HashSet.toList
code: def toList (m : HashSet α) : List α 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.HashSet α → List α

full_name: Lean.HashSet.toArray
code: def toArray (m : HashSet α) : Array α 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.HashSet α → Array α

full_name: Lean.HashSet.numBuckets
code: def numBuckets (m : HashSet α) : Nat 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.HashSet α → Nat

full_name: Lean.HashSet.insertMany
code: /-- Insert many elements into a HashSet. -/
def insertMany [ForIn Id ρ α] (s : HashSet α) (as : ρ) : HashSet α 
goal: {x : BEq α} → {x_1 : Hashable α} → {ρ : Type u_1} → [inst : ForIn Id ρ α] → Lean.HashSet α → ρ → Lean.HashSet α

full_name: Lean.HashSet.merge
code: /--
`O(|t|)` amortized. Merge two `HashSet`s.
-/
@[inline]
def merge {α : Type u} [BEq α] [Hashable α] (s t : HashSet α) : HashSet α 
goal: Lean.HashSet α