util

Documentation

Index

• func Any[T Element[T]](ctx context.Context, c Container[T], f func(T) bool) (ok bool, err error)
• func ChanToSlice[T any](ctx context.Context, c <-chan T) (slice []T, err error)
• func Concatenate[T any](ins ...[]T) (out []T)
• func Each[T any](ctx context.Context, ts []T, f func(*T) bool) error
• func EachErr[T any](ctx context.Context, ts []T, f func(*T) (bool, error)) error
• func ElementsEqual[T Element[T]](a, b T) bool
• func Filter[T any](f func(T) bool, in ...T) (out []T)
• func NonEmpty[T any](t []T) bool
• func SliceToChan[T any](ctx context.Context, slice []T, c chan<- T) (err error)
• func Sum[T constraints.Ordered](terms ...T) (sum T)
• func Transform[From, To any](ctx context.Context, transformer func(From) To, from ...From) (to []To)
• func TransformErr[From, To any](ctx context.Context, transformer func(From) (To, error), from ...From) ([]To, error)
• func UnmarshalRegexp(re *regexp.Regexp, match []string, v interface{}) error
• type Chain
  • func (sc *Chain[T]) Run(ctx context.Context, init ...T) (results <-chan T, callback func() error)
• type Container
• type Element
• type Merger
• type MergerTransformer
  • func (t MergerTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error
• type OrderedSet
  • func NewOrderedSet[T Element[T]](ctx context.Context, ts ...T) *OrderedSet[T]
  • func (s *OrderedSet[T]) Contains(ctx context.Context, t T) (ok bool)
  • func (s *OrderedSet) Each(ctx context.Context, f func(T) bool) error
  • func (s OrderedSet) Empty() bool
  • func (s *OrderedSet[T]) Insert(ctx context.Context, ts ...T) (inserted int)
  • func (s OrderedSet) Len() int
  • func (s *OrderedSet) RemoveIf(_ context.Context, f func(T) bool) (removed int, err error)
  • func (s *OrderedSet) Slice() []T
• type Pather
• type SortedSet
  • func NewSortedSet[T Element[T]](ctx context.Context, ts ...T) *SortedSet[T]
  • func (s *SortedSet[T]) Contains(ctx context.Context, t T) (ok bool)
  • func (s *SortedSet) Each(ctx context.Context, f func(T) bool) error
  • func (s SortedSet) Empty() bool
  • func (s *SortedSet[T]) Insert(ctx context.Context, ts ...T) (inserted int)
  • func (s *SortedSet[T]) IntDiff(ctx context.Context, other *SortedSet[T]) (thisDiff, intersection, otherDiff SortedSet[T])
  • func (s SortedSet) Len() int
  • func (s *SortedSet) RemoveIf(_ context.Context, f func(T) bool) (removed int, err error)
  • func (s *SortedSet) Slice() []T
• type Transformer
  • func Exclude[T any](f func(T) bool) Transformer[T]

Functions

func Any

func Any[T Element[T]](
	ctx context.Context,
	c Container[T],
	f func(T) bool,
) (ok bool, err error)

func ChanToSlice

func ChanToSlice[T any](
	ctx context.Context,
	c <-chan T,
) (slice []T, err error)

func Concatenate

func Concatenate[T any](ins ...[]T) (out []T)

func Each

func Each[T any](ctx context.Context, ts []T, f func(*T) bool) error

func EachErr

func EachErr[T any](
	ctx context.Context,
	ts []T,
	f func(*T) (bool, error),
) error

func ElementsEqual

func ElementsEqual[T Element[T]](a, b T) bool

func Filter

func Filter[T any](f func(T) bool, in ...T) (out []T)

func NonEmpty

func NonEmpty[T any](t []T) bool

func SliceToChan

func SliceToChan[T any](
	ctx context.Context,
	slice []T,
	c chan<- T,
) (err error)

func Sum

func Sum[T constraints.Ordered](terms ...T) (sum T)

func Transform

func Transform[From, To any](
	ctx context.Context,
	transformer func(From) To,
	from ...From,
) (to []To)

func TransformErr

func TransformErr[From, To any](
	ctx context.Context,
	transformer func(From) (To, error),
	from ...From,
) ([]To, error)

func UnmarshalRegexp

func UnmarshalRegexp(re *regexp.Regexp, match []string, v interface{}) error

Types

type Chain

type Chain[T any] struct {
	Transformers []Transformer[T]
	ChanSize     int
}

func (*Chain[T]) Run

func (sc *Chain[T]) Run(
	ctx context.Context,
	init ...T,
) (results <-chan T, callback func() error)

type Container

type Container[T Element[T]] interface {
	Contains(context.Context, T) bool
	Each(context.Context, func(T) bool) error
	Empty() bool
	Insert(context.Context, ...T) int
	Len() int
	Slice() []T
}

type Element

type Element[T any] interface {
	Compare(T) int
}

type Merger

type Merger interface {
	Merge(src reflect.Value) error
}

type MergerTransformer

type MergerTransformer struct{}

func (MergerTransformer) Transformer

func (t MergerTransformer) Transformer(
	typ reflect.Type,
) func(dst, src reflect.Value) error

type OrderedSet

type OrderedSet[T Element[T]] struct {
	// contains filtered or unexported fields
}

func NewOrderedSet

func NewOrderedSet[T Element[T]](
	ctx context.Context,
	ts ...T,
) *OrderedSet[T]

func (*OrderedSet[T]) Contains

func (s *OrderedSet[T]) Contains(ctx context.Context, t T) (ok bool)

func (*OrderedSet) Each

func (s *OrderedSet) Each(ctx context.Context, f func(T) bool) error

func (OrderedSet) Empty

func (s OrderedSet) Empty() bool

func (*OrderedSet[T]) Insert

func (s *OrderedSet[T]) Insert(
	ctx context.Context,
	ts ...T,
) (inserted int)

func (OrderedSet) Len

func (s OrderedSet) Len() int

func (*OrderedSet) RemoveIf

func (s *OrderedSet) RemoveIf(
	_ context.Context,
	f func(T) bool,
) (removed int, err error)

func (*OrderedSet) Slice

func (s *OrderedSet) Slice() []T

type Pather

type Pather interface {
	Path() (string, error)
}

type SortedSet

type SortedSet[T Element[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet

func NewSortedSet[T Element[T]](
	ctx context.Context,
	ts ...T,
) *SortedSet[T]

func (*SortedSet[T]) Contains

func (s *SortedSet[T]) Contains(ctx context.Context, t T) (ok bool)

func (*SortedSet) Each

func (s *SortedSet) Each(ctx context.Context, f func(T) bool) error

func (SortedSet) Empty

func (s SortedSet) Empty() bool

func (*SortedSet[T]) Insert

func (s *SortedSet[T]) Insert(
	ctx context.Context,
	ts ...T,
) (inserted int)

func (*SortedSet[T]) IntDiff

func (s *SortedSet[T]) IntDiff(
	ctx context.Context,
	other *SortedSet[T],
) (thisDiff, intersection, otherDiff SortedSet[T])

func (SortedSet) Len

func (s SortedSet) Len() int

func (*SortedSet) RemoveIf

func (s *SortedSet) RemoveIf(
	_ context.Context,
	f func(T) bool,
) (removed int, err error)

func (*SortedSet) Slice

func (s *SortedSet) Slice() []T

type Transformer

type Transformer[T any] func(
	ctx context.Context,
	in <-chan T,
	out chan<- T,
) error

func Exclude

func Exclude[T any](f func(T) bool) Transformer[T]