pipe

type Config struct {
	// Capacity is a value that sets the initial capacity of a Pipe.
	// Capacity must be a power of two and must not be negative.
	Capacity int

	// ExtendAfter is a value that sets the duration of time that a
	// Pipe will wait on a blocked call to Send before increasing its
	// capacity. A negative value will disable capacity extension.
	ExtendAfter time.Duration

	// MaxExtensions is a value that sets the maximum number of times
	// that a Pipe will dynamically increase its capacity. A zero
	// value will disable capacity extension. A negative value enables
	// unlimited extensions.
	MaxExtensions int
}

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

type Rx[T any] interface {
	// Recv is a function that provides a "pull" mechanism for reading
	// values from the Rx. Recv overwrites the value of t with the next
	// value read from the Rx and returns `true` only when a new value
	// has been written to t. The implementation of Rx must make it safe
	// to call Recv concurrently.
	//
	// After a call to Recv has returned `false`, all subsequent calls to
	// Recv must also return `false`. Additionally any iter.Seq returned
	// by a call to Seq must also terminate at this point.
	Recv(t *T) bool

	// Seq is a function that provides a way to iterate over values in
	// the Rx. Subsequent calls to Seq on the same Rx must provide a unique
	// iterator that contends for values from the Rx. This means that values
	// are not broadcast to each iter.Seq from the same Rx. No guarantees
	// are made about the order in which an iter.Seq will receive a value.
	//
	// The implementation of Rx must make it safe to call Seq concurrently.
	// Once iteration of any produced iter.Seq has stopped, all other iter.Seq
	// instances produced by the same Rx will terminate.
	Seq() iter.Seq[T]
}

type RxCloser[T any] interface {
	Rx[T]
	io.Closer
}

type Tx[T any] interface {
	// Send is a function that provides a way to send a value through the Tx.
	// When a value has been sent successfully, Send must return a `true` value.
	// When a value has not been sent, for any reason, Send must return a `false`
	// value. The implementation of Tx must make it safe to call Send concurrently.
	//
	// Once Send has returned a `false` value, all subsequent calls to
	// Send must also return a `false` value.
	Send(T) bool
}

type TxCloser[T any] interface {
	Tx[T]
	io.Closer
}