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]) 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])

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]) Populate ¶ added in v0.10.4

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

Populate returns a worker that adds items from the iterator to the list. Any error returned is either a context cancellation error or the result of a panic in the input iterator. The close method on the input iterator is not called.

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]) Slice ¶ added in v0.10.3

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

Slice exports the contents of the list to a slice.

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 holding K and V objects to the map.

func (Map[K, V]) AddTuple ¶ added in v0.10.5

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

AddTuple adds a Tuple of K and V objects 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]) 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]) ConsumePairs ¶ added in v0.10.5

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

ConsumePairs adds items to the map from a Pairs object. Existing values for K are always overwritten.

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]) ConsumeTuples ¶ added in v0.10.5

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

ConsumeTuples adds items to the map from a Tuples object. Existing values for K are always overwritten.

func (Map[K, V]) ConsumeValues ¶

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

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]) Delete ¶ added in v0.10.8

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

Delete removes a key from the map.

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 Pairs object, containing the contents of the map.

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]) Tuples ¶ added in v0.10.5

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

Tupes exports a map a Pairs object, containing the contents of the map.

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 (*Optional[T]) Default ¶ added in v0.10.5

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

Default sets value of the optional to the provided value if it is not already been defined.

func (*Optional[T]) DefaultFuture ¶ added in v0.10.5

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

DefaultFuture resolves the future if the optional has not yet been set.

func (*Optional[T]) Future ¶ added in v0.10.5

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

Future provides access to the value of the optional as a Future function. This does not disambiguate zero values. Use in conjunction with Optional.Handler and adt.AccessorsWithLock and adt.AccessorsWithReadLock to handle concurency control.

func (*Optional[T]) Get ¶ added in v0.10.5

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

Get returns the current value of the optional and the ok value. Use this to disambiguate zero values.

func (*Optional[T]) Handler ¶ added in v0.10.5

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

Handler provides access to setting the optional value as fun.Handler function. Use in conjunction with Optional.Future and adt.AccessorsWithLock and adt.AccessorsWithReadLock to handle concurency control.

func (Optional[T]) MarshalBinary ¶ added in v0.10.5

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

MarshalBinary supports marshaling optional values into binary formats and uses the value of the optional to dictate behavior. The underlying value must implement encoding.BinaryMarshaler, bson.Marshaler or a generic Marshal() interface. byte slices are passed through.

func (Optional[T]) MarshalText ¶ added in v0.10.5

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

MarshalText defines how to marshal the optional value in text-based contexts. In most cases it falls back on the value of the optional: using encoding.TextMarshaler, json.Marshaler, yaml.Marahaler, or a generic Marshal() ([]byte,error) interface are called. Strings and []byte values are through directly, and failing all of these options, this falls back to json.Marshal().

func (Optional[T]) Ok ¶ added in v0.10.9

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

Ok returns true when the optional

func (*Optional[T]) Reset ¶ added in v0.10.5

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

Reset unsets the OK value of the optional, and unsets the reference to the existing value.

func (*Optional[T]) Resolve ¶ added in v0.10.5

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

Resolve returns the current value of the optional. Zero values of T are ambiguous.

func (*Optional[T]) Scan ¶ added in v0.10.5

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

Scan implements the sql Scanner interface. This is invalid if the type of the optional value is not a primitive value type.

func (*Optional[T]) Set ¶ added in v0.10.5

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

Set marks the optional value as defined, and sets the optional value. You can set an optional to the zero value for type T. To "unset" a value use the Reset().

func (*Optional[T]) SetWhen ¶ added in v0.10.5

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

Set changes the value of the, only when the boolean cond value is positive.

func (*Optional[T]) SetWhenFuture ¶ added in v0.10.5

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

SetWhenFuture resolves the future only when

func (*Optional[T]) Swap ¶ added in v0.10.5

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

Swap returns the previous value of the optional and replaces it with the provided value

func (*Optional[T]) UnmarshalBinary ¶ added in v0.10.5

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

UnmarshalBinary provides a compliment to MarshalBinary, and serves as a passthrough for encoding.BinaryUnmarshaler, bson.Unmarshaler and the generic Unmarshal interface.

func (*Optional[T]) UnmarshalText ¶ added in v0.10.5

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

UnmarshalText provides an inverse version of MarshalText for the encoding.UnmarshalText interface. encoding.TextUnmarshaler, json.Unmarshaler, yaml.Unmarshaler, and a generic Unmarshler interface. Strings and bytes slices pass through directly, and json.Unmarshal() is used in all other situations.

func (Optional[T]) Value ¶ added in v0.10.5

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

Value implements the SQL driver.Valuer interface. Scan implements the sql Scanner interface. This is invalid if the type of the optional value is not a primitive value type.

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. The return value is provided to support chaining Add() operations

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

func (p *Pairs[K, V]) Append(new ...Pair[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(iter *fun.Iterator[Pair[K, V]]) fun.Worker

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)

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)

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(iter *fun.Iterator[V], keyf func(V) K) fun.Worker

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

func (*Pairs[K, V]) Copy ¶ added in v0.10.3

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

Copy produces a new Pairs object with the same values.

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]) Observe ¶ added in v0.10.3

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

Observe calls the handler function for every pair in the container.

func (*Pairs[K, V]) Process ¶ added in v0.10.3

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

Process returns a worker, that when executed calls the processor function for every pair in the container.

func (*Pairs[K, V]) Push ¶ added in v0.10.5

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

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

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.StableSort. 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]) Extend ¶ added in v0.10.3

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

Extend adds the items of one set to this set.

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.

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]) SortMerge ¶ added in v0.10.4

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

SortMerge sorts the elements in an ordered set using a merge sort algorithm. If the set is not ordered, it will become ordered. Unlike the Order() method, you can use this method on a populated but unordered set.

func (*Set[T]) SortQuick ¶ added in v0.10.4

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

SortQuick sorts the elements in the set using sort.StableSort. Typically faster than SortMerge, but potentially more memory intensive for some types. If the set is not ordered, it will become ordered. Unlike the Order() method, you can use this method on a populated but unordered set.

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]) FillTo ¶ added in v0.10.5

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

FillTo appends zero values to the slice until it reaches the specified length, and returns the resulting slice.

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]) Grow ¶ added in v0.10.4

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

Grow adds zero items to the slice until it reaches the desired size.

func (*Slice[T]) GrowCapacity ¶ added in v0.10.5

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

GrowCapacity extends the capacity of the slice (by adding zero items and the )

func (Slice[T]) Index ¶ added in v0.10.4

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

Index 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]) 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]) 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]) Populate ¶ added in v0.10.3

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

Populate constructs an operation that adds all items from the iterator to the slice.

func (*Slice[T]) Prepend ¶ added in v0.10.4

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

Prepend adds the items to beginning of 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]) Sparse ¶ added in v0.10.5

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

Sparse always returns a new slice. It iterates through the elements in the source slice and checks, using ft.IsNil() (which uses reflection), if the value is nil, and only adds the item when it is not-nil.

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 (Slice[T]) Zero ¶ added in v0.10.5

func (s Slice[T]) Zero()

Zero replaces all items in the slice with the zero value for the type T.

func (Slice[T]) ZeroRange ¶ added in v0.10.5

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

ZeroRange replaces values between the specified indexes (inclusive) with the zero value of the type. If the indexes provided are outside of the bounds of the slice, an invariant violation panic is raised.

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]) Populate ¶ added in v0.10.4

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

Populate returns a worker that adds items from the iterator to the stack. Any error returned is either a context cancellation error or the result of a panic in the input iterator. The close method on the input iterator is not called.

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.

func (Tuple[K, V]) MarshalJSON ¶ added in v0.10.5

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

func (*Tuple[K, V]) UnmarshalJSON ¶ added in v0.10.5

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

func (*Tuples[K, V]) Add ¶ added in v0.10.5

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

Add adds a new value to the underlying slice. This may add a duplicate key. The return value is provided to support chaining Add() operations

func (*Tuples[K, V]) Append ¶ added in v0.10.5

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

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

func (*Tuples[K, V]) Consume ¶ added in v0.10.5

func (p *Tuples[K, V]) Consume(iter *fun.Iterator[Tuple[K, V]]) fun.Worker

Consume adds items from an iterator of tuples to the current Tuples slice.

func (*Tuples[K, V]) Copy ¶ added in v0.10.5

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

Copy produces a new Tuples object with the same values.

func (*Tuples[K, V]) Extend ¶ added in v0.10.5

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

Extend adds the items from a Tuples object (slice of Tuple) without modifying the donating object.

func (*Tuples[K, V]) Iterator ¶ added in v0.10.5

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

Iterator return an iterator over each key-value tuples.

func (*Tuples[K, V]) Len ¶ added in v0.10.5

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

Len returns the number of items in the tuples object.

func (*Tuples[K, V]) List ¶ added in v0.10.5

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

List returns the sequence of tuples as a list.

func (*Tuples[K, V]) MarshalJSON ¶ added in v0.10.5

func (p *Tuples[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 (*Tuples[K, V]) Observe ¶ added in v0.10.5

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

Observe calls the handler function for every tuple in the container.

func (*Tuples[K, V]) Ones ¶ added in v0.10.5

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

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

func (*Tuples[K, V]) Process ¶ added in v0.10.5

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

Process returns a worker, that when executed calls the processor function for every tuple in the container.

func (*Tuples[K, V]) Push ¶ added in v0.10.5

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

Push adds a single tuple to the slice of tuples. This may add a duplicate key.

func (*Tuples[K, V]) Slice ¶ added in v0.10.5

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

Slice creates a new slice of all the Tuple objects.

func (*Tuples[K, V]) SortMerge ¶ added in v0.10.5

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

SortMerge performs a merge sort on the collected tuples.

func (*Tuples[K, V]) SortQuick ¶ added in v0.10.5

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

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

func (*Tuples[K, V]) Twos ¶ added in v0.10.5

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

Twos returns an iterator over only the values in a sequence of iterator tuples.

func (*Tuples[K, V]) UnmarshalJSON ¶ added in v0.10.5

func (p *Tuples[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.