dt

func (*Element[T]) Append ¶

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

Append adds the element 'new' after the element 'e', inserting it in the next position in the list. Will return 'e' if 'new' is not valid for insertion into this list (e.g. it belongs to another list, or is attached to other elements, is already a member of this list, or is otherwise invalid.) PushBack and PushFront, are implemented in terms of Append.

func (*Element[T]) Drop ¶

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

Drop wraps remove, and additionally, if the remove was successful, drops the value and sets the Ok value to false.

func (*Element[T]) In ¶

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

In checks to see if an element is in the specified list. Because elements hold a pointer to their list, this is an O(1) operation.

Returns false when the element is nil.

func (*Element[T]) MarshalJSON ¶

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

MarshalJSON returns the result of json.Marshal on the value of the element. By supporting json.Marshaler and json.Unmarshaler, Elements and lists can behave as arrays in larger json objects, and can be as the output/input of json.Marshal and json.Unmarshal.

func (*Element[T]) Next ¶

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

Next produces the next element. This is always non-nil, *unless* the element is not a member of a list. At the ends of a list, the value is non-nil, but would return false for Ok.

func (*Element[T]) Ok ¶

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

Ok checks that an element is valid. Invalid elements can be produced at the end of iterations (e.g. the list's root object,) or if you attempt to Pop an element off of an empty list.

Returns false when the element is nil.

func (*Element[T]) Previous ¶

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

Previous produces the next element. This is always non-nil, *unless* the element is not a member of a list. At the ends of a list, the value is non-nil, but would return false for Ok.

func (*Element[T]) Remove ¶

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

Remove removes the elemtn from the list, returning true if the operation was successful. Remove returns false when the element is not valid to be removed (e.g. is not part of a list, is the root element of the list, etc.)

func (*Element[T]) Set ¶

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

Set allows you to change set the value of an item in place. Returns true if the operation is successful. The operation fails if the Element is the root item in a list or not a member of a list.

Set is safe to call on nil elements.

func (*Element[T]) String ¶

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

String returns the string form of the value of the element.

func (*Element[T]) Swap ¶

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

Swap exchanges the location of two elements in a list, returning true if the operation was successful, and false if the elements are not eligible to be swapped. It is valid/possible to swap the root element of the list with another element to "move the head", causing a wrap around effect. Swap will not operate if either element is nil, or not a member of the same list.

func (*Element[T]) UnmarshalJSON ¶

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

UnmarshalJSON reads the json value, and sets the value of the element to the value in the json, potentially overriding an existing value. By supporting json.Marshaler and json.Unmarshaler, Elements and lists can behave as arrays in larger json objects, and can be as the output/input of json.Marshal and json.Unmarshal.

func (*Element[T]) Value ¶

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

Value accesses the element's value.

func (*Heap[T]) Iterator ¶

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

Iterator provides an fun.Iterator interface to the heap. The iterator consumes items from the heap, and will return when the heap is empty.

func (*Heap[T]) Len ¶

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

Len reports the size of the heap. Because the heap tracks its size with Push/Pop operations, this is a constant time operation.

func (*Heap[T]) Pop ¶

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

Pop removes the element from the underlying list and returns it, with an OK value, which is true when the value returned is valid.

func (*Heap[T]) Push ¶

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

Push adds an item to the heap.

func (*Item[T]) Append ¶

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

Append inserts a new item after the following item in the stack, returning the new item, or if the new item is not valid, the item itself.

func (*Item[T]) Attach ¶

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

Attach removes items from the back of the stack and appends them to the current item. This inverts the order of items in the input stack.

func (*Item[T]) Detach ¶

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

Detach splits a stack into two, using the current Item as the head of the new stack. The output is always non-nil: if the item is not valid or not the member of a stack Detach creates a new empty stack. If this item is currently the head of a stack, Detach returns that stack.

func (*Item[T]) In ¶

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

In reports if an item is a member of a stack. Because item's track references to the stack, this is an O(1) operation.

func (*Item[T]) MarshalJSON ¶

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

MarshalJSON returns the result of json.Marshal on the value of the item. By supporting json.Marshaler and json.Unmarshaler, Items and stacks can behave as arrays in larger json objects, and can be as the output/input of json.Marshal and json.Unmarshal.

func (*Item[T]) Next ¶

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

Next returns the following item in the stack.

func (*Item[T]) Ok ¶

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

Ok return true if the Value() has been set. Returns false for incompletely initialized values.

Returns false when the item is nil.

func (*Item[T]) Remove ¶

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

Remove removes the item from the stack, (at some expense, for items deeper in the stack.) If the operation isn't successful or possible the operation returns false.

func (*Item[T]) Set ¶

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

Set mutates the value of an Item, returning true if the operation has been successful. The operation fails if the Item is the head item in a stack or not a member of a stack.

func (*Item[T]) String ¶

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

String implements fmt.Stringer, and returns the string value of the item's value.

func (*Item[T]) UnmarshalJSON ¶

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

UnmarshalJSON reads the json value, and sets the value of the item to the value in the json, potentially overriding an existing value. By supporting json.Marshaler and json.Unmarshaler, Items and stacks can behave as arrays in larger json objects, and can be as the output/input of json.Marshal and json.Unmarshal.

func (*Item[T]) Value ¶

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

Value returns the Item's underlying value. Use the Ok method to check the validity of the zero values.

func (*List[T]) Append ¶

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

Append adds a variadic sequence of items to the end of the list.

func (*List[T]) Back ¶

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

Back returns a pointer to the last element of the list. If the list is empty, this is also the first element of the list. The operation is non-destructive. You can use this pointer to begin a c-style iteration over the list:

for e := list.Back(); e.Ok(); e = e.Previous() {
       // operate
}

func (*List[T]) Copy ¶

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

Copy duplicates the list. The element objects in the list are distinct, though if the Values are themselves references, the values of both lists would be shared.

func (*List[T]) Extend ¶

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

Extend removes items from the front of the input list, and appends them to the end of the current list.

func (*List[T]) Front ¶

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

Front returns a pointer to the first element of the list. If the list is empty, this is also the last element of the list. The operation is non-destructive. You can use this pointer to begin a c-style iteration over the list:

for e := list.Front(); e.Ok(); e = e.Next() {
       // operate
}

func (*List[T]) IsSorted ¶

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

IsSorted reports if the list is sorted from low to high, according to the LessThan function.

func (*List[T]) Iterator ¶

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

Iterator returns an iterator over the values in the list in front-to-back order. The Iterator is not synchronized with the values in the list, and will be exhausted when you reach the end of the list.

If you add values to the list during iteration *behind* where the iterator is, these values will not be present in the iterator; however, values added ahead of the iterator, will be visible.

func (*List[T]) Len ¶

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

Len returns the length of the list. As the Append/Remove operations track the length of the list, this is an O(1) operation.

func (*List[T]) MarshalJSON ¶

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

MarshalJSON produces a JSON array representing the items in the list. By supporting json.Marshaler and json.Unmarshaler, Elements and lists can behave as arrays in larger json objects, and can be as the output/input of json.Marshal and json.Unmarshal.

func (*List[T]) PopBack ¶

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

PopBack removes the last element from the list. If the list is empty, this returns a detached non-nil value, that will report an Ok() false value. You can use this element to produce a C-style iterator over the list, that removes items during the iteration:

for e := list.PopBack(); e.Ok(); e = input.PopBack() {
	// do work
}

func (*List[T]) PopFront ¶

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

PopFront removes the first element from the list. If the list is empty, this returns a nil value, that will report an Ok() false You can use this element to produce a C-style iterator over the list, that removes items during the iteration:

for e := list.PopFront(); e.Ok(); e = input.PopFront() {
	// do work
}

func (*List[T]) PopIterator ¶

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

PopIterator produces an iterator that consumes elements from the list as it iterates, moving front-to-back.

If you add values to the list during iteration *behind* where the iterator is, these values will not be present in the iterator; however, values added ahead of the iterator, will be visible.

func (*List[T]) PopReverse ¶

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

PopReverse produces an iterator that consumes elements from the list as it iterates, moving back-to-front. To access an iterator of the *values* in the list, use PopReverseValues() for an iterator over the values.

If you add values to the list during iteration *behind* where the iterator is, these values will not be present in the iterator; however, values added ahead of the iterator, will be visible.

func (*List[T]) Producer ¶

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

Producer provides a producer function that iterates through the contents of the list. When the producer reaches has fully iterated through the list, or iterates to an item that has been removed (likely due to concurrent access,) the producer returns io.EOF.

The Producer starts at the front of the list and iterates in order.

func (*List[T]) ProducerPop ¶

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

ProducerPop provides a producer function that iterates through the contents of the list, removing each item from the list as it encounters it. When the producer reaches has fully iterated through the list, or iterates to an item that has been removed (likely due to concurrent access,) the producer returns io.EOF.

In most cases, for destructive iteration, use the pubsub.Queue, pubsub.Deque, or one of the pubsub.Distributor implementations.

The Producer starts at the front of the list and iterates in order.

func (*List[T]) ProducerReverse ¶

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

ProducerReverse provides the same semantics and operation as the Producer operation, but starts at the end/tail of the list and works forward.

func (*List[T]) ProducerReversePop ¶

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

ProducerReverse provides the same semantics and operation as the ProducerPop operation, but starts at the end/tail of the list and works forward.

func (*List[T]) PushBack ¶

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

PushBack creates an element and appends it to the list. The performance of PushFront and PushBack are the same.

func (*List[T]) PushFront ¶

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

PushFront creates an element and prepends it to the list. The performance of PushFront and PushBack are the same.

func (*List[T]) Reverse ¶

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

Reverse returns an iterator that produces elements from the list, from the back to the front. The iterator is not synchronized with the values in the list, and will be exhausted when you reach the front of the list.

If you add values to the list during iteration *behind* where the iterator is, these values will not be present in the iterator; however, values added ahead of the iterator, will be visible.

func (*List[T]) SortMerge ¶

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

SortMerge sorts the list, using the provided comparison function and a Merge Sort operation. This is something of a novelty in most cases, as removing the elements from the list, adding to a slice and then using sort.Slice() from the standard library, and then re-adding those elements to the list, will perform better.

The operation will modify the input list, replacing it with an new list operation.

func (*List[T]) SortQuick ¶

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

SortQuick sorts the list, by removing the elements, adding them to a slice, and then using sort.SliceStable(). In many cases this performs better than the merge sort implementation.

func (*List[T]) UnmarshalJSON ¶

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

UnmarshalJSON reads json input and adds that to values in the list. If there are elements in the list, they are not removed. By supporting json.Marshaler and json.Unmarshaler, Elements and lists can behave as arrays in larger json objects, and can be as the output/input of json.Marshal and json.Unmarshal.

func (Map[K, V]) Add ¶

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

Add adds a key value pair directly to the map.

func (Map[K, V]) AddPair ¶

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

AddPair adds a Pair object to the map.

func (Map[K, V]) Append ¶

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

Append adds a sequence of Pair objects to the map.

func (Map[K, V]) Check ¶

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

Check returns true if the value K is in the map.

func (Map[K, V]) Consume ¶

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

Consume adds items to the map from an iterator of Pair objects. Existing values for K are always overwritten.

func (Map[K, V]) ConsumeMap ¶

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

ConsumeMap adds all the keys from the input map the map.

func (Map[K, V]) ConsumeSlice ¶

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

ConsumeSlice adds a slice of values to the map, using the provided function to generate the key for the value. Existing values in the map are overridden.

func (Map[K, V]) ConsumeValues ¶

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

ConsumeValues adds items to the map, using the function to generate the keys for the values.

This operation will panic (with an ErrInvariantValidation) if the keyf panics.

func (Map[K, V]) Extend ¶

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

Extend adds a sequence of Pairs to the map.

func (Map[K, V]) Get ¶

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

Get returns the value from the map, and is the same thing as:

foo := mp[key]

If the key is not present in the map, as with a normal map, this is the zero value for V.

func (Map[K, V]) Iterator ¶

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

Iterator converts a map into an iterator of dt.Pair objects. The iterator is panic-safe, and uses one go routine to track the progress through the map. As a result you should always, either exhaust the iterator, cancel the context that you pass to the iterator OR call iterator.Close().

To use this iterator the items in the map are not copied, and the iteration order is randomized following the convention in go.

Use in combination with other iterator processing tools (generators, observers, transformers, etc.) to limit the number of times a collection of data must be coppied.

func (Map[K, V]) Keys ¶

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

Keys provides an iterator over just the keys in the map.

func (Map[K, V]) Len ¶

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

Len returns the length. It is equivalent to len(Map), but is provided for consistency.

func (Map[K, V]) Load ¶

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

Load returns the value in the map for the key, and an "ok" value which is true if that item is present in the map.

func (Map[K, V]) Pairs ¶

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

Pairs exports a map a Pairs object, which is an alias for a slice of Pair objects.

func (Map[K, V]) Producer ¶

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

Producer constructs a fun.Producer function for the pairs in the map. The operation starts a goroutine on the first iteration that tracks the state of the iterator. Iteration order is randomized.

func (Map[K, V]) ProducerKeys ¶

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

ProducerKeys returns a generator that generates the keys of the map. The operation requires a goroutine to keep track of the state of the iteration, but does not buffer or cache keys.

func (Map[K, V]) ProducerValues ¶

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

ProducerValues returns a generator that generates the values of the map. The operation requires a goroutine to keep track of the state of the iteration, but does not buffer or cache values.

func (Map[K, V]) SetDefault ¶

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

SetDefault set's sets the provided key in the map to the zero value for the value type.

func (Map[K, V]) Values ¶

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

Values provides an iterator over just the values in the map.

func (*Pairs[K, V]) Add ¶

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

Add adds a new value to the underlying slice. This may add a duplicate key.

func (*Pairs[K, V]) AddPair ¶

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

AddPair adds a single pair to the slice of pairs. This may add a duplicate key.

func (*Pairs[K, V]) Append ¶

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

Append as a collection of pairs to the collection of key/value pairs.

func (*Pairs[K, V]) Consume ¶

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

Consume adds items from an iterator of pairs to the current Pairs slice.

func (*Pairs[K, V]) ConsumeMap ¶

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

ConsumeMap adds all of the items in a map to the Pairs object.

func (*Pairs[K, V]) ConsumeSlice ¶

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

ConsumeSlice adds all the values in the input slice to the Pairs object, creating the keys using the function provide.

func (*Pairs[K, V]) ConsumeValues ¶

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

ConsumeValues adds all of the values in the input iterator, generating the keys using the function provided.

func (*Pairs[K, V]) Extend ¶

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

Extend adds the items from a Pairs object (slice of Pair) without modifying the donating object.

func (*Pairs[K, V]) Iterator ¶

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

Iterator return an iterator over each key-value pairs.

func (*Pairs[K, V]) Keys ¶

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

Keys returns an iterator over only the keys in a sequence of iterator items.

func (*Pairs[K, V]) Len ¶

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

Len returns the number of items in the pairs object.

func (*Pairs[K, V]) List ¶ added in v0.10.2

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

List returns the sequence of pairs as a list.

func (*Pairs[K, V]) Map ¶

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

Map converts a list of pairs to the equivalent map. If there are duplicate keys in the Pairs list, only the first occurrence of the key is retained.

func (*Pairs[K, V]) MarshalJSON ¶

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

MarshalJSON produces a JSON encoding for the Pairs object by first converting it to a map and then encoding that map as JSON. The JSON serialization does not necessarily preserve the order of the pairs object.

func (*Pairs[K, V]) Slice ¶

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

Slice creates a new slice of all the Pair objects.

func (*Pairs[K, V]) SortMerge ¶ added in v0.10.2

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

SortMerge performs a merge sort on the collected pairs.

func (*Pairs[K, V]) SortQuick ¶ added in v0.10.2

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

SortQuick does a quick sort using sort.Sort. Typically faster than SortMerge, but potentially more memory intensive for some types.

func (*Pairs[K, V]) UnmarshalJSON ¶

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

UnmarshalJSON provides consistent JSON decoding for Pairs objects. It reads a JSON document into a map and converts it to pairs, and appends it to the existing Pairs objects without removing or resetting the current object.

func (*Pairs[K, V]) Values ¶

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

Values returns an iterator over only the values in a sequence of iterator pairs.

func (*Set[T]) Add ¶

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

Add attempts to add the item to the mutex, and is a noop otherwise.

func (*Set[T]) AddCheck ¶

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

AddCheck adds an item to the set and returns true if the item had been in the set before AddCheck. In all cases when AddCheck returns, the item is a member of the set.

func (*Set[T]) Check ¶

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

Check returns true if the item is in the set.

func (*Set[T]) Delete ¶

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

Delete attempts to remove the item from the set.

func (*Set[T]) DeleteCheck ¶

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

DeleteCheck removes the item from the set, return true when the item had been in the Set, and returning false othewise

func (*Set[T]) Equal ¶

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

Equal tests two sets, returning true if the items in the sets have equal values. If the iterators are ordered, order is considered.

func (*Set[T]) Iterator ¶

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

Iterator provides a way to iterate over the items in the set. Provides items in iteration order if the set is ordered.

func (*Set[T]) Len ¶

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

Len returns the number of items tracked in the set.

func (*Set[T]) MarshalJSON ¶

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

MarshalJSON generates a JSON array of the items in the set.

func (*Set[T]) Order ¶

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

Order enables order tracking for the Set. The method panics if there is more than one item in the map. If order tracking is enabled, this operation is a noop. tracking is enabled,

func (*Set[T]) Populate ¶

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

Populate adds all items encountered in the iterator to the set.

func (*Set[T]) Producer ¶

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

Producer will produce each item from set on successive calls. If the Set is ordered, then the producer produces items in the set's order. If the Set is synchronize, then the Producer always holds the Set's lock when called.

func (*Set[T]) Synchronize ¶

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

Synchronize creates a mutex and enables its use in the Set. This operation is safe to call more than once,

func (*Set[T]) UnmarshalJSON ¶

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

UnmarshalJSON reads input JSON data, constructs an array in memory and then adds items from the array to existing set. Items that are in the set when UnmarshalJSON begins are not modified.

func (*Set[T]) WithLock ¶

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

WithLock configures the Set to synchronize operations with this mutex. If the mutex is nil, or the Set is already synchronized with a different mutex, WithLock panics with an invariant violation.

func (*Slice[T]) Add ¶

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

Add adds a single item to the end of the slice.

func (*Slice[T]) AddWhen ¶

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

AddWhen embeds a conditional check in the Add, and only adds the item to the slice when the condition is true.

func (*Slice[T]) Append ¶

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

Append adds all of the items to the end of the slice.

func (*Slice[T]) AppendWhen ¶

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

AppendWhen embeds a conditional check in the Append operation, and only adds the items to the slice when the condition is true.

func (Slice[T]) Cap ¶

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

Cap returns the capacity of the slice.

func (Slice[T]) Copy ¶

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

Copy performs a shallow copy of the Slice.

func (*Slice[T]) Empty ¶

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

Empty re-slices the slice, to omit all items, but retain the allocation.

func (*Slice[T]) Extend ¶

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

Extend adds the items from the input slice to the root slice.

func (*Slice[T]) ExtendWhen ¶

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

ExtendWhen embeds a conditional check in the Extend operatio and only adds the items to the slice when the condition is true.

func (*Slice[T]) Filter ¶

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

Filter returns a new slice, having passed all the items in the input slice. Items that the filter function returns true for are included and others are skipped.

func (*Slice[T]) FilterFuture ¶

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

FilterFuture returns a future that generates a new slice using the filter to select items from the root slice.

func (Slice[T]) IsEmpty ¶

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

IsEmpty returns true when there are no items in the slice (or it is nil.

func (Slice[T]) Item ¶

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

Item returns the item at the specified index.

If the provided index is not within the bounds of the slice the operation panics.

func (Slice[T]) Iterator ¶

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

Iterator returns an iterator to the items of the slice the range keyword also works for these slices.

func (Slice[T]) Last ¶

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

Last returns the index of the last element in the slice. Empty slices have `-1` last items.

func (Slice[T]) Len ¶

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

Len returns the length of the slice.

func (Slice[T]) Observe ¶

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

Observe calls the observer function on every item in the slice.

func (Slice[T]) Process ¶

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

Process creates a future in the form of a work that, when called iterates through all items in the slice, returning when the processor errors. io.EOF errors are not returned, but do abort iteration early, while fun.ErrIteratorSkip is respected.

func (Slice[T]) Ptr ¶ added in v0.10.2

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

Ptr provides a pointer to the item at the provided index.

func (Slice[T]) Ptrs ¶ added in v0.10.2

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

Ptrs converts a slice in to a slice of pointers to the values in the original slice

func (*Slice[T]) Reset ¶

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

Reset constructs a new empty slice releasing the original allocation.

func (*Slice[T]) Reslice ¶

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

Reslice modifies the slice to set the new start and end indexes.

Slicing operations, can lead to panics if the indexes are out of bounds.

func (*Slice[T]) ResliceBeginning ¶

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

ResliceBeginning moves the "beginning" of the slice to the specified index.

Slicing operations, can lead to panics if the indexes are out of bounds.

func (*Slice[T]) ResliceEnd ¶

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

ResliceEnd moves the "end" of the slice to the specified index.

Slicing operations, can lead to panics if the indexes are out of bounds.

func (Slice[T]) Sort ¶

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

Sort reorders the slice using the provided com parator function, which should return true if a is less than b and, false otherwise. The slice is sorted in "lowest" to "highest" order.

func (*Slice[T]) Truncate ¶

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

Truncate removes the last n items from the end of the list.

Slicing operations, can lead to panics if the indexes are out of bounds.

func (*Stack[T]) Append ¶

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

Append adds a variadic sequence of items to the list.

func (*Stack[T]) Head ¶

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

Head returns the item at the top of this stack. This is a non destructive operation.

func (*Stack[T]) Iterator ¶

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

Iterator returns a non-destructive iterator over the Items in a stack. Iterator will not observe new items added to the stack during iteration.

func (*Stack[T]) Len ¶

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

Len returns the length of the stack. Because stack's track their own size, this is an O(1) operation.

func (*Stack[T]) MarshalJSON ¶

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

MarshalJSON produces a JSON array representing the items in the stack. By supporting json.Marshaler and json.Unmarshaler, Items and stacks can behave as arrays in larger json objects, and can be as the output/input of json.Marshal and json.Unmarshal.

func (*Stack[T]) Pop ¶

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

Pop removes the item on the top of the stack, and returns it. If the stack is empty, this will return, but not detach, the root item of the stack, which will report a false Ok() value.

func (*Stack[T]) PopIterator ¶

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

PopIterator returns a destructive iterator over the Items in a stack. PopIterator will not observe new items added to the stack during iteration.

func (*Stack[T]) Producer ¶

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

func (*Stack[T]) ProducerPop ¶

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

func (*Stack[T]) Push ¶

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

Push appends an item to the stack.

func (*Stack[T]) UnmarshalJSON ¶

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

UnmarshalJSON reads json input and adds that to values in the stack. If there are items in the stack, they are not removed. By supporting json.Marshaler and json.Unmarshaler, Items and stacks can behave as arrays in larger json objects, and can be as the output/input of json.Marshal and json.Unmarshal.