container

type Collector[S any, T any, R any] interface {
	Builder() S
	Append(builder S, element T)
	Finish(builder S) R
}

type Delete[K constraints.Key, V any] interface {
	Delete(key K) error
}

type Get[K constraints.Key, V any] interface {
	Get(key K) (V, error)
}

type KeyNode[K comparable, T any] struct {
	Next  *KeyNode[K, T]
	Key   K
	Value T
}

type LinkedKeyNode[K comparable, T any] struct {
	Prev, Next *LinkedKeyNode[K, T]
	Key        K
	Value      T
}

type LinkedNode[T any] struct {
	Prev, Next *LinkedNode[T]
	Value      T
}

type LinkedOrderedKeyNode[K constraints.Ordered, T any] struct {
	Prev, Next *LinkedOrderedKeyNode[K, T]
	Key        K
	Value      T
}

type Node[T any] struct {
	Next  *Node[T]
	Value T
}

type OrderedKeyNode[K constraints.Ordered, T any] struct {
	Next  *OrderedKeyNode[K, T]
	Key   K
	Value T
}

type Remove[K constraints.Key, V any] interface {
	Remove(key K) bool
}

type Set[K constraints.Key, V any] interface {
	Set(key K, v V) error
}

type SetWithExpire[K constraints.Key, V any] interface {
	SetWithExpire(key K, v V, expire time.Duration) error
}

type Store[K constraints.Key, V any] interface {
	Set[K, V]
	Get[K, V]
	Delete[K, V]
}

type StoreWithExpire[K constraints.Key, V any] interface {
	SetWithExpire[K, V]
	Get[K, V]
	Delete[K, V]
}