record

package

v1.0.15 Latest Latest Go to latest Published: Aug 10, 2023 License: Apache-2.0 Imports: 8 Imported by: 12

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/IBM/fp-go

Links

Open Source Insights

Documentation ¶

Overview ¶

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

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 ¶

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[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[K comparable, V, R any](f func(K, V) R) func(map[K]V) []R
func ConstNil[K comparable, V any]() map[K]V
func DeleteAt[K comparable, V any](k K) func(map[K]V) map[K]V
func Empty[K comparable, V any]() map[K]V
func Eq[K comparable, V any](e E.Eq[V]) E.Eq[map[K]V]
func Filter[K comparable, V any](f func(K) bool) func(map[K]V) map[K]V
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
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
func FilterMap[K comparable, V1, V2 any](f func(V1) O.Option[V2]) func(map[K]V1) map[K]V2
func FilterMapWithIndex[K comparable, V1, V2 any](f func(K, V1) O.Option[V2]) func(map[K]V1) map[K]V2
func FilterWithIndex[K comparable, V any](f func(K, V) bool) func(map[K]V) map[K]V
func Flatten[K comparable, V any](m Mo.Monoid[map[K]V]) func(map[K]map[K]V) map[K]V
func FromEntries[K comparable, V any](fa []T.Tuple2[K, V]) map[K]V
func Has[K comparable, V any](k K, r map[K]V) bool
func IsEmpty[K comparable, V any](r map[K]V) bool
func IsNil[K comparable, V any](m map[K]V) bool
func IsNonEmpty[K comparable, V any](r map[K]V) bool
func IsNonNil[K comparable, V any](m map[K]V) bool
func Keys[K comparable, V any](r map[K]V) []K
func Lookup[K comparable, V any](k K) func(map[K]V) O.Option[V]
func Map[K comparable, V, R any](f func(V) R) func(map[K]V) map[K]R
func MapRef[K comparable, V, R any](f func(*V) R) func(map[K]V) map[K]R
func MapRefWithIndex[K comparable, V, R any](f func(K, *V) R) func(map[K]V) map[K]R
func MapWithIndex[K comparable, V, R any](f func(K, V) R) func(map[K]V) map[K]R
func Merge[K comparable, V any](right map[K]V) func(map[K]V) map[K]V
func MergeMonoid[K comparable, V any]() M.Monoid[map[K]V]
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[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[K comparable, V, R any](r map[K]V, f func(V) R) map[K]R
func MonadMapRef[K comparable, V, R any](r map[K]V, f func(*V) R) map[K]R
func MonadMapRefWithIndex[K comparable, V, R any](r map[K]V, f func(K, *V) R) map[K]R
func MonadMapWithIndex[K comparable, V, R any](r map[K]V, f func(K, V) R) map[K]R
func Reduce[K comparable, V, R any](f func(R, V) R, initial R) func(map[K]V) R
func ReduceRef[K comparable, V, R any](f func(R, *V) R, initial R) func(map[K]V) R
func ReduceRefWithIndex[K comparable, V, R any](f func(K, R, *V) R, initial R) func(map[K]V) R
func ReduceWithIndex[K comparable, V, R any](f func(K, R, V) R, initial R) func(map[K]V) R
func Sequence[K comparable, A, HKTA, HKTAA, HKTRA any](fof func(map[K]A) HKTRA, ...) HKTRA
func Singleton[K comparable, V any](k K, v V) map[K]V
func Size[K comparable, V any](r map[K]V) int
func ToArray[K comparable, V any](r map[K]V) []T.Tuple2[K, V]
func ToEntries[K comparable, V any](r map[K]V) []T.Tuple2[K, V]
func Traverse[K comparable, A, B, HKTB, HKTAB, HKTRB any](fof func(map[K]B) HKTRB, ...) func(map[K]A) HKTRB
func TraverseWithIndex[K comparable, A, B, HKTB, HKTAB, HKTRB any](fof func(map[K]B) HKTRB, ...) func(map[K]A) HKTRB
func Union[K comparable, V any](m Mg.Magma[V]) func(map[K]V) func(map[K]V) map[K]V
func UnionFirstMonoid[K comparable, V any]() M.Monoid[map[K]V]
func UnionFirstSemigroup[K comparable, V any]() S.Semigroup[map[K]V]
func UnionLastMonoid[K comparable, V any]() M.Monoid[map[K]V]
func UnionLastSemigroup[K comparable, V any]() S.Semigroup[map[K]V]
func UnionMonoid[K comparable, V any](s S.Semigroup[V]) M.Monoid[map[K]V]
func UnionSemigroup[K comparable, V any](s S.Semigroup[V]) S.Semigroup[map[K]V]
func UpsertAt[K comparable, V any](k K, v V) func(map[K]V) map[K]V
func Values[K comparable, V any](r map[K]V) []V

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

Types ¶

This section is empty.

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
generic

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