record

package
v1.0.26 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 8, 2023 License: Apache-2.0 Imports: 9 Imported by: 12

Documentation

Overview

Package record contains monadic operations for maps as well as a rich set of utility functions

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Chain added in v1.0.15

func Chain[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2]) func(func(V1) map[K]V2) func(map[K]V1) map[K]V2

func ChainWithIndex added in v1.0.15

func ChainWithIndex[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2]) func(func(K, V1) map[K]V2) func(map[K]V1) map[K]V2

func Collect

func Collect[K comparable, V, R any](f func(K, V) R) func(map[K]V) []R

Collect applies a collector function to the key value pairs in a map and returns the result as an array

func ConstNil

func ConstNil[K comparable, V any]() map[K]V

ConstNil return a nil map

func DeleteAt

func DeleteAt[K comparable, V any](k K) func(map[K]V) map[K]V

func Empty

func Empty[K comparable, V any]() map[K]V

Empty creates an empty map

func Eq

func Eq[K comparable, V any](e E.Eq[V]) E.Eq[map[K]V]

func Filter

func Filter[K comparable, V any](f func(K) bool) func(map[K]V) map[K]V

Filter creates a new map with only the elements that match the predicate

func FilterChain added in v1.0.15

func FilterChain[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2]) func(func(V1) O.Option[map[K]V2]) func(map[K]V1) map[K]V2

FilterChain creates a new map with only the elements for which the transformation function creates a Some

func FilterChainWithIndex added in v1.0.15

func FilterChainWithIndex[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2]) func(func(K, V1) O.Option[map[K]V2]) func(map[K]V1) map[K]V2

FilterChainWithIndex creates a new map with only the elements for which the transformation function creates a Some

func FilterMap

func FilterMap[K comparable, V1, V2 any](f func(V1) O.Option[V2]) func(map[K]V1) map[K]V2

FilterMap creates a new map with only the elements for which the transformation function creates a Some

func FilterMapWithIndex

func FilterMapWithIndex[K comparable, V1, V2 any](f func(K, V1) O.Option[V2]) func(map[K]V1) map[K]V2

FilterMapWithIndex creates a new map with only the elements for which the transformation function creates a Some

func FilterWithIndex

func FilterWithIndex[K comparable, V any](f func(K, V) bool) func(map[K]V) map[K]V

FilterWithIndex creates a new map with only the elements that match the predicate

func Flatten added in v1.0.15

func Flatten[K comparable, V any](m Mo.Monoid[map[K]V]) func(map[K]map[K]V) map[K]V

Flatten converts a nested map into a regular map

func Fold added in v1.0.16

func Fold[K comparable, A any](m Mo.Monoid[A]) func(map[K]A) A

Fold folds the record using the provided Monoid.

func FoldMap added in v1.0.16

func FoldMap[K comparable, A, B any](m Mo.Monoid[B]) func(func(A) B) func(map[K]A) B

FoldMap maps and folds a record. Map the record passing each value to the iterating function. Then fold the results using the provided Monoid.

Example
src := map[string]string{
	"a": "a",
	"b": "b",
	"c": "c",
}

fold := FoldMapOrd[string, string](S.Ord)(S.Monoid)(strings.ToUpper)

fmt.Println(fold(src))
Output:

ABC

func FoldMapOrd added in v1.0.16

func FoldMapOrd[A, B any, K comparable](o ord.Ord[K]) func(m Mo.Monoid[B]) func(func(A) B) func(map[K]A) B

FoldMap maps and folds a record. Map the record passing each value to the iterating function. Then fold the results using the provided Monoid and the items in the provided order

func FoldMapOrdWithIndex added in v1.0.16

func FoldMapOrdWithIndex[K comparable, A, B any](o ord.Ord[K]) func(m Mo.Monoid[B]) func(func(K, A) B) func(map[K]A) B

FoldMapWithIndex maps and folds a record. Map the record passing each value to the iterating function. Then fold the results using the provided Monoid and the items in the provided order

func FoldMapWithIndex added in v1.0.16

func FoldMapWithIndex[K comparable, A, B any](m Mo.Monoid[B]) func(func(K, A) B) func(map[K]A) B

FoldMapWithIndex maps and folds a record. Map the record passing each value to the iterating function. Then fold the results using the provided Monoid.

func FoldOrd added in v1.0.16

func FoldOrd[A any, K comparable](o ord.Ord[K]) func(m Mo.Monoid[A]) func(map[K]A) A

Fold folds the record using the provided Monoid with the items passed in the given order

func FromEntries

func FromEntries[K comparable, V any](fa []T.Tuple2[K, V]) map[K]V

func Has

func Has[K comparable, V any](k K, r map[K]V) bool

Has tests if a key is contained in a map

func IsEmpty

func IsEmpty[K comparable, V any](r map[K]V) bool

IsEmpty tests if a map is empty

func IsNil

func IsNil[K comparable, V any](m map[K]V) bool

IsNil checks if the map is set to nil

func IsNonEmpty

func IsNonEmpty[K comparable, V any](r map[K]V) bool

IsNonEmpty tests if a map is not empty

func IsNonNil

func IsNonNil[K comparable, V any](m map[K]V) bool

IsNonNil checks if the map is set to nil

func Keys

func Keys[K comparable, V any](r map[K]V) []K

Keys returns the key in a map

func KeysOrd added in v1.0.16

func KeysOrd[V any, K comparable](o ord.Ord[K]) func(r map[K]V) []K

KeysOrd returns the keys in the map in their given order

func Lookup

func Lookup[V any, K comparable](k K) func(map[K]V) O.Option[V]

Lookup returns the entry for a key in a map if it exists

func Map

func Map[K comparable, V, R any](f func(V) R) func(map[K]V) map[K]R

func MapRef

func MapRef[K comparable, V, R any](f func(*V) R) func(map[K]V) map[K]R

func MapRefWithIndex

func MapRefWithIndex[K comparable, V, R any](f func(K, *V) R) func(map[K]V) map[K]R

func MapWithIndex

func MapWithIndex[K comparable, V, R any](f func(K, V) R) func(map[K]V) map[K]R

func Merge added in v1.0.15

func Merge[K comparable, V any](right map[K]V) func(map[K]V) map[K]V

Merge combines two maps giving the values in the right one precedence. Also refer to MergeMonoid

func MergeMonoid added in v1.0.15

func MergeMonoid[K comparable, V any]() M.Monoid[map[K]V]

MergeMonoid computes the union of two maps of the same type giving the last map precedence

func MonadChain added in v1.0.15

func MonadChain[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2], r map[K]V1, f func(V1) map[K]V2) map[K]V2

func MonadChainWithIndex added in v1.0.15

func MonadChainWithIndex[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2], r map[K]V1, f func(K, V1) map[K]V2) map[K]V2

func MonadLookup added in v1.0.24

func MonadLookup[V any, K comparable](m map[K]V, k K) O.Option[V]

MonadLookup returns the entry for a key in a map if it exists

func MonadMap

func MonadMap[K comparable, V, R any](r map[K]V, f func(V) R) map[K]R

func MonadMapRef

func MonadMapRef[K comparable, V, R any](r map[K]V, f func(*V) R) map[K]R

func MonadMapRefWithIndex

func MonadMapRefWithIndex[K comparable, V, R any](r map[K]V, f func(K, *V) R) map[K]R

func MonadMapWithIndex

func MonadMapWithIndex[K comparable, V, R any](r map[K]V, f func(K, V) R) map[K]R

func Reduce

func Reduce[K comparable, V, R any](f func(R, V) R, initial R) func(map[K]V) R

func ReduceOrd added in v1.0.16

func ReduceOrd[V, R any, K comparable](o ord.Ord[K]) func(func(R, V) R, R) func(map[K]V) R

ReduceOrd reduces a map into a single value via a reducer function making sure that the keys are passed to the reducer in the specified order

func ReduceOrdWithIndex added in v1.0.16

func ReduceOrdWithIndex[V, R any, K comparable](o ord.Ord[K]) func(func(K, R, V) R, R) func(map[K]V) R

ReduceOrdWithIndex reduces a map into a single value via a reducer function making sure that the keys are passed to the reducer in the specified order

func ReduceRef

func ReduceRef[K comparable, V, R any](f func(R, *V) R, initial R) func(map[K]V) R

func ReduceRefWithIndex

func ReduceRefWithIndex[K comparable, V, R any](f func(K, R, *V) R, initial R) func(map[K]V) R

func ReduceWithIndex

func ReduceWithIndex[K comparable, V, R any](f func(K, R, V) R, initial R) func(map[K]V) R

func Sequence

func Sequence[K comparable, A, HKTA, HKTAA, HKTRA any](
	fof func(map[K]A) HKTRA,
	fmap func(func(map[K]A) func(A) map[K]A) func(HKTRA) HKTAA,
	fap func(HKTA) func(HKTAA) HKTRA,
	ma map[K]HKTA) HKTRA

HKTA = HKT[A] HKTAA = HKT[func(A)map[K]A] HKTRA = HKT[map[K]A]

func Singleton

func Singleton[K comparable, V any](k K, v V) map[K]V

Singleton creates a new map with a single entry

func Size

func Size[K comparable, V any](r map[K]V) int

Size returns the number of elements in a map

func ToArray

func ToArray[K comparable, V any](r map[K]V) []T.Tuple2[K, V]

func ToEntries

func ToEntries[K comparable, V any](r map[K]V) []T.Tuple2[K, V]

func Traverse

func Traverse[K comparable, A, B, HKTB, HKTAB, HKTRB any](
	fof func(map[K]B) HKTRB,
	fmap func(func(map[K]B) func(B) map[K]B) func(HKTRB) HKTAB,
	fap func(HKTB) func(HKTAB) HKTRB,
	f func(A) HKTB) func(map[K]A) HKTRB

HKTA = HKT<A> HKTB = HKT<B> HKTAB = HKT<func(A)B> HKTRB = HKT<map[K]B>

func TraverseWithIndex

func TraverseWithIndex[K comparable, A, B, HKTB, HKTAB, HKTRB any](
	fof func(map[K]B) HKTRB,
	fmap func(func(map[K]B) func(B) map[K]B) func(HKTRB) HKTAB,
	fap func(HKTB) func(HKTAB) HKTRB,

	f func(K, A) HKTB) func(map[K]A) HKTRB

func Union

func Union[K comparable, V any](m Mg.Magma[V]) func(map[K]V) func(map[K]V) map[K]V

func UnionFirstMonoid added in v1.0.15

func UnionFirstMonoid[K comparable, V any]() M.Monoid[map[K]V]

UnionFirstMonoid computes the union of two maps of the same type giving the first map precedence

func UnionFirstSemigroup added in v1.0.15

func UnionFirstSemigroup[K comparable, V any]() S.Semigroup[map[K]V]

func UnionLastMonoid added in v1.0.15

func UnionLastMonoid[K comparable, V any]() M.Monoid[map[K]V]

UnionLastMonoid computes the union of two maps of the same type giving the last map precedence

func UnionLastSemigroup added in v1.0.15

func UnionLastSemigroup[K comparable, V any]() S.Semigroup[map[K]V]

func UnionMonoid

func UnionMonoid[K comparable, V any](s S.Semigroup[V]) M.Monoid[map[K]V]

UnionMonoid computes the union of two maps of the same type

func UnionSemigroup

func UnionSemigroup[K comparable, V any](s S.Semigroup[V]) S.Semigroup[map[K]V]

func UpsertAt

func UpsertAt[K comparable, V any](k K, v V) func(map[K]V) map[K]V

func Values

func Values[K comparable, V any](r map[K]V) []V

Values returns the values in a map

func ValuesOrd added in v1.0.16

func ValuesOrd[V any, K comparable](o ord.Ord[K]) func(r map[K]V) []V

ValuesOrd returns the values in the map ordered by their keys in the given order

Example
src := map[string]string{
	"c": "a",
	"b": "b",
	"a": "c",
}

getValues := ValuesOrd[string](S.Ord)

fmt.Println(getValues(src))
Output:

[c b a]

Types

This section is empty.

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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