c3

type Action func(item interface{})

type Aggregator func(item interface{}, aggregate interface{}) (aggregateResult interface{})

type Bag interface {
	Clearer
	ReadOnlyBag
	// Add adds an item to the container,
	// returns true if the container was modified,
	// false if it was not modified
	Add(item interface{}) bool
	// Delete removes an item from the container,
	// returns true if the container was modified,
	// false if it was not modified
	Delete(item interface{}) bool
}

type Clearer interface {
	// Clear removes all items from the container.
	Clear()
}

type Consumable interface {
	Consumer() Consumer
}

type Consume func() (interface{}, bool)

type Consumer interface {
	Iterator
}

type Generate func() (interface{}, bool)

type Generator func() Generate

type Indexable interface {
	// Returns the first item and true,
	// or nil and false if there is no first item
	First() (interface{}, bool)
	// Returns the item at the index and true,
	// or nil and false if the index is out of bounds
	Get(index int) (interface{}, bool)
	// Returns the last item and true,
	// or nil and false if there is no last item
	Last() (interface{}, bool)
	// Returns the first index of the item and true,
	// or -1 and false if there is no such item
	IndexOf(item interface{}) (int, bool)
	// Returns the index of the next item before the offset and true,
	// or -1 and false if there is no such item
	PrevIndexOf(offset int, item interface{}) (int, bool)
	// Returns the index of the next item after the offset and true,
	// or -1 and false if there is no such item
	NextIndexOf(offset int, item interface{}) (int, bool)
	// Returns the last index of the item and true,
	// or -1 and false if there is no such item
	LastIndexOf(item interface{}) (int, bool)
}

type Iterable interface {
	// returns a new Iterator positioned at the start of the container.
	Iterator() Iterator
}

type Iterator interface {
	// Move the iterator to the next item, returns true on succes
	// or false if the are no more item
	MoveNext() bool
	// returns the value at the current iterator position, or nil
	Value() interface{}
}

type Lesser func(a, b interface{}) bool

type List interface {
	Bag
	Indexable
	// Inserts the item at the given index,
	// returns true if the container was modified,
	// false if it was not modified.
	InsertAt(index int, item interface{}) bool
	// Swaps the 2 items at the given indexes
	Swap(i, j int)
	// Deletes the item at the given index,
	// returns true if the container was modified,
	// false if it was not modified.
	DeleteAt(index int) bool
}

type ManySelector func(interface{}) Iterable

type Peeker interface {
	// Peek returns the next item without removing it from the container.
	Peek() (interface{}, bool)
}

type Predicate func(item interface{}) bool

type Q struct {
	// contains filtered or unexported fields
}

type Queue interface {
	ReadOnlyBag
	Peeker
	Clearer
	Consumable
	// Appends an item at the tail of the queue,
	// returns true if the queue was modified,
	// false if it was not modified.
	Enqueue(item interface{}) bool
	// Removes an item from the head of the queue,
	// returns the item and true if the queue was modified,
	// or nil and false if it was not modified.
	Dequeue() (interface{}, bool)
}

type ReadOnlyBag interface {
	Iterable
	// Returns the item count
	Len() int
	// Returns true if the item is in the container, false otherwise.
	Contains(item interface{}) bool
}

type ReadOnlyList interface {
	ReadOnlyBag
	Indexable
}

type Selector func(item interface{}) interface{}

type Set interface {
	Bag
	// Union computes the union of the set.
	// i.e. all items in this set and the other set, without duplicates
	Union(other Set) Set
	// SymmetricDifference computes the symmetric difference of the sets.
	// i.e. all the items that are either in this set,
	// or in the other set, but not in both.
	SymmetricDifference(other Set) Set
	// Difference computes the items that are in this set but not in the other set.
	Difference(other Set) Set
	// Intersection computes the items that are present in both sets.
	Intersection(other Set) Set
}

type Sorter struct {
	List
	Lesser
}

type Stack interface {
	ReadOnlyBag
	Peeker
	Clearer
	Consumable
	// Adds an item at the top of the stack,
	// returns true if the stack was modified,
	// false if it was not modified.
	Push(item interface{}) bool
	// Removes an item from the top of the stack,
	// returns the item and true if the stack was modified,
	// nil and false if it was not modified.
	Pop() (interface{}, bool)
}