datastructures

type AbstractMap[K, V, C any] interface {
	// Size returns the number of key-value pairs in the map.
	Size() C
	// Iter returns an iterator over all key-value pairs.
	Iter() iter.Seq2[K, V]
}

type AbstractMatrix[T, C any] interface {
	// Dimensions returns the number of rows (n) and columns (m) in the matrix.
	Dimensions() (n, m C)
	// Transpose returns a new matrix with rows and columns swapped.
	Transpose() T
	// SubMatrix returns a sub-matrix from row1 to row2 and col1 to col2 (exclusive).
	SubMatrix(row1, row2, col1, col2 int) T
	// IsSquare returns true if the matrix has equal rows and columns.
	IsSquare() bool
	// IsDiagonal returns true if all non-diagonal elements are zero.
	IsDiagonal() bool
}

type AbstractSet[E, C any] interface {
	// Cardinality returns the number of elements in the set.
	Cardinality() C
	// Iter returns an iterator over all elements in the set.
	Iter() iter.Seq[E]
	// Contains returns true if the element is in the set.
	Contains(e E) bool
}

type BiMap[K, V any] interface {

	// Reverse returns a view of this bimap with keys and values swapped.
	Reverse() BiMap[V, K]
	// Unfreeze returns a mutable copy of this bimap.
	Unfreeze() MutableBiMap[K, V]
	// contains filtered or unexported methods
}

type Clonable[T any] interface {
	// Clone creates and returns a deep copy of the receiver.
	Clone() T
}

type ConcurrentBiMap[K, V any] interface {

	// Reverse returns a thread-safe view of this bimap with keys and values swapped.
	Reverse() ConcurrentBiMap[V, K]
	// contains filtered or unexported methods
}

type ConcurrentMap[K, V any] interface {

	// Enumerate returns an iterator with index and MapEntry pairs.
	Enumerate() iter.Seq2[int, MapEntry[K, V]]
	// contains filtered or unexported methods
}

type ConcurrentSet[E any] interface {
	// contains filtered or unexported methods
}

type Equatable[T any] interface {
	// Equal checks if the receiver is equal to rhs.
	Equal(rhs T) bool
}

type HashCode uint64

type Hashable[T any] interface {
	Equatable[T]
	// HashCode returns the hash code of the receiver.
	HashCode() HashCode
}

type ImmutableTable[E any] immutableTable[E, ImmutableTable[E]]

type Map[K, V any] interface {

	// Enumerate returns an iterator with index and MapEntry pairs.
	Enumerate() iter.Seq2[int, MapEntry[K, V]]
	// Unfreeze returns a mutable copy of this map.
	Unfreeze() MutableMap[K, V]
	// contains filtered or unexported methods
}

type MapEntry[K any, V any] struct {
	Key   K
	Value V
}

type MutableBiMap[K, V any] interface {

	// Reverse returns a view of this bimap with keys and values swapped.
	Reverse() MutableBiMap[V, K]
	// Freeze returns an immutable snapshot of this bimap.
	Freeze() BiMap[K, V]
	// contains filtered or unexported methods
}

type MutableMap[K, V any] interface {

	// Enumerate returns an iterator with index and MapEntry pairs.
	Enumerate() iter.Seq2[int, MapEntry[K, V]]
	// Freeze returns an immutable snapshot of this map.
	Freeze() Map[K, V]
	// contains filtered or unexported methods
}

type MutableSet[E any] interface {

	// Freeze returns an immutable snapshot of this set.
	Freeze() Set[E]
	// contains filtered or unexported methods
}

type Set[E any] interface {

	// Unfreeze returns a mutable copy of this set.
	Unfreeze() MutableSet[E]
	// contains filtered or unexported methods
}

type Table[E any] mutableTable[E, Table[E]]