xsync

type Future ¶

type Future[T any] struct {
	// contains filtered or unexported fields
}

A Future holds a value that might not be available yet.

func NewFuture[T any]() (f *Future[T], complete func(T))

func (f *Future[T]) Done() <-chan struct{}

func (f *Future[T]) Get() T

type Queue ¶

type Queue[T any] struct {
	// contains filtered or unexported fields
}

A Queue concurrently collects values and returns them in FIFO order. A zero value Queue is ready to use.

A Queue is stopped when it is garbage collected. Therefore, a reference to the Queue must be kept alive during its use or its behavior will become undefined. Because of that, it is recommended to access the Queue's channels via the methods every time instead of storing a copy somewhere.

A Queue is initialized by calling any of its methods, so a copy of a Queue made before those methods are called is a completely independent Queue, while a copy made afterwards is the same Queue.

If a Queue's contents contain any references to the Queue itself, it can cause garbage collection to fail. For example, given a Queue[func()], if the Queue contains any closures which reference the actual instance of the Queue, the Queue's finalizer will not run until those elements have been removed from the Queue. Because of this, such a Queue will need to be manually stopped with a call to Queue.Stop.

func (q *Queue[T]) Pop() <-chan T

func (q *Queue[T]) Push() chan<- T

func (q *Queue[T]) Stop()

type SelectCase ¶

type SelectCase interface {
	Dir() reflect.SelectDir
	// contains filtered or unexported methods
}

SelectCase represents either a send or receive on a channel, or a default case with no channel associated.

func Default(f func()) SelectCase

func Recv[T any](c <-chan T, f func(T)) SelectCase

func RecvOK[T any](c <-chan T, f func(T, bool)) SelectCase

func Send[T any](c chan<- T, v T, f func()) SelectCase

type Stopper ¶

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

A Stopper provides a simple way to handle a done channel for internal coordination. For coordination across API boundaries, it is generally better to use context.Context.

The zero value of a Stopper is ready to use.

func (s *Stopper) Done() <-chan struct{}

func (s *Stopper) Stop()