collections

type Collection[T any] interface {
	iterators.Iterable[T]

	// Add ensures that this collection contains the specified elements.
	// Returns true if the collection changed as a result of the operation.
	// (returns false if the collection does not support duplicates and already contained all given elements).
	Add(elements ...T) bool

	// AddAll adds all elements from the given collection to this one.
	// Returns true if the collection changed as a result of the operation.
	AddAll(c Collection[T]) bool

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

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

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

	// Compares the specified object with this collection for equality.
	Equals(c Collection[T]) bool

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

	// Removes all given elements from the collection, if they are present.
	// Each specified element is removed only once, even if it is contained multiple times in the collection.
	// Returns true if the collection changed as a result of the operation.
	Remove(elements ...T) bool

	// RemoveAllOf removes all instances of the given elements from the collection.
	// Returns true if the collection changed as a result of the operation.
	RemoveAllOf(elements ...T) bool

	// Removes all of this collection's elements that are also contained in the specified collection.
	// Returns true if the collection changed as a result of the operation.
	RemoveAll(c Collection[T]) bool

	// RetainAll removes all elements from the collection that are not contained in the specified collection.
	// Returns true if the collection changed as a result of the operation.
	RetainAll(c Collection[T]) bool

	// RemoveIf removes all elements from the collection that satisfy the given predicate.
	// Returns true if the collection changed as a result of the operation.
	RemoveIf(filter Predicate[T]) bool

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

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

	// New returns a new Collection of the same type.
	New() Collection[T]
}

type Comparable[T any] interface {
	// Equals returns true if the receiver and the argument are equal.
	Equals(T) bool
}

type LinkedList[T any] struct {
	// contains filtered or unexported fields
}

type List[T any] interface {
	Collection[T]
	json.Marshaler
	json.Unmarshaler

	// AddIndex adds the given element at the specified index.
	// Returns an IndexOutOfBoundsError if the index is not within the list's size or equal to l.Size().
	AddIndex(element T, idx int) error

	// RemoveIndex removes the element at the specified index.
	// Returns an IndexOutOfBoundsError if the index is not within the list's size.
	RemoveIndex(idx int) error

	// Get returns the element at the specified index.
	// Returns an IndexOutOfBoundsError if the index is not within the list's size.
	Get(idx int) (T, error)
}

type Predicate[T any] func(T) bool

type Queue[T any] interface {
	Collection[T]

	// Push adds the given elements to the queue.
	// Returns an error, if the queue's size restriction prevents the elements from being added.
	Push(elements ...T) error
	// Peek returns the first element without removing it.
	// Returns T's zero value, if the queue is empty.
	Peek() T
	// Element returns the first element without removing it.
	// Returns an error, if the queue is empty.
	Element() (T, error)
	// Poll returns the first element and removes it from the queue.
	// Returns T's zero value, if the queue is empty.
	Poll() T
	// Fetch returns the first element and removes it from the queue.
	// Returns an error, if the queue is empty.
	Fetch() (T, error)
}