fn

package module
v1.2.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 6, 2024 License: MIT Imports: 12 Imported by: 23

Documentation

Overview

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Index

Constants

View Source 
const (
	// DefaultQueueSize is the default size to use for concurrent queues.
	DefaultQueueSize = 10
)

Variables

View Source 
var (
	// DefaultTimeout is the default timeout used for context operations.
	DefaultTimeout = 30 * time.Second
)
View Source 
var ErrStopping = errors.New("can not add goroutine, stopping")

ErrStopping is returned when trying to add a new goroutine while stopping.

Functions

func All added in v1.0.5 

func All[A any](pred func(A) bool, s []A) bool

All returns true when the supplied predicate evaluates to true for all of the values in the slice.

func Any added in v1.0.5 

func Any[A any](pred func(A) bool, s []A) bool

Any returns true when the supplied predicate evaluates to true for any of the values in the slice.

func ChainOption 

func ChainOption[A, B any](f func(A) Option[B]) func(Option[A]) Option[B]

ChainOption transforms a function A -> Option[B] into one that accepts an Option[A] as an argument.

ChainOption : (A -> Option[B]) -> Option[A] -> Option[B].

func Comp added in v1.2.0 

func Comp[A, B, C any](f func(A) B, g func(B) C) func(A) C

Comp is left to right function composition. Comp(f, g)(x) == g(f(x)). This can make it easier to create on the fly closures that we may use as arguments to other functions defined in this package (or otherwise).

func Const added in v1.2.0 

func Const[A, B any](a A) func(B) A

Const is a function that accepts an argument and returns a function that always returns that value irrespective of the returned function's argument. This is also quite useful in conjunction with higher order functions.

func Elem added in v1.2.0 

func Elem[A comparable](a A, s []A) bool

Elem returns true if the element in the argument is found in the slice

func ElimEither added in v1.2.0 

func ElimEither[L, R, O any](f func(L) O, g func(R) O, e Either[L, R]) O

ElimEither is the universal Either eliminator. It can be used to safely handle all possible values inside the Either by supplying two continuations, one for each side of the Either.

func ElimOption 

func ElimOption[A, B any](o Option[A], b func() B, f func(A) B) B

ElimOption is the universal Option eliminator. It can be used to safely handle all possible values inside the Option by supplying two continuations.

ElimOption : (Option[A], () -> B, A -> B) -> B.

func Eq added in v1.2.0 

func Eq[A comparable](x A) func(A) bool

Eq is a curried function that returns true if its eventual two arguments are equal.

func Filter added in v1.0.5 

func Filter[A any](pred Pred[A], s []A) []A

Filter creates a new slice of values where all the members of the returned slice pass the predicate that is supplied in the argument.

func FilterMap added in v1.2.5 

func FilterMap[A, B any](as []A, f func(A) Option[B]) []B

FilterMap takes a function argument that optionally produces a value and returns a slice of the 'Some' return values.

func Flatten added in v1.0.5 

func Flatten[A any](s [][]A) []A

Flatten takes a slice of slices and returns a concatenation of those slices.

func Foldl added in v1.0.5 

func Foldl[A, B any](f func(B, A) B, seed B, s []A) B

Foldl iterates through all members of the slice left to right and reduces them pairwise with an accumulator value that is seeded with the seed value in the argument.

func Foldr added in v1.0.5 

func Foldr[A, B any](f func(A, B) B, seed B, s []A) B

Foldr, is exactly like Foldl except that it iterates over the slice from right to left.

func ForEachConc added in v1.2.0 

func ForEachConc[A, B any](f func(A) B,
	as []A) []B

ForEachConc maps the argument function over the slice, spawning a new goroutine for each element in the slice and then awaits all results before returning them.

func HasDuplicates added in v1.0.7 

func HasDuplicates[A comparable](items []A) bool

HasDuplicates checks if the given slice contains any duplicate elements. It returns false if there are no duplicates in the slice (i.e., all elements are unique), otherwise returns false.

func Iden added in v1.2.0 

func Iden[A any](a A) A

Iden is the left and right identity of Comp. It is a function that simply returns its argument. The utility of this function is only apparent in conjunction with other functions in this package.

func Len added in v1.2.2 

func Len[A any](items []A) uint

Len is the len function that is defined in a way that makes it usable in higher-order contexts.

func LiftA2Option 

func LiftA2Option[A, B, C any](
	f func(A, B) C,
) func(Option[A], Option[B]) Option[C]

LiftA2Option transforms a pure function (A, B) -> C into one that will operate in an Option context. For the returned function, if either of its arguments are None, then the result will be None.

LiftA2Option : ((A, B) -> C) -> (Option[A], Option[B]) -> Option[C].

func Map added in v1.0.5 

func Map[A, B any](f func(A) B, s []A) []B

Map applies the function argument to all members of the slice and returns a slice of those return values.

func MapFirst added in v1.2.0 

func MapFirst[A, B, C any](f func(A) B) func(T2[A, C]) T2[B, C]

MapFirst lifts the argument function into one that applies to the first element of a 2-tuple.

func MapLeft added in v1.0.2 

func MapLeft[L, R, O any](f func(L) O) func(Either[L, R]) Either[O, R]

MapLeft maps the left value of the Either to a new value.

func MapOk added in v1.2.5 

func MapOk[A, B any](f func(A) B) func(Result[A]) Result[B]

MapOk applies a non-endomorphic function to the success value if it exists and returns a Result of the new type.

func MapOption 

func MapOption[A, B any](f func(A) B) func(Option[A]) Option[B]

MapOption transforms a pure function A -> B into one that will operate inside the Option context.

MapOption : (A -> B) -> Option[A] -> Option[B].

func MapOptionZ added in v1.0.2 

func MapOptionZ[A, B any](o Option[A], f func(A) B) B

MapOptionZ transforms a pure function A -> B into one that will operate inside the Option context. Unlike MapOption, this function will return the default/zero argument of the return type if the Option is empty.

func MapRight added in v1.2.0 

func MapRight[L, R, O any](f func(R) O) func(Either[L, R]) Either[L, O]

MapRight maps the right value of the Either to a new value.

func MapSecond added in v1.2.0 

func MapSecond[A, B, C any](f func(A) B) func(T2[C, A]) T2[C, B]

MapSecond lifts the argument function into one that applies to the second element of a 2-tuple.

func Neq added in v1.2.0 

func Neq[A comparable](x A) func(A) bool

Neq is a curried function that returns true if its eventual two arguments are not equal.

func NewSubMap added in v1.0.6 

func NewSubMap[K comparable, V any](m map[K]V, keys []K) (map[K]V, error)

NewSubMap creates a sub-map from a given map using specified keys. It errors if any of the keys is not found in the map.

func NewSubMapIntersect added in v1.0.6 

func NewSubMapIntersect[K comparable, V any](m map[K]V, keys []K) map[K]V

NewSubMapIntersect returns a sub-map of `m` containing only the keys found in both `m` and the `keys` slice.

func Pair added in v1.2.0 

func Pair[A, B, C any](f func(A) B, g func(A) C) func(A) T2[B, C]

Pair takes two functions that share the same argument type and runs them both and produces a 2-tuple of the results.

func RecvOrTimeout added in v1.0.2 

func RecvOrTimeout[T any](c <-chan T, timeout time.Duration) (T, error)

RecvOrTimeout attempts to recv over chan c, returning the value. If the timeout passes before the recv succeeds, an error is returned

func RecvResp added in v1.0.2 

func RecvResp[T any](r <-chan T, e <-chan error, q <-chan struct{}) (T, error)

RecvResp takes three channels: a response channel, an error channel and a quit channel. If either of these channels are sent on, then the function will exit with that response. This can be used to wait for a response, error, or a quit signal.

func Replicate added in v1.0.5 

func Replicate[A any](n uint, val A) []A

Replicate generates a slice of values initialized by the prototype value.

func SendOrQuit added in v1.0.2 

func SendOrQuit[T any, Q any](c chan<- T, msg T, quit chan Q) bool

SendOrQuit attempts to and a message through channel c. If this succeeds, then bool is returned. Otherwise if a quit signal is received first, then false is returned.

func SetDiff added in v1.0.2 

func SetDiff[T comparable](a, b []T) []T

SetDiff returns all the items that are in the first set but not in the second.

func SliceToMap added in v1.0.6 

func SliceToMap[A any, K comparable, V any](s []A, keyFunc func(A) K,
	valueFunc func(A) V) map[K]V

SliceToMap converts a slice to a map using the provided key and value functions.

func Span added in v1.0.5 

func Span[A any](pred func(A) bool, s []A) ([]A, []A)

Span, applied to a predicate and a slice, returns two slices where the first element is the longest prefix (possibly empty) of slice elements that satisfy the predicate and second element is the remainder of the slice.

func SplitAt added in v1.0.5 

func SplitAt[A any](n uint, s []A) ([]A, []A)

SplitAt(n, s) returns a tuple where first element is s prefix of length n and second element is the remainder of the list.

func Sum added in v1.0.6 

func Sum[B Number](items []B) B

Sum calculates the sum of a slice of numbers, `items`.

func TrimNones added in v1.2.5 

func TrimNones[A any](as []Option[A]) []A

TrimNones takes a slice of Option values and returns a slice of the Some values in it.

func ZipWith added in v1.0.5 

func ZipWith[A, B, C any](f func(A, B) C, a []A, b []B) []C

ZipWith combines slice elements with the same index using the function argument, returning a slice of the results.

Types

type ConcurrentQueue added in v1.0.2 

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

ConcurrentQueue is a typed concurrent-safe FIFO queue with unbounded capacity. Clients interact with the queue by pushing items into the in channel and popping items from the out channel. There is a goroutine that manages moving items from the in channel to the out channel in the correct order that must be started by calling Start().

func NewConcurrentQueue added in v1.0.2 

func NewConcurrentQueue[T any](bufferSize int) *ConcurrentQueue[T]

NewConcurrentQueue constructs a ConcurrentQueue. The bufferSize parameter is the capacity of the output channel. When the size of the queue is below this threshold, pushes do not incur the overhead of the less efficient overflow structure.

func (*ConcurrentQueue[T]) ChanIn added in v1.0.2 

func (cq *ConcurrentQueue[T]) ChanIn() chan<- T

ChanIn returns a channel that can be used to push new items into the queue.

func (*ConcurrentQueue[T]) ChanOut added in v1.0.2 

func (cq *ConcurrentQueue[T]) ChanOut() <-chan T

ChanOut returns a channel that can be used to pop items from the queue.

func (*ConcurrentQueue[T]) Start added in v1.0.2 

func (cq *ConcurrentQueue[T]) Start()

Start begins a goroutine that manages moving items from the in channel to the out channel. The queue tries to move items directly to the out channel minimize overhead, but if the out channel is full it pushes items to an overflow queue. This must be called before using the queue.

func (*ConcurrentQueue[T]) Stop added in v1.0.2 

func (cq *ConcurrentQueue[T]) Stop()

Stop ends the goroutine that moves items from the in channel to the out channel. This does not clear the queue state, so the queue can be restarted without dropping items.

type ContextGuard added in v1.2.3 

type ContextGuard struct {
	DefaultTimeout time.Duration
	Wg             sync.WaitGroup
	Quit           chan struct{}
}

ContextGuard is an embeddable struct that provides a wait group and main quit channel that can be used to create guarded contexts.

func NewContextGuard added in v1.2.3 

func NewContextGuard() *ContextGuard

func (*ContextGuard) CtxBlocking added in v1.2.3 

func (g *ContextGuard) CtxBlocking() (context.Context, func())

CtxBlocking is used to create a cancellable context that will NOT be cancelled if the main quit signal is triggered, to block shutdown of important tasks. The context will be cancelled if the timeout is reached.

func (*ContextGuard) CtxBlockingCustomTimeout added in v1.2.3 

func (g *ContextGuard) CtxBlockingCustomTimeout(
	timeout time.Duration) (context.Context, func())

CtxBlockingCustomTimeout is used to create a cancellable context with a custom timeout that will NOT be cancelled if the main quit signal is triggered, to block shutdown of important tasks. The context will be cancelled if the timeout is reached.

func (*ContextGuard) WithCtxQuit added in v1.2.3 

func (g *ContextGuard) WithCtxQuit() (context.Context, func())

WithCtxQuit is used to create a cancellable context that will be cancelled if the main quit signal is triggered or after the default timeout occurred.

func (*ContextGuard) WithCtxQuitCustomTimeout added in v1.2.3 

func (g *ContextGuard) WithCtxQuitCustomTimeout(
	timeout time.Duration) (context.Context, func())

WithCtxQuitCustomTimeout is used to create a cancellable context that will be cancelled if the main quit signal is triggered or after the given timeout occurred.

func (*ContextGuard) WithCtxQuitNoTimeout added in v1.2.3 

func (g *ContextGuard) WithCtxQuitNoTimeout() (context.Context, func())

WithCtxQuitNoTimeout is used to create a cancellable context that will be cancelled if the main quit signal is triggered.

type Either added in v1.0.2 

type Either[L any, R any] struct {
	// contains filtered or unexported fields
}

Either is a type that can be either left or right.

func NewLeft added in v1.0.2 

func NewLeft[L any, R any](l L) Either[L, R]

NewLeft returns an Either with a left value.

func NewRight added in v1.0.2 

func NewRight[L any, R any](r R) Either[L, R]

NewRight returns an Either with a right value.

func OptionToLeft added in v1.2.0 

func OptionToLeft[O, L, R any](o Option[O], r R) Either[O, R]

OptionToLeft can be used to convert an Option value into an Either, by providing the Right value that should be used if the Option value is None.

func OptionToRight added in v1.2.0 

func OptionToRight[O, L, R any](o Option[O], l L) Either[L, O]

OptionToRight can be used to convert an Option value into an Either, by providing the Left value that should be used if the Option value is None.

func (Either[L, R]) IsLeft added in v1.0.2 

func (e Either[L, R]) IsLeft() bool

IsLeft returns true if the Either is left.

func (Either[L, R]) IsRight added in v1.0.2 

func (e Either[L, R]) IsRight() bool

IsRight returns true if the Either is right.

func (Either[L, R]) LeftToOption added in v1.2.0 

func (e Either[L, R]) LeftToOption() Option[L]

LeftToOption converts a Left value to an Option, returning None if the inner Either value is a Right value.

func (Either[L, R]) RightToOption added in v1.2.0 

func (e Either[L, R]) RightToOption() Option[R]

RightToOption converts a Right value to an Option, returning None if the inner Either value is a Left value.

func (Either[L, R]) Swap added in v1.2.0 

func (e Either[L, R]) Swap() Either[R, L]

Swap reverses the type argument order. This can be useful as an adapter between APIs.

func (Either[L, R]) UnwrapLeftOr added in v1.2.0 

func (e Either[L, R]) UnwrapLeftOr(l L) L

UnwrapLeftOr will extract the Left value from the Either if it is present returning the supplied default if it is not.

func (Either[L, R]) UnwrapRightOr added in v1.2.0 

func (e Either[L, R]) UnwrapRightOr(r R) R

UnwrapRightOr will extract the Right value from the Either if it is present returning the supplied default if it is not.

func (Either[L, R]) WhenLeft added in v1.0.2 

func (e Either[L, R]) WhenLeft(f func(L))

WhenLeft executes the given function if the Either is left.

func (Either[L, R]) WhenRight added in v1.0.2 

func (e Either[L, R]) WhenRight(f func(R))

WhenRight executes the given function if the Either is right.

type Event added in v1.0.2 

type Event interface {
	Timestamp() time.Time
}

Event is a generic event that can be sent to a subscriber.

type EventDistributor added in v1.0.2 

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

EventDistributor is a struct type that helps to distribute events to multiple subscribers.

func NewEventDistributor added in v1.0.2 

func NewEventDistributor[T any]() *EventDistributor[T]

NewEventDistributor creates a new event distributor of the declared type.

func (*EventDistributor[T]) NotifySubscribers added in v1.0.2 

func (d *EventDistributor[T]) NotifySubscribers(events ...T)

NotifySubscribers sends the given events to all subscribers.

func (*EventDistributor[T]) RegisterSubscriber added in v1.0.2 

func (d *EventDistributor[T]) RegisterSubscriber(subscriber *EventReceiver[T])

RegisterSubscriber adds a new subscriber for receiving events.

func (*EventDistributor[T]) RemoveSubscriber added in v1.0.2 

func (d *EventDistributor[T]) RemoveSubscriber(
	subscriber *EventReceiver[T]) error

RemoveSubscriber removes the given subscriber and also stops it from processing events.

type EventPublisher added in v1.0.2 

type EventPublisher[T any, Q any] interface {
	// RegisterSubscriber adds a new subscriber for receiving events. The
	// deliverExisting boolean indicates whether already existing items
	// should be sent to the NewItemCreated channel when the subscription is
	// started. An optional deliverFrom can be specified to indicate from
	// which timestamp/index/marker onward existing items should be
	// delivered on startup. If deliverFrom is nil/zero/empty then all
	// existing items will be delivered.
	RegisterSubscriber(receiver *EventReceiver[T], deliverExisting bool,
		deliverFrom Q) error

	// RemoveSubscriber removes the given subscriber and also stops it from
	// processing events.
	RemoveSubscriber(subscriber *EventReceiver[T]) error
}

EventPublisher is an interface type for a component that offers event based subscriptions for publishing events.

type EventReceiver added in v1.0.2 

type EventReceiver[T any] struct {

	// NewItemCreated is sent to when a new item was created successfully.
	NewItemCreated *ConcurrentQueue[T]

	// ItemRemoved is sent to when an existing item was removed.
	ItemRemoved *ConcurrentQueue[T]
	// contains filtered or unexported fields
}

EventReceiver is a struct type that holds two queues for new and removed items respectively.

func NewEventReceiver added in v1.0.2 

func NewEventReceiver[T any](queueSize int) *EventReceiver[T]

NewEventReceiver creates a new event receiver with concurrent queues of the given size.

func (*EventReceiver[T]) ID added in v1.0.2 

func (e *EventReceiver[T]) ID() uint64

ID returns the internal process-unique ID of the subscription.

func (*EventReceiver[T]) Stop added in v1.0.2 

func (e *EventReceiver[T]) Stop()

Stop stops the receiver from processing events.

type GoroutineManager added in v1.2.2 

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

GoroutineManager is used to launch goroutines until context expires or the manager is stopped. The Stop method blocks until all started goroutines stop.

func NewGoroutineManager added in v1.2.2 

func NewGoroutineManager(ctx context.Context) *GoroutineManager

NewGoroutineManager constructs and returns a new instance of GoroutineManager.

func (*GoroutineManager) Done added in v1.2.2 

func (g *GoroutineManager) Done() <-chan struct{}

Done returns a channel which is closed when either the context passed to NewGoroutineManager expires or when Stop is called.

func (*GoroutineManager) Go added in v1.2.2 

func (g *GoroutineManager) Go(f func(ctx context.Context)) error

Go starts a new goroutine if the manager is not stopping.

func (*GoroutineManager) Stop added in v1.2.2 

func (g *GoroutineManager) Stop()

Stop prevents new goroutines from being added and waits for all running goroutines to finish.

type List added in v1.2.0 

type List[A any] struct {
	// contains filtered or unexported fields
}

List represents a doubly linked list. The zero value for List is an empty list ready to use.

func NewList added in v1.2.0 

func NewList[A any]() *List[A]

New returns an initialized List.

func (*List[A]) Back added in v1.2.0 

func (l *List[A]) Back() *Node[A]

Back returns the last Node of List l or nil if the list is empty.

func (*List[A]) Filter added in v1.2.2 

func (l *List[A]) Filter(f Pred[A]) []A

Filter gives a slice of all of the node values that satisfy the given predicate.

func (*List[A]) Front added in v1.2.0 

func (l *List[A]) Front() *Node[A]

Front returns the first Node of List l or nil if the list is empty.

func (*List[A]) Init added in v1.2.0 

func (l *List[A]) Init() *List[A]

Init intializes or clears the List l.

func (*List[A]) InsertAfter added in v1.2.0 

func (l *List[A]) InsertAfter(a A, predecessor *Node[A]) *Node[A]

InsertAfter inserts a new Node n with value a immediately after and returns e. If predecessor is not an element of l, the list is not modified. The predecessor must not be nil.

func (*List[A]) InsertBefore added in v1.2.0 

func (l *List[A]) InsertBefore(a A, successor *Node[A]) *Node[A]

InsertBefore inserts a new Node n with value a immediately before successor and returns n. If successor is not an element of l, the list is not modified. The successor must not be nil.

func (*List[A]) Len added in v1.2.0 

func (l *List[A]) Len() int

Len returns the number of elements of List l. The complexity is O(1).

func (*List[A]) MoveAfter added in v1.2.0 

func (l *List[A]) MoveAfter(n, predecessor *Node[A])

MoveAfter moves Node n to its new position after predecessor. If n or predecessor is not an element of l, or n == predecessor, the list is not modified. The Node and predecessor must not be nil.

func (*List[A]) MoveBefore added in v1.2.0 

func (l *List[A]) MoveBefore(n, successor *Node[A])

MoveBefore moves Node n to its new position before successor. If n or successor is not an element of l, or n == successor, the list is not modified. The Node and successor must not be nil.

func (*List[A]) MoveToBack added in v1.2.0 

func (l *List[A]) MoveToBack(n *Node[A])

MoveToBack moves Node n to the back of List l. If n is not an element of l, the list is not modified. The Node must not be nil.

func (*List[A]) MoveToFront added in v1.2.0 

func (l *List[A]) MoveToFront(n *Node[A])

MoveToFront moves Node n to the front of List l. If n is not an element of l, the list is not modified. The Node must not be nil.

func (*List[A]) PushBack added in v1.2.0 

func (l *List[A]) PushBack(a A) *Node[A]

PushBack inserts a new Node n with value a at the back of List l and returns n.

func (*List[A]) PushBackList added in v1.2.0 

func (l *List[A]) PushBackList(other *List[A])

PushBackList inserts a copy of List other at the back of List l. The Lists l and other may be the same. They must not be nil.

func (*List[A]) PushFront added in v1.2.0 

func (l *List[A]) PushFront(a A) *Node[A]

PushFront inserts a new Node n with value a at the front of List l and returns n.

func (*List[A]) PushFrontList added in v1.2.0 

func (l *List[A]) PushFrontList(other *List[A])

PushFrontList inserts a copy of List other at the front of List l. The Lists l and other may be the same. They must not be nil.

func (*List[A]) Remove added in v1.2.0 

func (l *List[A]) Remove(n *Node[A]) A

Remove removes Node n from List l if n is an element of List l. It returns the Node value e.Value. The Node must not be nil.

type Node added in v1.2.0 

type Node[A any] struct {

	// Value is the actual data contained within the Node.
	Value A
	// contains filtered or unexported fields
}

func (*Node[A]) Next added in v1.2.0 

func (e *Node[A]) Next() *Node[A]

Next returns the next list node or nil.

func (*Node[A]) Prev added in v1.2.0 

func (e *Node[A]) Prev() *Node[A]

Prev returns the previous list node or nil.

type Number added in v1.0.6 

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

Number is a type constraint for all numeric types in Go (integers, float and complex numbers)

type Option 

type Option[A any] struct {
	// contains filtered or unexported fields
}

Option[A] represents a value which may or may not be there. This is very often preferable to nil-able pointers.

func CollectOptions added in v1.2.5 

func CollectOptions[A any](options []Option[A]) Option[[]A]

CollectOptions collects a list of Options into a single Option of the list of Some values in it. If there are any Nones present it will return None.

func Find added in v1.0.5 

func Find[A any](pred Pred[A], s []A) Option[A]

Find returns the first value that passes the supplied predicate, or None if the value wasn't found.

func FindIdx added in v1.2.0 

func FindIdx[A any](pred Pred[A], s []A) Option[T2[int, A]]

FindIdx returns the first value that passes the supplied predicate along with its index in the slice. If no satisfactory value is found, None is returned.

func FlattenOption 

func FlattenOption[A any](oo Option[Option[A]]) Option[A]

FlattenOption joins multiple layers of Options together such that if any of the layers is None, then the joined value is None. Otherwise the innermost Some value is returned.

FlattenOption : Option[Option[A]] -> Option[A]. 

func Head[A any](items []A) Option[A]

Head returns the first element of the slice, assuming it is non-empty.

func Init added in v1.2.2 

func Init[A any](items []A) Option[[]A]

Init returns the slice without the last element, assuming the slice is not empty. Note this makes a copy of the slice.

func Last added in v1.2.2 

func Last[A any](items []A) Option[A]

Last returns the last element of the slice, assuming it is non-empty.

func None 

func None[A any]() Option[A]

None trivially constructs an empty option

None : Option[A].

func Some 

func Some[A any](a A) Option[A]

Some trivially injects a value into an optional context.

Some : A -> Option[A].

func Tail added in v1.2.2 

func Tail[A any](items []A) Option[[]A]

Tail returns the slice without the first element, assuming the slice is not empty. Note this makes a copy of the slice.

func TransposeResOpt added in v1.2.5 

func TransposeResOpt[A any](r Result[Option[A]]) Option[Result[A]]

TransposeResOpt transposes the Result[Option[A]] into a Option[Result[A]]. This has the effect of leaving an A value alone while inverting the Result and Option layers. If there is no internal A value, it will convert the non-success value to the proper one in the transposition.

func TraverseOption added in v1.2.5 

func TraverseOption[A, B any](as []A, f func(A) Option[B]) Option[[]B]

TraverseOption traverses a slice of A values, applying the provided function to each, collecting the results into an Option of a slice of B values. If any of the results are None, the entire result is None.

func Uncons added in v1.2.2 

func Uncons[A any](items []A) Option[T2[A, []A]]

Uncons splits a slice into a pair of its Head and Tail.

func Unsnoc added in v1.2.2 

func Unsnoc[A any](items []A) Option[T2[[]A, A]]

Unsnoc splits a slice into a pair of its Init and Last.

func (Option[A]) Alt 

func (o Option[A]) Alt(o2 Option[A]) Option[A]

Alt chooses the left Option if it is full, otherwise it chooses the right option. This can be useful in a long chain if you want to choose between many different ways of producing the needed value.

Alt : Option[A] -> Option[A] -> Option[A].

func (Option[A]) IsNone 

func (o Option[A]) IsNone() bool

IsNone returns true if the Option is empty

IsNone : Option[A] -> bool.

func (Option[A]) IsSome 

func (o Option[A]) IsSome() bool

IsSome returns true if the Option contains a value

IsSome : Option[A] -> bool.

func (Option[A]) SomeToOk added in v1.2.5 

func (o Option[A]) SomeToOk(err error) Result[A]

SomeToOk allows you to convert an Option value to a Result with your own error. If the Option contained a Some, then the supplied error is ignored and Some is converted to Ok.

func (Option[A]) SomeToOkf added in v1.2.5 

func (o Option[A]) SomeToOkf(errString string, args ...interface{}) Result[A]

SomeToOkf allows you to convert an Option value to a Result with your own error message. If the Option contains a Some, then the supplied message is ignored and Some is converted to Ok.

func (Option[A]) UnsafeFromSome added in v1.0.1 

func (o Option[A]) UnsafeFromSome() A

UnsafeFromSome can be used to extract the internal value. This will panic if the value is None() though.

func (Option[A]) UnwrapOr 

func (o Option[A]) UnwrapOr(a A) A

UnwrapOr is used to extract a value from an option, and we supply the default value in the case when the Option is empty.

UnwrapOr : (Option[A], A) -> A.

func (Option[A]) UnwrapOrErr added in v1.0.4 

func (o Option[A]) UnwrapOrErr(err error) (A, error)

UnwrapOrErr is used to extract a value from an option, if the option is empty, then the specified error is returned directly.

func (Option[A]) UnwrapOrFail added in v1.0.4 

func (o Option[A]) UnwrapOrFail(t *testing.T) A

UnwrapOrFail is used to extract a value from an option within a test context. If the option is None, then the test fails.

func (Option[A]) UnwrapOrFunc added in v1.0.2 

func (o Option[A]) UnwrapOrFunc(f func() A) A

UnwrapOrFunc is used to extract a value from an option, and we supply a thunk to be evaluated in the case when the Option is empty.

func (Option[A]) UnwrapOrFuncErr added in v1.0.2 

func (o Option[A]) UnwrapOrFuncErr(f func() (A, error)) (A, error)

UnwrapOrFuncErr is used to extract a value from an option, and we supply a thunk to be evaluated in the case when the Option is empty.

func (Option[A]) WhenSome 

func (o Option[A]) WhenSome(f func(A))

WhenSome is used to conditionally perform a side-effecting function that accepts a value of the type that parameterizes the option. If this function performs no side effects, WhenSome is useless.

WhenSome : (Option[A], A -> ()) -> ().

type Pred added in v1.0.9 

type Pred[A any] func(A) bool

Pred[A] is a type alias for a predicate operating over type A.

func PredAnd added in v1.0.9 

func PredAnd[A any](p0 Pred[A], p1 Pred[A]) Pred[A]

PredAnd is a lifted version of the && operation that operates over functions producing a boolean value from some type A.

func PredOr added in v1.0.9 

func PredOr[A any](p0 Pred[A], p1 Pred[A]) Pred[A]

PredOr is a lifted version of the || operation that operates over functions producing a boolean value from some type A.

type Queue added in v1.0.2 

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

Queue is a generic queue implementation.

func NewQueue added in v1.0.2 

func NewQueue[T any](startingItems ...T) Queue[T]

NewQueue creates a new Queue.

func (*Queue[T]) Dequeue added in v1.0.2 

func (q *Queue[T]) Dequeue() Option[T]

Dequeue removes an element from the front of the Queue. If there're no items in the queue, then None is returned.

func (*Queue[T]) Enqueue added in v1.0.2 

func (q *Queue[T]) Enqueue(value ...T)

Enqueue adds one or more an items to the end of the Queue.

func (*Queue[T]) IsEmpty added in v1.0.2 

func (q *Queue[T]) IsEmpty() bool

IsEmpty returns true if the Queue is empty

func (*Queue[T]) Peek added in v1.0.2 

func (q *Queue[T]) Peek() Option[T]

Peek returns the first item in the queue without removing it. If the queue is empty, then None is returned.

func (*Queue[T]) Size added in v1.0.2 

func (q *Queue[T]) Size() int

Size returns the number of items in the Queue

type Req added in v1.2.1 

type Req[Input any, Output any] struct {
	// Request is the data we are sending to the remote goroutine for
	// processing.
	Request Input
	// contains filtered or unexported fields
}

Req is a type to encapsulate RPC-like calls wherein we send some data structure as a request, as well as a channel to receive the response on where the remote goroutine will send the result.

NOTE: This construct should only be used for request/response patterns for which there is only a single response for the request.

func NewReq added in v1.2.1 

func NewReq[Input, Output any](input Input) (
	Req[Input, Output], <-chan Output)

NewReq is the base constructor of the Req type. It returns both the packaged Req object as well as the receive side of the response channel that we will listen on for the response.

func (*Req[Input, Output]) Dispatch added in v1.2.1 

func (r *Req[Input, Output]) Dispatch(handler func(Input) Output)

Dispatch is a convenience method that lifts a function that transforms the Input to the Output type into a full request handling cycle.

func (*Req[Input, Output]) Resolve added in v1.2.1 

func (r *Req[Input, Output]) Resolve(output Output)

Resolve is a function that is used to send a value of the Output type back to the requesting thread.

type Result added in v1.0.8 

type Result[T any] struct {
	Either[T, error]
}

Result represents a value that can either be a success (T) or an error.

func AndThen added in v1.0.8 

func AndThen[A, B any](r Result[A], f func(A) Result[B]) Result[B]

AndThen is an alias for FlatMap. This along with OrElse can be used to Railway Oriented Programming (ROP).

func AndThen2 added in v1.1.0 

func AndThen2[A, B, C any](ra Result[A], rb Result[B],
	f func(A, B) Result[C]) Result[C]

AndThen2 applies a function that returns a Result[C] to the success values of two Result types if both exist.

func CollectResults added in v1.2.5 

func CollectResults[A any](results []Result[A]) Result[[]A]

CollectResults collects a list of Results into a single Result of the list of Ok values in it. If there are any errors present it will return the first error encountered.

func Err added in v1.0.8 

func Err[T any](err error) Result[T]

Err creates a new Result with an error.

func Errf added in v1.0.8 

func Errf[T any](errString string, args ...any) Result[T]

Errf creates a new Result with a new formatted error string.

func FlatMap added in v1.0.8 

func FlatMap[A, B any](r Result[A], f func(A) Result[B]) Result[B]

FlatMap applies a function that returns a Result[B] to the success value if it exists.

func FlattenResult added in v1.2.5 

func FlattenResult[A any](r Result[Result[A]]) Result[A]

FlattenResult takes a nested Result and joins the two functor layers into one.

func NewResult added in v1.1.0 

func NewResult[T any](val T, err error) Result[T]

NewResult creates a new result from a (value, error) tuple.

func Ok added in v1.0.8 

func Ok[T any](val T) Result[T]

Ok creates a new Result with a success value.

func TransposeOptRes added in v1.2.5 

func TransposeOptRes[A any](o Option[Result[A]]) Result[Option[A]]

TransposeOptRes transposes the Option[Result[A]] into a Result[Option[A]]. This has the effect of leaving an A value alone while inverting the Option and Result layers. If there is no internal A value, it will convert the non-success value to the proper one in the transposition.

func TraverseResult added in v1.2.5 

func TraverseResult[A, B any](as []A, f func(A) Result[B]) Result[[]B]

TraverseResult traverses a slice of A values, applying the provided function to each, collecting the results into a Result of a slice of B values. If any of the results are Err, the entire result is the first error encountered.

func (Result[T]) AndThen added in v1.0.8 

func (r Result[T]) AndThen(f func(T) Result[T]) Result[T]

AndThen is an alias for FlatMap. This along with OrElse can be used to Railway Oriented Programming (ROP) by chaining successive computational operations from a single result type.

func (Result[T]) Err added in v1.1.0 

func (r Result[T]) Err() error

Err exposes the underlying error of the result type as a normal error type.

func (Result[T]) FlatMap added in v1.0.8 

func (r Result[T]) FlatMap(f func(T) Result[T]) Result[T]

FlatMap applies a kleisli endomorphic function that returns a Result to the success value if it exists.

func (Result[T]) IsErr added in v1.0.8 

func (r Result[T]) IsErr() bool

IsErr returns true if the Result is an error.

func (Result[T]) IsOk added in v1.0.8 

func (r Result[T]) IsOk() bool

IsOk returns true if the Result is a success value.

func (Result[T]) Map deprecated added in v1.0.8 

func (r Result[T]) Map(f func(T) T) Result[T]

Map applies an endomorphic function to the success value if it exists.

Deprecated: Use MapOk instead.

func (Result[T]) MapErr added in v1.0.8 

func (r Result[T]) MapErr(f func(error) error) Result[T]

MapErr applies an endomorphic function to the error value if it exists.

func (Result[T]) MapOk added in v1.2.5 

func (r Result[T]) MapOk(f func(T) T) Result[T]

MapOk applies an endomorphic function to the success value if it exists.

func (Result[T]) OkToSome added in v1.2.5 

func (r Result[T]) OkToSome() Option[T]

OkToSome mutes the error value of the result.

func (Result[T]) Option deprecated added in v1.0.8 

func (r Result[T]) Option() Option[T]

Option returns the success value as an Option.

Deprecated: Use OkToSome instead.

func (Result[T]) OrElse added in v1.0.8 

func (r Result[T]) OrElse(f func() Result[T]) Result[T]

OrElse returns the original Result if it is a success, otherwise it returns the provided alternative Result. This along with AndThen can be used to Railway Oriented Programming (ROP).

func (Result[A]) Sink added in v1.2.5 

func (r Result[A]) Sink(f func(A) error) error

Sink consumes a Result, either propagating its error or processing its success value with a function that can fail.

func (Result[T]) Unpack added in v1.0.8 

func (r Result[T]) Unpack() (T, error)

Unpack extracts the value or error from the Result.

func (Result[T]) UnwrapOr added in v1.0.8 

func (r Result[T]) UnwrapOr(defaultValue T) T

UnwrapOr returns the success value or a default value if it's an error.

func (Result[T]) UnwrapOrElse added in v1.0.8 

func (r Result[T]) UnwrapOrElse(f func() T) T

UnwrapOrElse returns the success value or computes a value from a function if it's an error.

func (Result[T]) UnwrapOrFail added in v1.0.8 

func (r Result[T]) UnwrapOrFail(t *testing.T) T

UnwrapOrFail returns the success value or fails the test if it's an error.

func (Result[T]) WhenErr added in v1.0.8 

func (r Result[T]) WhenErr(f func(error))

WhenErr executes the given function if the Result is an error.

func (Result[T]) WhenOk added in v1.2.5 

func (r Result[T]) WhenOk(f func(T))

WhenOk executes the given function if the Result is a success.

func (Result[T]) WhenResult deprecated added in v1.0.8 

func (r Result[T]) WhenResult(f func(T))

WhenResult executes the given function if the Result is a success.

Deprecated: Use WhenOk instead.

type Set added in v1.0.2 

type Set[T comparable] map[T]struct{}

Set is a generic set using type params that supports the following operations: diff, union, intersection, and subset.

func KeySet added in v1.0.6 

func KeySet[K comparable, V any](m map[K]V) Set[K]

KeySet converts a map into a Set containing the keys of the map.

func NewSet added in v1.0.2 

func NewSet[T comparable](elems ...T) Set[T]

NewSet returns a new set with the given elements.

func (Set[T]) Add added in v1.0.2 

func (s Set[T]) Add(e T)

Add adds an element to the set.

func (Set[T]) Contains added in v1.0.2 

func (s Set[T]) Contains(e T) bool

Contains returns true if the set contains the element.

func (Set[T]) Diff added in v1.0.2 

func (s Set[T]) Diff(other Set[T]) Set[T]

Diff returns the difference between two sets.

func (Set[T]) Equal added in v1.0.2 

func (s Set[T]) Equal(other Set[T]) bool

Equal returns true if the set is equal to the other set.

func (Set[T]) Intersect added in v1.0.2 

func (s Set[T]) Intersect(other Set[T]) Set[T]

Intersect returns the intersection of two sets.

func (Set[T]) IsEmpty added in v1.2.2 

func (s Set[T]) IsEmpty() bool

IsEmpty returns true if the set is empty.

func (Set[T]) Remove added in v1.0.2 

func (s Set[T]) Remove(e T)

Remove removes an element from the set.

func (Set[T]) Size added in v1.2.2 

func (s Set[T]) Size() uint

Size returns the number of elements in the set.

func (Set[T]) Subset added in v1.0.2 

func (s Set[T]) Subset(other Set[T]) bool

Subset returns true if the set is a subset of the other set.

func (Set[T]) ToSlice added in v1.0.2 

func (s Set[T]) ToSlice() []T

ToSlice returns the set as a slice.

func (Set[T]) Union added in v1.0.2 

func (s Set[T]) Union(other Set[T]) Set[T]

Union returns the union of two sets.

type T2 added in v1.2.0 

type T2[A, B any] struct {
	// contains filtered or unexported fields
}

T2 is the simplest 2-tuple type. It is useful for capturing ad hoc type conjunctions in a single value that can be easily dot-chained.

func NewT2 added in v1.2.0 

func NewT2[A, B any](a A, b B) T2[A, B]

NewT2 is the canonical constructor for a T2. We include it because the fields themselves are unexported.

func (T2[A, B]) First added in v1.2.0 

func (t2 T2[A, B]) First() A

First returns the first value in the T2.

func (T2[A, B]) Second added in v1.2.0 

func (t2 T2[A, B]) Second() B

Second returns the second value in the T2.

func (T2[A, B]) Unpack added in v1.2.0 

func (t2 T2[A, B]) Unpack() (A, B)

Unpack ejects the 2-tuple's members into the multiple return values that are customary in go idiom.

type Unit added in v1.2.0 

type Unit = struct{}

Unit is a type alias for the empty struct to make it a bit less noisy to communicate the informationaless type.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.