dt

package

Go to main page

Versions in this module

v0

v0.10.9

Jan 14, 2024

Changes in this version

type Optional

+ func (o Optional[T]) Ok() bool

v0.10.8

Oct 29, 2023

Changes in this version

type Map

+ func (m Map[K, V]) Delete(k K)

v0.10.7

Aug 31, 2023

Changes in this version

type Map

+ func NewMap(in map[K]V) Map[K, V]

type Slice

+ func NewSlice(in []T) Slice[T]

v0.10.6

Aug 30, 2023

v0.10.5

Aug 29, 2023

Changes in this version

type Map

+ func (m Map[K, V]) AddTuple(p Tuple[K, V])

+ func (m Map[K, V]) ConsumePairs(pairs *Pairs[K, V])

+ func (m Map[K, V]) ConsumeTuples(tuples *Tuples[K, V])

+ func (m Map[K, V]) Tuples() *Tuples[K, V]

+ type Optional struct

+ func NewOptional(in T) Optional[T]

+ func (o *Optional[T]) Default(in T)

+ func (o *Optional[T]) DefaultFuture(in fun.Future[T])

+ func (o *Optional[T]) Future() fun.Future[T]

+ func (o *Optional[T]) Get() (T, bool)

+ func (o *Optional[T]) Handler() fun.Handler[T]

+ func (o *Optional[T]) Reset()

+ func (o *Optional[T]) Resolve() T

+ func (o *Optional[T]) Scan(src any) (err error)

+ func (o *Optional[T]) Set(in T)

+ func (o *Optional[T]) SetWhen(cond bool, v T)

+ func (o *Optional[T]) SetWhenFuture(cond bool, v fun.Future[T])

+ func (o *Optional[T]) Swap(next T) (prev T)

+ func (o *Optional[T]) UnmarshalBinary(in []byte) (err error)

+ func (o *Optional[T]) UnmarshalText(in []byte) (err error)

+ func (o Optional[T]) MarshalBinary() ([]byte, error)

+ func (o Optional[T]) MarshalText() ([]byte, error)

+ func (o Optional[T]) OK() bool

+ func (o Optional[T]) Value() (driver.Value, error)

type Pairs

+ func (p *Pairs[K, V]) Push(pair Pair[K, V])

type Slice

+ func MergeSlices(sls ...[]T) Slice[T]

+ func (s *Slice[T]) GrowCapacity(size int)

+ func (s Slice[T]) FillTo(length int) Slice[T]

+ func (s Slice[T]) Sparse() Slice[T]

+ func (s Slice[T]) Zero()

+ func (s Slice[T]) ZeroRange(start, end int)

+ type Tuple struct

+ One K

+ Two V

+ func MakeTuple(k K, v V) Tuple[K, V]

+ func (t *Tuple[K, V]) UnmarshalJSON(in []byte) error

+ func (t Tuple[K, V]) MarshalJSON() ([]byte, error)

+ type Tuples struct

+ func ConsumeTuples(ctx context.Context, iter *fun.Iterator[Tuple[K, V]]) (*Tuples[K, V], error)

+ func MakeTuples(in ...Tuple[K, V]) *Tuples[K, V]

+ func (p *Tuples[K, V]) Add(k K, v V) *Tuples[K, V]

+ func (p *Tuples[K, V]) Append(new ...Tuple[K, V])

+ func (p *Tuples[K, V]) Consume(ctx context.Context, iter *fun.Iterator[Tuple[K, V]]) error

+ func (p *Tuples[K, V]) Copy() *Tuples[K, V]

+ func (p *Tuples[K, V]) Extend(toAdd *Tuples[K, V])

+ func (p *Tuples[K, V]) Iterator() *fun.Iterator[Tuple[K, V]]

+ func (p *Tuples[K, V]) Len() int

+ func (p *Tuples[K, V]) List() *List[Tuple[K, V]]

+ func (p *Tuples[K, V]) MarshalJSON() ([]byte, error)

+ func (p *Tuples[K, V]) Observe(hf fun.Handler[Tuple[K, V]])

+ func (p *Tuples[K, V]) Ones() *fun.Iterator[K]

+ func (p *Tuples[K, V]) Process(pf fun.Processor[Tuple[K, V]]) fun.Worker

+ func (p *Tuples[K, V]) Push(tuple Tuple[K, V])

+ func (p *Tuples[K, V]) Slice() []Tuple[K, V]

+ func (p *Tuples[K, V]) SortMerge(c cmp.LessThan[Tuple[K, V]])

+ func (p *Tuples[K, V]) SortQuick(c cmp.LessThan[Tuple[K, V]])

+ func (p *Tuples[K, V]) Twos() *fun.Iterator[V]

+ func (p *Tuples[K, V]) UnmarshalJSON(in []byte) error

v0.10.4

Aug 24, 2023

Changes in this version

+ func DefaultMap(input map[K]V, args ...int) map[K]V

type List

+ func (l *List[T]) Populate(iter *fun.Iterator[T]) fun.Worker

type Set

+ func (s *Set[T]) SortMerge(lt cmp.LessThan[T])

+ func (s *Set[T]) SortQuick(lt cmp.LessThan[T])

type Slice

+ func DefaultSlice(input []T, args ...int) Slice[T]

+ func SlicePtrs(in []T) Slice[*T]

+ func SliceRefs(in []*T) Slice[T]

+ func SliceSparseRefs(in []*T) Slice[T]

+ func (s *Slice[T]) Grow(size int)

+ func (s *Slice[T]) Prepend(in ...T)

+ func (s Slice[T]) FillToLen(size int) Slice[T]

+ func (s Slice[T]) Index(index int) T

type Stack

+ func (s *Stack[T]) Populate(iter *fun.Iterator[T]) fun.Worker

v0.10.3

Aug 14, 2023

Changes in this version

type Element

+ func (e *Element[T]) OK() bool

type Item

+ func (it *Item[T]) OK() bool

type List

+ func (l *List[T]) Slice() Slice[T]

type Pairs

+ func ConsumePairs(ctx context.Context, iter *fun.Iterator[Pair[K, V]]) (*Pairs[K, V], error)

+ func (p *Pairs[K, V]) Copy() *Pairs[K, V]

+ func (p *Pairs[K, V]) Observe(hf fun.Handler[Pair[K, V]])

+ func (p *Pairs[K, V]) Process(pf fun.Processor[Pair[K, V]]) fun.Worker

type Set

+ func NewSetFromMap(in map[K]V) *Set[Pair[K, V]]

+ func NewSetFromSlice(in []T) *Set[T]

+ func (s *Set[T]) Extend(extra *Set[T])

type Slice

+ func (s *Slice[T]) Populate(iter *fun.Iterator[T]) fun.Operation

v0.10.2

Jul 26, 2023

Changes in this version

type Pairs

+ func (p *Pairs[K, V]) List() *List[Pair[K, V]]

+ func (p *Pairs[K, V]) SortMerge(c cmp.LessThan[Pair[K, V]])

+ func (p *Pairs[K, V]) SortQuick(c cmp.LessThan[Pair[K, V]])

type Slice

+ func (s Slice[T]) Ptr(index int) *T

+ func (s Slice[T]) Ptrs() []*T

v0.10.1

Jul 13, 2023

v0.10.0

Jul 7, 2023

Changes in this version

+ const ErrUninitializedContainer

+ func MapIterator(in map[K]V) *fun.Iterator[Pair[K, V]]

+ func MapKeys(in map[K]V) *fun.Iterator[K]

+ func MapValues(in map[K]V) *fun.Iterator[V]

+ func Unwind(in T) []T

+ func Unwrap(in T) (out T)

+ type Element struct

+ func NewElement(val T) *Element[T]

+ func (e *Element[T]) Append(new *Element[T]) *Element[T]

+ func (e *Element[T]) Drop()

+ func (e *Element[T]) In(l *List[T]) bool

+ func (e *Element[T]) MarshalJSON() ([]byte, error)

+ func (e *Element[T]) Next() *Element[T]

+ func (e *Element[T]) Ok() bool

+ func (e *Element[T]) Previous() *Element[T]

+ func (e *Element[T]) Remove() bool

+ func (e *Element[T]) Set(v T) bool

+ func (e *Element[T]) String() string

+ func (e *Element[T]) Swap(with *Element[T]) bool

+ func (e *Element[T]) UnmarshalJSON(in []byte) error

+ func (e *Element[T]) Value() T

+ type Heap struct

+ LT cmp.LessThan[T]

+ func NewHeapFromIterator(ctx context.Context, cmp cmp.LessThan[T], iter *fun.Iterator[T]) (*Heap[T], error)

+ func (h *Heap[T]) Iterator() *fun.Iterator[T]

+ func (h *Heap[T]) Len() int

+ func (h *Heap[T]) Pop() (T, bool)

+ func (h *Heap[T]) Push(t T)

+ type Item struct

+ func NewItem(in T) *Item[T]

+ func (it *Item[T]) Append(n *Item[T]) *Item[T]

+ func (it *Item[T]) Attach(stack *Stack[T]) bool

+ func (it *Item[T]) Detach() *Stack[T]

+ func (it *Item[T]) In(s *Stack[T]) bool

+ func (it *Item[T]) MarshalJSON() ([]byte, error)

+ func (it *Item[T]) Next() *Item[T]

+ func (it *Item[T]) Ok() bool

+ func (it *Item[T]) Remove() bool

+ func (it *Item[T]) Set(v T) bool

+ func (it *Item[T]) String() string

+ func (it *Item[T]) UnmarshalJSON(in []byte) error

+ func (it *Item[T]) Value() T

+ type List struct

+ func NewListFromIterator(ctx context.Context, iter *fun.Iterator[T]) (*List[T], error)

+ func (l *List[T]) Append(items ...T)

+ func (l *List[T]) Back() *Element[T]

+ func (l *List[T]) Copy() *List[T]

+ func (l *List[T]) Extend(input *List[T])

+ func (l *List[T]) Front() *Element[T]

+ func (l *List[T]) IsSorted(lt cmp.LessThan[T]) bool

+ func (l *List[T]) Iterator() *fun.Iterator[T]

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

+ func (l *List[T]) MarshalJSON() ([]byte, error)

+ func (l *List[T]) PopBack() *Element[T]

+ func (l *List[T]) PopFront() *Element[T]

+ func (l *List[T]) PopIterator() *fun.Iterator[T]

+ func (l *List[T]) PopReverse() *fun.Iterator[T]

+ func (l *List[T]) Producer() fun.Producer[T]

+ func (l *List[T]) ProducerPop() fun.Producer[T]

+ func (l *List[T]) ProducerReverse() fun.Producer[T]

+ func (l *List[T]) ProducerReversePop() fun.Producer[T]

+ func (l *List[T]) PushBack(it T)

+ func (l *List[T]) PushFront(it T)

+ func (l *List[T]) Reverse() *fun.Iterator[T]

+ func (l *List[T]) SortMerge(lt cmp.LessThan[T])

+ func (l *List[T]) SortQuick(lt cmp.LessThan[T])

+ func (l *List[T]) UnmarshalJSON(in []byte) error

+ type Map map[K]V

+ func Mapify(in map[K]V) Map[K, V]

+ func (m Map[K, V]) Add(k K, v V)

+ func (m Map[K, V]) AddPair(p Pair[K, V])

+ func (m Map[K, V]) Append(pairs ...Pair[K, V])

+ func (m Map[K, V]) Check(key K) bool

+ func (m Map[K, V]) Consume(ctx context.Context, iter *fun.Iterator[Pair[K, V]])

+ func (m Map[K, V]) ConsumeMap(in Map[K, V])

+ func (m Map[K, V]) ConsumeSlice(in []V, keyf func(V) K)

+ func (m Map[K, V]) ConsumeValues(ctx context.Context, iter *fun.Iterator[V], keyf func(V) K)

+ func (m Map[K, V]) Extend(pairs *Pairs[K, V])

+ func (m Map[K, V]) Get(key K) V

+ func (m Map[K, V]) Iterator() *fun.Iterator[Pair[K, V]]

+ func (m Map[K, V]) Keys() *fun.Iterator[K]

+ func (m Map[K, V]) Len() int

+ func (m Map[K, V]) Load(key K) (V, bool)

+ func (m Map[K, V]) Pairs() *Pairs[K, V]

+ func (m Map[K, V]) Producer() fun.Producer[Pair[K, V]]

+ func (m Map[K, V]) ProducerKeys() fun.Producer[K]

+ func (m Map[K, V]) ProducerValues() fun.Producer[V]

+ func (m Map[K, V]) SetDefault(key K)

+ func (m Map[K, V]) Values() *fun.Iterator[V]

+ type Pair struct

+ Key K

+ Value V

+ func MakePair(k K, v V) Pair[K, V]

+ type Pairs struct

+ func MakePairs(in ...Pair[K, V]) *Pairs[K, V]

+ func (p *Pairs[K, V]) Add(k K, v V) *Pairs[K, V]

+ func (p *Pairs[K, V]) AddPair(pair Pair[K, V]) *Pairs[K, V]

+ func (p *Pairs[K, V]) Append(new ...Pair[K, V]) *Pairs[K, V]

+ func (p *Pairs[K, V]) Consume(ctx context.Context, iter *fun.Iterator[Pair[K, V]]) error

+ func (p *Pairs[K, V]) ConsumeMap(in map[K]V) *Pairs[K, V]

+ func (p *Pairs[K, V]) ConsumeSlice(in []V, keyf func(V) K) *Pairs[K, V]

+ func (p *Pairs[K, V]) ConsumeValues(ctx context.Context, iter *fun.Iterator[V], keyf func(V) K) error

+ func (p *Pairs[K, V]) Extend(toAdd *Pairs[K, V])

+ func (p *Pairs[K, V]) Iterator() *fun.Iterator[Pair[K, V]]

+ func (p *Pairs[K, V]) Keys() *fun.Iterator[K]

+ func (p *Pairs[K, V]) Len() int

+ func (p *Pairs[K, V]) Map() map[K]V

+ func (p *Pairs[K, V]) MarshalJSON() ([]byte, error)

+ func (p *Pairs[K, V]) Slice() []Pair[K, V]

+ func (p *Pairs[K, V]) UnmarshalJSON(in []byte) error

+ func (p *Pairs[K, V]) Values() *fun.Iterator[V]

+ type Set struct

+ func (s *Set[T]) Add(in T)

+ func (s *Set[T]) AddCheck(in T) (ok bool)

+ func (s *Set[T]) Check(in T) bool

+ func (s *Set[T]) Delete(in T)

+ func (s *Set[T]) DeleteCheck(in T) bool

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

+ func (s *Set[T]) Iterator() *fun.Iterator[T]

+ func (s *Set[T]) Len() int

+ func (s *Set[T]) MarshalJSON() ([]byte, error)

+ func (s *Set[T]) Order()

+ func (s *Set[T]) Populate(iter *fun.Iterator[T])

+ func (s *Set[T]) Producer() (out fun.Producer[T])

+ func (s *Set[T]) Synchronize()

+ func (s *Set[T]) UnmarshalJSON(in []byte) error

+ func (s *Set[T]) WithLock(mtx *sync.Mutex)

+ type Slice []T

+ func Sliceify(in []T) Slice[T]

+ func Transform(in Slice[T], op func(T) (O, error)) (Slice[O], error)

+ func Variadic(in ...T) Slice[T]

+ func (s *Slice[T]) Add(in T)

+ func (s *Slice[T]) AddWhen(cond bool, in T)

+ func (s *Slice[T]) Append(in ...T)

+ func (s *Slice[T]) AppendWhen(cond bool, in ...T)

+ func (s *Slice[T]) Empty()

+ func (s *Slice[T]) Extend(in []T)

+ func (s *Slice[T]) ExtendWhen(cond bool, in []T)

+ func (s *Slice[T]) Filter(p func(T) bool) (o Slice[T])

+ func (s *Slice[T]) FilterFuture(p func(T) bool) fun.Future[Slice[T]]

+ func (s *Slice[T]) Reset()

+ func (s *Slice[T]) Reslice(start, end int)

+ func (s *Slice[T]) ResliceBeginning(start int)

+ func (s *Slice[T]) ResliceEnd(end int)

+ func (s *Slice[T]) Truncate(n int)

+ func (s Slice[T]) Cap() int

+ func (s Slice[T]) Copy() Slice[T]

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

+ func (s Slice[T]) Item(index int) T

+ func (s Slice[T]) Iterator() *fun.Iterator[T]

+ func (s Slice[T]) Last() int

+ func (s Slice[T]) Len() int

+ func (s Slice[T]) Observe(of fun.Observer[T])

+ func (s Slice[T]) Process(pf fun.Processor[T]) fun.Worker

+ func (s Slice[T]) Sort(cp func(a, b T) bool)

+ type Stack struct

+ func NewStackFromIterator(ctx context.Context, iter *fun.Iterator[T]) (*Stack[T], error)

+ func (s *Stack[T]) Append(items ...T)

+ func (s *Stack[T]) Head() *Item[T]

+ func (s *Stack[T]) Iterator() *fun.Iterator[T]

+ func (s *Stack[T]) Len() int

+ func (s *Stack[T]) MarshalJSON() ([]byte, error)

+ func (s *Stack[T]) Pop() *Item[T]

+ func (s *Stack[T]) PopIterator() *fun.Iterator[T]

+ func (s *Stack[T]) Producer() fun.Producer[T]

+ func (s *Stack[T]) ProducerPop() fun.Producer[T]

+ func (s *Stack[T]) Push(it T)

+ func (s *Stack[T]) UnmarshalJSON(in []byte) error

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL