types

type AggregationWithCache ¶

type AggregationWithCache[T comparable] struct {
	Aggregation []T
	Cache       map[T]bool
}

type AggregationWithCacheAndCounter ¶

type AggregationWithCacheAndCounter[T comparable] struct {
	Aggregation []T
	Cache       map[T]bool
	Counter     int64
}

type AggregationWithCounter ¶

type AggregationWithCounter[T any] struct {
	Aggregation T
	Counter     int64
}

type ComplexNumber ¶

type ComplexNumber interface {
	constraints.Complex
}

type Future ¶

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

Future is a type that represents a value that will be available in the future. It is heavily inspired by Java's Future interface. It is used to represent the result of an asynchronous operation and a way to early return from a function.

The creation and completion of the future is done internally, so the user is not expected to create it manually. The user is responsible for obtaining the value from the future. There are two ways to do that: 1. By calling Get() method. This method will block until the value is available. It returns either the pointer to the value or an error. In pippin the error means that the pipeline was interrupted before it could complete that's why the value is not available. 2. By calling GetWithTimeout(timeout time.Duration) method. This method will block until the value is available or the timeout is reached.

The recommended way to obtain the value is by calling GetWithTimeout() method, as otherwise the execution might be blocked forever.

It is possible to manually check whether the future is done or not by calling IsDone() method. This method return a boolean value indicating whether the future is done or not. It is not blocking.

Please, note that since it's the async operation, the value might not be available immediately.

func NewFuture[T any]() Future[T]

func (f *Future[T]) Complete(value T)

func (f *Future[T]) Fail(err error)

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

func (f *Future[T]) GetWithTimeout(timeout time.Duration) (*T, error)

func (f *Future[T]) IsDone() bool

type Number ¶

type Number interface {
	constraints.Integer | constraints.Float
}

type Tuple ¶

type Tuple[A, B any] struct {
	First  A
	Second B
}

type Void ¶

type Void struct{}