collection

type Collection[T any] interface {
	// Add adds the specified element to this collection.
	Add(e T) bool

	// AddAll adds all of the elements in the this collection.
	AddAll(c ...T) bool

	// Clear removes all of the elements from this collection.
	Clear()

	// Contains returns true if this collection contains the specified element.
	Contains(e T) bool

	// ContainsAll returns true if this collection contains all of the elements in the specified collection.
	ContainsAll(c ...T) bool

	// Equals compares this collection with the object pass from parameter.
	Equals(o any) bool

	// ForEach performs the given handler for each elements in the collection until all elements have been processed or the handler returns an error.
	ForEach(func(e T) error) error

	// IsEmpty returns true if this collection contains no elements.
	IsEmpty() bool

	// Iter returns a channel of all elements in this collection.
	Iter() <-chan T

	// Remove removes the specified element from this collection.
	Remove(e T) bool

	// RemoveAll removes all of the elements in the specified collection from this collection.
	RemoveAll(c ...T) bool

	// Size returns the number of elements in this collection.
	Size() int

	// ToSlice returns a slice containing all of the elements in this collection.
	ToSlice() []T
}

type ConcurrentHashSet[T comparable] struct {
	// contains filtered or unexported fields
}

type HashMap[K comparable, V any] map[K]V

type HashSet[T comparable] map[T]struct{}

type Map[K comparable, V any] interface {
	// Clear removes all key-value pairs in this map.
	Clear()

	// Clone returns a copy of this map.
	Clone() Map[K, V]

	// ContainsKey returns true if this map contains a key-value pair with the specified key.
	ContainsKey(k K) bool

	// Equals compares this map with the object pass from parameter.
	Equals(o any) bool

	// ForEach performs the given handler for each key-value pairs in the map until all pairs have
	// been processed or the handler returns an error.
	ForEach(handler func(k K, v V) error) error

	// Get returns the value which associated to the specified key.
	Get(k K) (V, bool)

	// GetDefault returns the value associated with the specified key, and returns the default value
	// if this map contains no pair with the key.
	GetDefault(k K, defaultVal V) V

	// IsEmpty returns true if this map is empty.
	IsEmpty() bool

	// Keys returns a slice that contains all the keys in this map.
	Keys() []K

	// Put associate the specified value with the specified key in this map.
	Put(k K, v V) V

	// Remove removes the key-value pair with the specified key.
	Remove(k K) V

	// Replace replaces the value for the specified key only if it is currently in this map.
	Replace(k K, v V) (V, bool)

	// Size returns the number of key-value pairs in this map.
	Size() int

	// Values returns a slice that contains all the values in this map.
	Values() []V
}

type Set[T comparable] interface {
	Collection[T]

	// Clone returns a copy of this set.
	Clone() Set[T]
}