map_

Documentation

Overview

Package map_ provides map processing helper functions

Index

• Variables
• func AppendKeys[M ~map[K]V, K comparable, V any](elements M, out []K) []K
• func AppendValues[M ~map[K]V, K comparable, V any](elements M, out []V) []V
• func Clone[M ~map[K]V, K comparable, V any](elements M) M
• func Contains[M ~map[K]V, K comparable, V any](m M, key K) (ok bool)
• func Conv[M ~map[K]V, K, Kto comparable, V, Vto any](elements M, converter func(K, V) (Kto, Vto, error)) (map[Kto]Vto, error)
• func Convert[M ~map[K]V, K, Kto comparable, V, Vto any](elements M, converter func(K, V) (Kto, Vto)) map[Kto]Vto
• func ConvertKeys[M ~map[K]V, K, Kto comparable, V any](elements M, converter func(K) Kto) map[Kto]V
• func ConvertValues[M ~map[K]V, V, Vto any, K comparable](elements M, converter func(V) Vto) map[K]Vto
• func DeepClone[M ~map[K]V, K comparable, V any](elements M, copier func(V) V) M
• func Empty[M ~map[K]V, K comparable, V any](val M) bool
• func Filter[M ~map[K]V, K comparable, V any](elements M, filter func(K, V) bool) map[K]V
• func FilterKeys[M ~map[K]V, K comparable, V any](elements M, filter func(K) bool) map[K]V
• func FilterValues[M ~map[K]V, K comparable, V any](elements M, filter func(V) bool) map[K]V
• func ForEachKey[M ~map[K]V, K comparable, V any](elements M, consumer func(K))
• func ForEachOrderedValues[M ~map[K]V, K comparable, V any](order []K, elements M, consumer func(V))
• func ForEachValue[M ~map[K]V, K comparable, V any](elements M, consumer func(V))
• func ForKeys[M ~map[K]V, K comparable, V any](elements M, consumer func(K) error) error
• func ForOrderedValues[M ~map[K]V, K comparable, V any](order []K, elements M, consumer func(V) error) error
• func ForValues[M ~map[K]V, K comparable, V any](elements M, consumer func(V) error) error
• func Generate[K comparable, V any](next func() (K, V, bool, error)) (map[K]V, error)
• func GenerateResolv[K comparable, V any](next func() (K, V, bool, error), resolv func(bool, K, V, V) V) (map[K]V, error)
• func Get[M ~map[K]V, K comparable, V any](m M, key K) V
• func GetOk[M ~map[K]V, K comparable, V any](m M, key K) (val V, ok bool)
• func Getter[M ~map[K]V, K comparable, V any](m M) func(key K) V
• func GetterOk[M ~map[K]V, K comparable, V any](m M) func(key K) (V, bool)
• func GroupOfLoop[S any, K comparable, V any](source S, hasNext func(S) bool, getNext func(S) (K, V, error)) (map[K][]V, error)
• func HasAny[M ~map[K]V, K comparable, V any](elements M, predicate func(K, V) bool) bool
• func KeyChecker[M ~map[K]V, K comparable, V any](m M) func(key K) (ok bool)
• func Keys[M ~map[K]V, K comparable, V any](elements M) []K
• func NotEmpty[M ~map[K]V, K comparable, V any](val M) bool
• func Of[K comparable, V any](elements ...c.KV[K, V]) map[K]V
• func OfLoop[S any, K comparable, V any](source S, hasNext func(S) bool, getNext func(S) (K, V, error)) (map[K]V, error)
• func OfLoopResolv[S any, K comparable, E, V any](source S, hasNext func(S) bool, getNext func(S) (K, E, error), ...) (map[K]V, error)
• func Reduce[M ~map[K]V, K comparable, V any](elements M, merge func(K, K, V, V) (K, V)) (rk K, rv V)
• func ToSlice[M ~map[K]V, K comparable, V any, T any](elements M, converter func(key K, val V) T) []T
• func ToSlicee[M ~map[K]V, K comparable, V any, T any](elements M, converter func(key K, val V) (T, error)) ([]T, error)
• func ToString[M ~map[K]V, K comparable, V any](elements M) string
• func ToStringOrdered[M ~map[K]V, K comparable, V any](order []K, elements M) string
• func ToStringOrderedf[M ~map[K]V, K comparable, V any](order []K, elements M, kvFormat, delim string) string
• func ToStringf[M ~map[K]V, K comparable, V any](elements M, kvFormat, delim string) string
• func Track[M ~map[K]V, K comparable, V any](elements M, consumer func(K, V) error) error
• func TrackEach[M ~map[K]V, K comparable, V any](elements M, consumer func(K, V))
• func TrackEachOrdered[M ~map[K]V, K comparable, V any](order []K, uniques M, consumer func(K, V))
• func TrackKeysWhile[M ~map[K]V, K comparable, V any](elements M, consumer func(K) bool)
• func TrackOrdered[M ~map[K]V, K comparable, V any](order []K, elements M, consumer func(K, V) error) error
• func TrackOrderedValuesWhile[M ~map[K]V, K comparable, V any](order []K, elements M, consumer func(V) bool)
• func TrackOrderedWhile[M ~map[K]V, K comparable, V any](order []K, elements M, consumer func(K, V) bool)
• func TrackValuesWhile[M ~map[K]V, K comparable, V any](elements M, consumer func(V) bool)
• func TrackWhile[M ~map[K]V, K comparable, V any](elements M, consumer func(K, V) bool)
• func Values[M ~map[K]V, K comparable, V any](elements M) []V
• func ValuesConverted[M ~map[K]V, K comparable, V, Vto any](elements M, by func(V) Vto) []Vto
• type Iter
  • func NewIter[K comparable, V any](elements map[K]V) Iter[K, V]
  • func (i *Iter[K, V]) All(consumer func(key K, value V) bool)
  • func (i *Iter[K, V]) Next() (key K, value V, ok bool)
  • func (i *Iter[K, V]) Size() int
  • func (i *Iter[K, V]) Track(traker func(key K, value V) error) error
  • func (i *Iter[K, V]) TrackEach(traker func(key K, value V))
• type KeyIter
  • func NewKeyIter[K comparable, V any](uniques map[K]V) KeyIter[K, V]
  • func (i KeyIter[K, V]) All(consumer func(element K) bool)
  • func (i KeyIter[K, V]) For(consumer func(element K) error) error
  • func (i KeyIter[K, V]) ForEach(consumer func(element K))
  • func (i KeyIter[K, V]) Next() (K, bool)
  • func (i KeyIter[K, V]) Size() int
• type ValIter
  • func NewValIter[K comparable, V any](uniques map[K]V) ValIter[K, V]
  • func (i ValIter[K, V]) All(consumer func(element V) bool)
  • func (i ValIter[K, V]) For(consumer func(element V) error) error
  • func (i ValIter[K, V]) ForEach(consumer func(element V))
  • func (i ValIter[K, V]) Next() (V, bool)
  • func (i ValIter[K, V]) Size() int

Variables

var Break = c.Break

Break is For, Track breaker

Functions

func AppendKeys

func AppendKeys[M ~map[K]V, K comparable, V any](elements M, out []K) []K

AppendKeys collects keys of the specified 'elements' map into the specified 'out' slice

func AppendValues

func AppendValues[M ~map[K]V, K comparable, V any](elements M, out []V) []V

AppendValues collects values of the specified 'elements' map into the specified 'out' slice

func Clone

func Clone[M ~map[K]V, K comparable, V any](elements M) M

Clone makes a copy of the 'elements' map. The values are copied as is.

func Contains

func Contains[M ~map[K]V, K comparable, V any](m M, key K) (ok bool)

Contains checks is the map contains a key

func Conv

func Conv[M ~map[K]V, K, Kto comparable, V, Vto any](elements M, converter func(K, V) (Kto, Vto, error)) (map[Kto]Vto, error)

Conv creates a map with converted keys and values

func Convert

func Convert[M ~map[K]V, K, Kto comparable, V, Vto any](elements M, converter func(K, V) (Kto, Vto)) map[Kto]Vto

Convert creates a map with converted keys and values

func ConvertKeys

func ConvertKeys[M ~map[K]V, K, Kto comparable, V any](elements M, converter func(K) Kto) map[Kto]V

ConvertKeys creates a map with converted keys

func ConvertValues

func ConvertValues[M ~map[K]V, V, Vto any, K comparable](elements M, converter func(V) Vto) map[K]Vto

ConvertValues creates a map with converted values

func DeepClone

func DeepClone[M ~map[K]V, K comparable, V any](elements M, copier func(V) V) M

DeepClone makes a copy of the 'elements' map. The values are copied by the 'copier' function

func Empty

func Empty[M ~map[K]V, K comparable, V any](val M) bool

Empty checks the val map is empty

func Filter

func Filter[M ~map[K]V, K comparable, V any](elements M, filter func(K, V) bool) map[K]V

Filter creates a map containing only the filtered elements

func FilterKeys

func FilterKeys[M ~map[K]V, K comparable, V any](elements M, filter func(K) bool) map[K]V

FilterKeys creates a map containing only the filtered elements

func FilterValues

func FilterValues[M ~map[K]V, K comparable, V any](elements M, filter func(V) bool) map[K]V

FilterValues creates a map containing only the filtered elements

func ForEachKey

func ForEachKey[M ~map[K]V, K comparable, V any](elements M, consumer func(K))

ForEachKey applies the 'consumer' function for every key from from the 'elements' map

func ForEachOrderedValues

func ForEachOrderedValues[M ~map[K]V, K comparable, V any](order []K, elements M, consumer func(V))

ForEachOrderedValues applies the 'consumer' function for each value from the 'elements' map in order of the 'order' slice

func ForEachValue

func ForEachValue[M ~map[K]V, K comparable, V any](elements M, consumer func(V))

ForEachValue applies the 'consumer' function for every value from from the 'elements' map

func ForKeys

func ForKeys[M ~map[K]V, K comparable, V any](elements M, consumer func(K) error) error

ForKeys applies the 'consumer' function for keys from the 'elements' map until the consumer returns the c.Break to stop.

func ForOrderedValues

func ForOrderedValues[M ~map[K]V, K comparable, V any](order []K, elements M, consumer func(V) error) error

ForOrderedValues applies the 'consumer' function for values from the 'elements' map in order of the 'order' slice until the consumer returns the c.Break to stop..

func ForValues

func ForValues[M ~map[K]V, K comparable, V any](elements M, consumer func(V) error) error

ForValues applies the 'consumer' function for values from the 'elements' map until the consumer returns the c.Break to stop..

func Generate

func Generate[K comparable, V any](next func() (K, V, bool, error)) (map[K]V, error)

Generate builds a map by an generator function. The next returns a key\value pair, or false if the generation is over, or an error.

func GenerateResolv

func GenerateResolv[K comparable, V any](next func() (K, V, bool, error), resolv func(bool, K, V, V) V) (map[K]V, error)

GenerateResolv builds a map by an generator function. The next returns a key\value pair, or false if the generation is over, or an error. The resolv selects value for duplicated keys.

func Get

func Get[M ~map[K]V, K comparable, V any](m M, key K) V

Get returns the value by the specified key from the map m or zero if the map doesn't contain that key

func GetOk

func GetOk[M ~map[K]V, K comparable, V any](m M, key K) (val V, ok bool)

GetOk returns the value, and true by the specified key from the map m or zero and false if the map doesn't contain that key

func Getter

func Getter[M ~map[K]V, K comparable, V any](m M) func(key K) V

Getter creates a function that can be used for retrieving a value from the map m by a key

func GetterOk

func GetterOk[M ~map[K]V, K comparable, V any](m M) func(key K) (V, bool)

GetterOk creates a function that can be used for retrieving a value from the map m by a key

func GroupOfLoop

func GroupOfLoop[S any, K comparable, V any](source S, hasNext func(S) bool, getNext func(S) (K, V, error)) (map[K][]V, error)

GroupOfLoop builds a map of slices by iterating over elements, extracting key\value pairs and grouping the values for each key in the slices. The hasNext specifies a predicate that tests existing of a next pair in the source. The getNext extracts the pair.

func HasAny

func HasAny[M ~map[K]V, K comparable, V any](elements M, predicate func(K, V) bool) bool

HasAny finds the first key/value pair that satisfies the 'predicate' function condition and returns true if successful

func KeyChecker

func KeyChecker[M ~map[K]V, K comparable, V any](m M) func(key K) (ok bool)

KeyChecker creates a function that can be used to check if the map contains a key

func Keys

func Keys[M ~map[K]V, K comparable, V any](elements M) []K

Keys returns keys of the 'elements' map as a slice

func NotEmpty

func NotEmpty[M ~map[K]V, K comparable, V any](val M) bool

NotEmpty checks the val map is not empty

func Of

func Of[K comparable, V any](elements ...c.KV[K, V]) map[K]V

Of instantiates a ap from the specified key/value pairs

func OfLoop

func OfLoop[S any, K comparable, V any](source S, hasNext func(S) bool, getNext func(S) (K, V, error)) (map[K]V, error)

OfLoop builds a map by iterating key\value pairs of a source. The hasNext specifies a predicate that tests existing of a next pair in the source. The getNext extracts the pair.

func OfLoopResolv

func OfLoopResolv[S any, K comparable, E, V any](source S, hasNext func(S) bool, getNext func(S) (K, E, error), resolv func(bool, K, V, E) V) (map[K]V, error)

OfLoopResolv builds a map by iterating elements of a source. The hasNext specifies a predicate that tests existing of a next pair in the source. The getNext extracts the element. The resolv values for duplicated keys.

func Reduce

func Reduce[M ~map[K]V, K comparable, V any](elements M, merge func(K, K, V, V) (K, V)) (rk K, rv V)

Reduce reduces the key/value pairs by the 'next' function into an one pair using the 'merge' function

func ToSlice

func ToSlice[M ~map[K]V, K comparable, V any, T any](elements M, converter func(key K, val V) T) []T

ToSlice collects key\value elements to a slice by applying the specified converter to evety element

func ToSlicee

func ToSlicee[M ~map[K]V, K comparable, V any, T any](elements M, converter func(key K, val V) (T, error)) ([]T, error)

ToSlicee collects key\value elements to a slice by applying the specified erroreable converter to evety element

func ToString

func ToString[M ~map[K]V, K comparable, V any](elements M) string

ToString converts elements to the string representation

func ToStringOrdered

func ToStringOrdered[M ~map[K]V, K comparable, V any](order []K, elements M) string

ToStringOrdered converts elements to the string representation according to the order

func ToStringOrderedf

func ToStringOrderedf[M ~map[K]V, K comparable, V any](order []K, elements M, kvFormat, delim string) string

ToStringOrderedf converts elements to a string representation using a key/value pair format and a delimeter. In order

func ToStringf

func ToStringf[M ~map[K]V, K comparable, V any](elements M, kvFormat, delim string) string

ToStringf converts elements to a string representation using a key/value pair format and a delimeter

func Track

func Track[M ~map[K]V, K comparable, V any](elements M, consumer func(K, V) error) error

Track applies the 'consumer' function for all key/value pairs until the consumer returns the c.Break to stop.

func TrackEach

func TrackEach[M ~map[K]V, K comparable, V any](elements M, consumer func(K, V))

TrackEach applies the 'consumer' function for every key/value pairs from the 'elements' map

func TrackEachOrdered

func TrackEachOrdered[M ~map[K]V, K comparable, V any](order []K, uniques M, consumer func(K, V))

TrackEachOrdered applies the 'consumer' function for evey key/value pair from the 'elements' map in order of the 'order' slice

func TrackKeysWhile

func TrackKeysWhile[M ~map[K]V, K comparable, V any](elements M, consumer func(K) bool)

TrackKeysWhile applies the 'consumer' function for every key from the 'elements' map until the consumer returns false.

func TrackOrdered

func TrackOrdered[M ~map[K]V, K comparable, V any](order []K, elements M, consumer func(K, V) error) error

TrackOrdered applies the 'consumer' function for key/value pairs from the 'elements' map in order of the 'order' slice until the consumer returns the c.Break to stop.

func TrackOrderedValuesWhile

func TrackOrderedValuesWhile[M ~map[K]V, K comparable, V any](order []K, elements M, consumer func(V) bool)

TrackOrderedValuesWhile applies the 'consumer' function for every value from the 'elements' map in order of the 'order' slice until the consumer returns false.

func TrackOrderedWhile

func TrackOrderedWhile[M ~map[K]V, K comparable, V any](order []K, elements M, consumer func(K, V) bool)

TrackOrderedWhile applies the 'consumer' function for every key/value pairs from the 'elements' map in order of the 'order' slice until the consumer returns false.

func TrackValuesWhile

func TrackValuesWhile[M ~map[K]V, K comparable, V any](elements M, consumer func(V) bool)

TrackValuesWhile applies the 'consumer' function for every value from the 'elements' map until the consumer returns false.

func TrackWhile

func TrackWhile[M ~map[K]V, K comparable, V any](elements M, consumer func(K, V) bool)

TrackWhile applies the 'consumer' function for every key/value pairs from the 'elements' map until the consumer returns false.

func Values

func Values[M ~map[K]V, K comparable, V any](elements M) []V

Values returns values of the 'elements' map as a slice

func ValuesConverted

func ValuesConverted[M ~map[K]V, K comparable, V, Vto any](elements M, by func(V) Vto) []Vto

ValuesConverted makes a slice of converted map values

Types

type Iter

type Iter[K comparable, V any] struct {
	// contains filtered or unexported fields
}

Iter is the embedded map based Iterator implementation

func NewIter

func NewIter[K comparable, V any](elements map[K]V) Iter[K, V]

NewIter returns the Iter based on map elements

func (*Iter[K, V]) All

func (i *Iter[K, V]) All(consumer func(key K, value V) bool)

All is used to iterate through the iterator using `for ... range`. Supported since go 1.22 with GOEXPERIMENT=rangefunc enabled.

func (*Iter[K, V]) Next

func (i *Iter[K, V]) Next() (key K, value V, ok bool)

Next returns the next element. The ok result indicates whether the element was returned by the iterator. If ok == false, then the iteration must be completed.

func (*Iter[K, V]) Size

func (i *Iter[K, V]) Size() int

Size returns the size of the map

func (*Iter[K, V]) Track

func (i *Iter[K, V]) Track(traker func(key K, value V) error) error

Track takes key, value pairs retrieved by the iterator. Can be interrupt by returning Break

func (*Iter[K, V]) TrackEach

func (i *Iter[K, V]) TrackEach(traker func(key K, value V))

TrackEach takes all key, value pairs retrieved by the iterator

type KeyIter

type KeyIter[K comparable, V any] struct {
	Iter[K, V]
}

KeyIter is the Iterator implementation that provides iterating over keys of a key/value pairs iterator

func NewKeyIter

func NewKeyIter[K comparable, V any](uniques map[K]V) KeyIter[K, V]

NewKeyIter instantiates a map keys iterator

func (KeyIter[K, V]) All

func (i KeyIter[K, V]) All(consumer func(element K) bool)

All is used to iterate through the iterator using `for ... range`. Supported since go 1.22 with GOEXPERIMENT=rangefunc enabled.

func (KeyIter[K, V]) For

func (i KeyIter[K, V]) For(consumer func(element K) error) error

For takes elements retrieved by the iterator. Can be interrupt by returning Break

func (KeyIter[K, V]) ForEach

func (i KeyIter[K, V]) ForEach(consumer func(element K))

ForEach FlatIter all elements retrieved by the iterator

func (KeyIter[K, V]) Next

func (i KeyIter[K, V]) Next() (K, bool)

Next returns the next element. The ok result indicates whether the element was returned by the iterator. If ok == false, then the iteration must be completed.

func (KeyIter[K, V]) Size

func (i KeyIter[K, V]) Size() int

Size returns the iterator capacity

type ValIter

type ValIter[K comparable, V any] struct {
	Iter[K, V]
}

ValIter is a map values iterator

func NewValIter

func NewValIter[K comparable, V any](uniques map[K]V) ValIter[K, V]

NewValIter is the main values iterator constructor

func (ValIter[K, V]) All

func (i ValIter[K, V]) All(consumer func(element V) bool)

All is used to iterate through the iterator using `for ... range`. Supported since go 1.22 with GOEXPERIMENT=rangefunc enabled.

func (ValIter[K, V]) For

func (i ValIter[K, V]) For(consumer func(element V) error) error

For takes elements retrieved by the iterator. Can be interrupt by returning Break

func (ValIter[K, V]) ForEach

func (i ValIter[K, V]) ForEach(consumer func(element V))

ForEach FlatIter all elements retrieved by the iterator

func (ValIter[K, V]) Next

func (i ValIter[K, V]) Next() (V, bool)

Next returns the next element. The ok result indicates whether the element was returned by the iterator. If ok == false, then the iteration must be completed.

func (ValIter[K, V]) Size

func (i ValIter[K, V]) Size() int

Size returns the size of the map