kv

type Deleter[K any] interface {
	// Delete removes the data at k
	Delete(ctx context.Context, k K) error
}

type Entry[K, V any] struct {
	Key   K
	Value V
}

type Exister[K any] interface {
	// Exists returns true if the store contains an entry for k and false otherwise.
	Exists(ctx context.Context, k K) (bool, error)
}

type Getter[K, V any] interface {
	Get(ctx context.Context, k K, dst *V) error
}

type Lister[K any] interface {
	// List copies keys from the store into the slice entries
	// and returns the number copied.
	// List signals the end of the list by returning (0, nil)
	// List may fill ks with fewer than len(ks), but will always return > 0, unless it is the end.
	// List will only return keys which are contained by in the span.
	List(ctx context.Context, span state.Span[K], ks []K) (int, error)
}

type MemStore[K, V any] struct {
	// contains filtered or unexported fields
}

type Poster[K, V any] interface {
	// Post creates an entry holding v and returns a key for it.
	Post(ctx context.Context, v V) (K, error)
}

type Putter[K, V any] interface {
	// Put replaces data at key with value, or creates a mapping from k -> v
	// if it does not exist.
	Put(ctx context.Context, k K, v V) error
}

type ReadOnlyStore[K, V any] interface {
	Getter[K, V]
	Lister[K]
}

type Store[K, V any] interface {
	Getter[K, V]
	Putter[K, V]
	Deleter[K]
	Lister[K]
	Exister[K]
}

type StoreTx[K, V any] interface {
	// View calls fn with a ReadOnly view of the store
	View(ctx context.Context, fn func(tx ReadOnlyStore[K, V]) error) error
	// Modify calls fn with a mutable view of the store.
	// Any operations on the store are either all applied if fn and Modify both return nil,
	// or all reverted if either fn or View returns a non-nil error.
	Modify(ctx context.Context, fn func(tx Store[K, V]) error) error
}

type Updater[K, V any] interface {
	// Update applies an update to a key serially with other calls to update
	Update(ctx context.Context, k K, fn func(v *V) (*V, error)) error
}