All returns true if the passed predicate returns true for all items in the slice.

AllMapItems returns true if the passed predicate returns true for all items in the map.

Any returns true if the passed predicate returns true for any item in the slice.

AnyMapItem returns true if the passed predicate returns true for any item in the map.

ByteSlice takes a byte array, and returns a slice.

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

Collect receives all values from a channel and returns them as a slice.

CollectBatch reads from the given channel and returns batchSize items at a time and a boolean that indicates whether we expect more items to be sent on the channel.

CopyAll creates a new slice where each item of the slice is a deep copy of the elements of the input slice.

CopyAllErr creates a new slice where each item of the slice is a deep copy of the elements of the input slice.

CopySlice returns a copy of the given slice.

Count returns the number of items in the slice that match the predicate.

CountMapItems returns the number of items in the map that match the predicate.

ElimOption is the universal Option eliminator.

Enumerate is a generic enumeration function.

EnumerateMap is a generic enumeration function.

ErrorAs behaves the same as `errors.As` except there's no need to declare the target error as a variable first.

Filter applies the given predicate function to each element of the given slice and generates a new slice containing only the elements for which the predicate returned true.

FilterMap applies the given predicate function to each element of the given map and generates a new slice containing only the elements for which the predicate returned true.

First returns the first item in the slice that matches the predicate, or an error if none matches.

FlatMap applies the given mapping function to each element of the given slice and concatenates the results into a new slice.

FlatMapErr applies the given mapping function to each element of the given slice, concatenates the results into a new slice, and returns an error if the mapping function fails.

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

ForEach is a generic implementation of a for-each (map with side effects).

ForEachErr will iterate through all items in the passed slice, calling the function f on each slice.

ForEachMapItem is a generic implementation of a for-each (map with side effects).

IsCanceled returns true if the passed error is a gRPC error with the context.Canceled error as the cause.

IsRpcErr returns true if the given error is a gRPC error with the given candidate error as the cause.

Last returns the last item in the slice that matches the predicate, or an error if none matches.

LiftA2Option transforms a pure function (A, B) -> C into one that will operate in an Option context.

MakeSlice is a generic function shorthand for making a slice out of a set of elements.

Map applies the given mapping function to each element of the given slice and generates a new slice.

MapErr applies the given fallible mapping function to each element of the given slice and generates a new slice.

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

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

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

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

MaybeSome constructs an option from a pointer.

NewConcurrentQueue constructs a ConcurrentQueue.

NewCriticalError creates a new CriticalError instance.

NewEventDistributor creates a new event distributor of the declared type.

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

NewLeft returns an Either with a left value.

NewRight returns an Either with a right value.

NewSet returns a new set with the given elements.

None trivially constructs an empty option.

NotAny returns true if the passed predicate returns false for all items in the slice.

NotAnyMapItem returns true if the passed predicate returns false for all items in the map.

ParSlice can be used to execute a function on each element of a slice in parallel.

Ptr returns the pointer of the given value.

RecvOrTimeout attempts to recv over chan c, returning the value.

RecvResp takes three channels: a response channel, an error channel and a quit channel.

Reduce takes a slice of something, and a reducer, and produces a final accumulated value.

SendAll attempts to send all messages through channel c.

SendOrQuit attempts to and a message through channel c.

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

Some trivially injects a value into an optional context.

ToArray takes a byte slice, and returns an array.

DefaultQueueSize is the default size to use for concurrent queues.

ConcurrentQueue is a typed concurrent-safe FIFO queue with unbounded capacity.

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

CriticalError is an error type that should be used for errors that are critical and should cause the application to exit.

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

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

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

Option[A] represents a value which may or may not be there.

ByteArray is a type constraint for type that reduces down to a fixed sized array.

Copyable is a generic interface for a type that's able to return a deep copy of itself.

CopyableErr is a generic interface for a type that's able to return a deep copy of itself.

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

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

ErrFunc is a type def for a function that takes a context (to allow early cancellation) and a series of value returning an error.

Reducer represents a function that takes an accumulator and the value, then returns a new accumulator.

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