sync

type Appender[T any] interface {
	Append(value T)
}

type ChildExecutor interface {
	ChildExecutor() Executor
}

type Collection[T any] interface {
	Iterable[T]
	Appender[T]
	Remove(value T)
	Contains(value T) bool
	Len() int
}

type Executor interface {
	// Go adds a unit of work to be executed by the executor. Depending on the execution strategy this may be blocking
	// or may execute the function directly
	Go(func())

	// Wait blocks and waits for all the executing functions to be completed before returning, or the context is cancelled.
	// if more functions are added to be executed by this executor after the Wait call, these will also complete before Wait proceeds
	// If the context is canceled, any queued functions will not be executed
	Wait(context.Context)
}

type Iterable[T any] interface {
	// Seq provides an iter.Seq compatible iterator
	Seq(fn func(value T) bool)
}

type List[T comparable] struct {
	Locking
	// contains filtered or unexported fields
}

type Lockable interface {
	Lock() (unlock UnlockFunc)
	RLock() (unlock UnlockFunc)
}

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

type PanicError struct {
	Value any
	Stack string
}

type Provider[T any] interface {
	Get() T
}

type Queue[T any] interface {
	Enqueue(value T)
	Dequeue() (value T, ok bool)
}

type Stack[T any] interface {
	Push(value T)
	Pop() (value T, ok bool)
	Peek() (value T, ok bool)
}

type UnlockFunc func()