list

type BasicLinkedList[T comparable] interface {
	Len() int64
	// Append appends the elements to the list l and returns the new elements.
	Append(elements ...*NodeElement[T]) []*NodeElement[T]
	// AppendValue appends the values to the list l and returns the new elements.
	AppendValue(values ...T) []*NodeElement[T]
	// InsertAfter inserts a value v as a new element immediately after element dstE and returns new element.
	// If e is nil, the value v will not be inserted.
	InsertAfter(v T, dstE *NodeElement[T]) *NodeElement[T]
	// InsertBefore inserts a value v as a new element immediately before element dstE and returns new element.
	// If e is nil, the value v will not be inserted.
	InsertBefore(v T, dstE *NodeElement[T]) *NodeElement[T]
	// Remove removes targetE from l if targetE is an element of list l and returns targetE or nil if the list is empty.
	Remove(targetE *NodeElement[T]) *NodeElement[T]
	// Foreach traverses the list l and executes function fn for each element.
	// If fn returns an error, the traversal stops and returns the error.
	Foreach(fn func(idx int64, e *NodeElement[T]) error) error
	// FindFirst finds the first element that satisfies the compareFn and returns the element and true if found.
	// If compareFn is not provided, it will use the default compare function that compares the value of element.
	FindFirst(v T, compareFn ...func(e *NodeElement[T]) bool) (*NodeElement[T], bool)
}

type LinkedList[T comparable] interface {
	BasicLinkedList[T]
	// ReverseForeach iterates the list in reverse order, calling fn for each element,
	// until either all elements have been visited.
	ReverseForeach(fn func(idx int64, e *NodeElement[T]))
	// Front returns the first element of doubly linked list l or nil if the list is empty.
	Front() *NodeElement[T]
	// Back returns the last element of doubly linked list l or nil if the list is empty.
	Back() *NodeElement[T]
	// PushFront inserts a new element e with value v at the front of list l and returns e.
	PushFront(v T) *NodeElement[T]
	// PushBack inserts a new element e with value v at the back of list l and returns e.
	PushBack(v T) *NodeElement[T]
	// MoveToFront moves an element e to the front of list l.
	MoveToFront(targetE *NodeElement[T]) bool
	// MoveToBack moves an element e to the back of list l.
	MoveToBack(targetE *NodeElement[T]) bool
	// MoveBefore moves an element srcE in front of element dstE.
	MoveBefore(srcE, dstE *NodeElement[T]) bool
	// MoveAfter moves an element srcE next to element dstE.
	MoveAfter(srcE, dstE *NodeElement[T]) bool
	// PushFrontList inserts a copy of another linked list at the front of list l.
	PushFrontList(srcList LinkedList[T])
	// PushBackList inserts a copy of another linked list at the back of list l.
	PushBackList(srcList LinkedList[T])
}

type NodeElement[T comparable] struct {
	Value T // The type of value may be a small size type.
	// contains filtered or unexported fields
}

type SkipList[K infra.OrderedKey, V any] interface {
	Levels() int32
	Len() int64
	IndexCount() uint64
	Insert(key K, val V, ifNotPresent ...bool) error
	LoadFirst(key K) (SklElement[K, V], error)
	RemoveFirst(key K) (SklElement[K, V], error)
	Foreach(action func(i int64, item SklIterationItem[K, V]) bool)
	PopHead() (SklElement[K, V], error)
	PeekHead() SklElement[K, V]
}

type SklElement[K infra.OrderedKey, V any] interface {
	Key() K
	Val() V
}

type SklIterationItem[K infra.OrderedKey, V any] interface {
	SklElement[K, V]
	NodeLevel() uint32
	NodeItemCount() int64
}

type SklOption[K infra.OrderedKey, V any] func(*sklOptions[K, V]) error

type SklRand func(maxLevel int, currentElements int64) int32

type SklType uint8

type SklValComparator[V any] func(i, j V) int64

type XSkipList[K infra.OrderedKey, V any] interface {
	SkipList[K, V]
	LoadIfMatch(key K, matcher func(that V) bool) ([]SklElement[K, V], error)
	LoadAll(key K) ([]SklElement[K, V], error)
	RemoveIfMatch(key K, matcher func(that V) bool) ([]SklElement[K, V], error)
	RemoveAll(key K) ([]SklElement[K, V], error)
}