record

package
v1.0.16 Latest Latest
Warning

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

 Go to latest Published: Aug 10, 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

Copyright (c) 2023 IBM Corp. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

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 := FoldMap[string, string](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[K comparable, V any](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 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.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.