fn

Nov 6, 2024

Changes in this version

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

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

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

type Option

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

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

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

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

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

type Result

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

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

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

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

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

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

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

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

Oct 30, 2024

Changes in this version

type Option

+ func OptionFromPtr[A any](a *A) Option[A]

Oct 17, 2024

Changes in this version

+ var DefaultTimeout = 30 * time.Second

+ type ContextGuard struct

+ DefaultTimeout time.Duration

+ Quit chan struct{}

+ Wg sync.WaitGroup

+ func NewContextGuard() *ContextGuard

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

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

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

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

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

Oct 7, 2024

Changes in this version

+ var ErrStopping = errors.New("can not add goroutine, stopping")

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

+ type GoroutineManager struct

+ func NewGoroutineManager(ctx context.Context) *GoroutineManager

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

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

+ func (g *GoroutineManager) Stop()

type List

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

type Option

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

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

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

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

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

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

type Set

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

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

Aug 8, 2024

Changes in this version

+ type Req struct

+ Request Input

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

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

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

Jul 13, 2024

Changes in this version

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

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

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

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

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

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

+ func Iden[A any](a A) A

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

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

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

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

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

type Either

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

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

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

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

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

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

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

+ type List struct

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type Node struct

+ Value A

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

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

type Option

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

+ type T2 struct

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

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

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

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

+ type Unit = struct

Jun 20, 2024

Changes in this version

type Result

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

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

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

Jun 5, 2024

Changes in this version

+ type Pred func(A) bool

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

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

May 29, 2024

Changes in this version

+ type Result struct

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

May 21, 2024

Changes in this version

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

May 10, 2024

Changes in this version

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

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

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

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

+ type Number interface

type Set

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

Mar 8, 2024

Changes in this version

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

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

+ func Filter[A any](pred func(A) bool, s []A) []A

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

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

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

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

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

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

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

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

type Option

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

Feb 27, 2024

Changes in this version

type Option

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

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

Jan 24, 2024

Changes in this version

+ const DefaultQueueSize

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

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

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

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

+ func Reduce[T any, V any, S []V](s S, f Reducer[T, V]) T

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

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

+ type ConcurrentQueue struct

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

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

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

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

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

+ type Either struct

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

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

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

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

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

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

+ type Event interface

+ Timestamp func() time.Time

+ type EventDistributor struct

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

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

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

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

+ type EventPublisher interface

+ RegisterSubscriber func(receiver *EventReceiver[T], deliverExisting bool, deliverFrom Q) error

+ RemoveSubscriber func(subscriber *EventReceiver[T]) error

+ type EventReceiver struct

+ ItemRemoved *ConcurrentQueue[T]

+ NewItemCreated *ConcurrentQueue[T]

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

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

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

type Option

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

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

+ type Queue struct

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

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

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

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

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

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

+ type Reducer func(accum T, value V) T

+ type Set map[T]struct

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

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

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

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

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

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

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

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

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

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

Jan 12, 2024

Changes in this version

type Option

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

Dec 8, 2023

Changes in this version

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

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

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

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

+ type Option struct

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

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

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

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

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

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

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

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