generic

type Cloner[T any] interface {
	Clone() T
}

type Collection1[T any] interface {
	// Size returns the number of items in the collection.
	Size() int

	// IsEmpty returns true if the collection contains no items.
	IsEmpty() bool

	// Add adds the specified items to the collection.
	// The behavior when adding an existing item depends on the implementation.
	Add(...T)

	// Remove removes the specified items from the collection.
	// If an item does not exist, it is ignored.
	Remove(...T)

	// RemoveAll removes all items from the collection, leaving it empty.
	RemoveAll()

	// Contains returns true if the collection includes all the specified items.
	Contains(...T) bool

	// All returns an iterator sequence containing all the items in the collection.
	// This allows for iterating over the entire collection using the range keyword.
	All() iter.Seq[T]

	// AnyMatch returns true if at least one item in the collection satisfies the provided predicate function.
	// If no items satisfy the predicate or the collection is empty, it returns false.
	AnyMatch(Predicate1[T]) bool

	// AllMatch returns true if all items in the collection satisfy the provided predicate function.
	// If the collection is empty, it returns true.
	AllMatch(Predicate1[T]) bool

	// FirstMatch returns the first item in the collection that satisfies the given predicate.
	// If no match is found, it returns the zero value of T and false.
	FirstMatch(Predicate1[T]) (T, bool)

	// SelectMatch selects a subset of items from the collection that satisfy the given predicate.
	// It returns a new collection containing the matching items, of the same type as the original collection.
	SelectMatch(Predicate1[T]) Collection1[T]

	// PartitionMatch partitions the items in the collection
	// into two separate collections based on the provided predicate.
	// The first collection contains the items that satisfy the predicate (matched items),
	// while the second collection contains those that do not satisfy the predicate (unmatched items).
	// Both collections are of the same type as the original collection.
	PartitionMatch(Predicate1[T]) (Collection1[T], Collection1[T])
}

type Collection2[K, V any] interface {
	// Size returns the number of key-values in the collection.
	Size() int

	// IsEmpty returns true if the collection contains no key-values.
	IsEmpty() bool

	// Put adds a new key-value to the collection.
	// If the key already exists, its value is updated.
	Put(K, V)

	// Get returns the value associated with the given key in the collection.
	// If the key does not exist, the second return value will be false.
	Get(K) (V, bool)

	// Delete deletes the key-value specified by the given key from the collection.
	// If the key does not exist, the second return value will be false.
	Delete(K) (V, bool)

	// DeleteAll deletes all key-values from the collection, leaving it empty.
	DeleteAll()

	// All returns an iterator sequence containing all the key-values in the collection.
	// This allows for iterating over the entire collection using the range keyword.
	All() iter.Seq2[K, V]

	// AnyMatch returns true if at least one key-value in the collection satisfies the provided predicate function.
	// If no key-values satisfy the predicate or the collection is empty, it returns false.
	AnyMatch(Predicate2[K, V]) bool

	// AllMatch returns true if all key-values in the collection satisfy the provided predicate function.
	// If the collection is empty, it returns true.
	AllMatch(Predicate2[K, V]) bool

	// FirstMatch returns the first key-value in the collection that satisfies the given predicate.
	// If no match is found, it returns the zero values of K and V, along with false.
	FirstMatch(Predicate2[K, V]) (K, V, bool)

	// SelectMatch selects a subset of key-values from the collection that satisfy the given predicate.
	// It returns a new collection containing the matching key-values, of the same type as the original collection.
	SelectMatch(Predicate2[K, V]) Collection2[K, V]

	// PartitionMatch partitions the key-values in the collection
	// into two separate collections based on the provided predicate.
	// The first collection contains the key-values that satisfy the predicate (matched key-values),
	// while the second collection contains those that do not satisfy the predicate (unmatched key-values).
	// Both collections are of the same type as the original collection.
	PartitionMatch(Predicate2[K, V]) (Collection2[K, V], Collection2[K, V])
}

type CompareFunc[T any] func(T, T) int

type Comparer[T any] interface {
	Compare(T) int
}

type EqualFunc[T any] func(T, T) bool

type Equaler[T any] interface {
	Equal(T) bool
}

type KeyValue[K, V any] struct {
	Key K
	Val V
}

type Predicate1[T any] func(T) bool

type Predicate2[K, V any] func(K, V) bool

type TraverseOrder int

type Tree1[T any] interface {
	// Traverse performs a traversal of the tree using the specified traversal order
	//   and yields the value of each node to the provided VisitFunc1 function.
	// If the function returns false, the traversal is halted.
	Traverse(TraverseOrder, VisitFunc1[T])

	// DOT generates and returns a representation of the tree in DOT format.
	// This format is commonly used for visualizing graphs with Graphviz tools.
	DOT() string
}

type Tree2[K, V any] interface {
	// Traverse performs a traversal of the tree using the specified traversal order
	//   and yields the key-value pair of each node to the provided VisitFunc2 function.
	// If the function returns false, the traversal is halted.
	Traverse(TraverseOrder, VisitFunc2[K, V])

	// DOT generates and returns a representation of the tree in DOT format.
	// This format is commonly used for visualizing graphs with Graphviz tools.
	DOT() string
}

type VisitFunc1[T any] func(T) bool

type VisitFunc2[K, V any] func(K, V) bool