record

package
v2.0.1 Latest Latest
Warning

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

 Go to latest Published: Dec 18, 2025 License: Apache-2.0 Imports: 11 Imported by: 0

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 Ap 

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

Ap returns a function that applies a map of functions to a map of values, combining results using the provided Monoid

func ApS 

func ApS[S1, T any, K comparable, S2 any](m Mo.Monoid[map[K]S2]) func(setter func(T) func(S1) S2, fa map[K]T) func(map[K]S1) map[K]S2

ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently (using Applicative rather than Monad). This allows independent computations to be combined without one depending on the result of the other.

Unlike Bind, which sequences operations, ApS can be used when operations are independent and can conceptually run in parallel.

Example: 

type State struct {
    Name  string
    Count int
}

// These operations are independent and can be combined with ApS
names := map[string]string{"a": "Alice", "b": "Bob"}
counts := map[string]int{"a": 10, "b": 20}

result := F.Pipe2(
    record.Do[string, State](),
    record.ApS(monoid.Record[string, State]())(
        func(name string) func(State) State {
            return func(s State) State { s.Name = name; return s }
        },
        names,
    ),
    record.ApS(monoid.Record[string, State]())(
        func(count int) func(State) State {
            return func(s State) State { s.Count = count; return s }
        },
        counts,
    ),
) // map[string]State{"a": {Name: "Alice", Count: 10}, "b": {Name: "Bob", Count: 20}}

func Bind 

func Bind[S1, T any, K comparable, S2 any](m Mo.Monoid[map[K]S2]) func(setter func(T) func(S1) S2, f func(S1) map[K]T) func(map[K]S1) map[K]S2

Bind attaches the result of a computation to a context [S1] to produce a context [S2]. This enables sequential composition where each step can depend on the results of previous steps. For records, this merges values by key.

The setter function takes the result of the computation and returns a function that updates the context from S1 to S2.

Example: 

type State struct {
    Name  string
    Count int
}

result := F.Pipe2(
    record.Do[string, State](),
    record.Bind(monoid.Record[string, State]())(
        func(name string) func(State) State {
            return func(s State) State { s.Name = name; return s }
        },
        func(s State) map[string]string {
            return map[string]string{"a": "Alice", "b": "Bob"}
        },
    ),
    record.Bind(monoid.Record[string, State]())(
        func(count int) func(State) State {
            return func(s State) State { s.Count = count; return s }
        },
        func(s State) map[string]int {
            // This can access s.Name from the previous step
            return map[string]int{"a": len(s.Name), "b": len(s.Name) * 2}
        },
    ),
)

func BindTo 

func BindTo[S1, T any, K comparable](setter func(T) S1) func(map[K]T) map[K]S1

BindTo initializes a new state [S1] from a value [T]

func Chain 

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

Chain returns a function that chains a map transformation function that produces maps, combining results using the provided Monoid

func ChainWithIndex 

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

ChainWithIndex returns a function that chains a map transformation function that produces maps, combining results using the provided Monoid

func Clone 

func Clone[K comparable, V any](f EM.Endomorphism[V]) EM.Endomorphism[map[K]V]

Clone creates a deep copy of the map using the provided endomorphism to clone the values

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 CollectOrd 

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

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

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

Copy creates a shallow copy of the map

func Do 

func Do[K comparable, S any]() map[K]S

Do creates an empty context of type [S] to be used with the Bind operation. This is the starting point for do-notation style composition.

Example: 

type State struct {
    Name  string
    Count int
}
result := record.Do[string, State]()

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 FilterChain 

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

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

func FilterChainWithIndex 

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

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

func Flap 

func Flap[B any, K comparable, A any](a A) func(map[K]func(A) B) map[K]B

Flap returns a function that applies a value to a map of functions, producing a map of results

func Flatten 

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 

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 

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 

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 

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 

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 

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 FromArray 

func FromArray[
	K comparable,
	V any](m Mg.Magma[V]) func(fa Entries[K, V]) map[K]V

FromArray converts from an array to a map Duplicate keys are resolved by the provided [Mg.Magma]

func FromArrayMap 

func FromArrayMap[
	A any,
	K comparable,
	V any](m Mg.Magma[V]) func(f func(A) Entry[K, V]) func(fa []A) map[K]V

FromArrayMap converts from an array to a map Duplicate keys are resolved by the provided [Mg.Magma]

func FromEntries 

func FromEntries[K comparable, V any](fa Entries[K, V]) map[K]V

FromEntries creates a map from an array of key-value pairs

func FromFoldable 

func FromFoldable[
	HKTA any,
	FOLDABLE ~func(func(map[K]V, Entry[K, V]) map[K]V, map[K]V) func(HKTA) map[K]V,
	K comparable,
	V any](m Mg.Magma[V], red FOLDABLE) func(fa HKTA) map[K]V

FromFoldable converts from a reducer to a map Duplicate keys are resolved by the provided [Mg.Magma]

func FromFoldableMap 

func FromFoldableMap[
	FOLDABLE ~func(func(map[K]V, A) map[K]V, map[K]V) func(HKTA) map[K]V,
	A any,
	HKTA any,
	K comparable,
	V any](m Mg.Magma[V], red FOLDABLE) func(f func(A) Entry[K, V]) func(fa HKTA) map[K]V

FromFoldableMap converts from a reducer to a map Duplicate keys are resolved by the provided [Mg.Magma]

func FromStrictEquals 

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

FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function

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 

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 Let 

func Let[S1, T any, K comparable, S2 any](
	setter func(T) func(S1) S2,
	f func(S1) T,
) func(map[K]S1) map[K]S2

Let attaches the result of a computation to a context [S1] to produce a context [S2]

func LetTo 

func LetTo[S1, T any, K comparable, S2 any](
	setter func(T) func(S1) S2,
	b T,
) func(map[K]S1) map[K]S2

LetTo attaches the a value to a context [S1] to produce a context [S2]

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 MergeMonoid 

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 MonadAp 

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

MonadAp applies a map of functions to a map of values, combining results using the provided Monoid

func MonadChain 

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

MonadChain chains a map transformation function that produces maps, combining results using the provided Monoid

func MonadChainWithIndex 

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

MonadChainWithIndex chains a map transformation function that produces maps, combining results using the provided Monoid

func MonadFlap 

func MonadFlap[B any, K comparable, A any](fab map[K]func(A) B, a A) map[K]B

MonadFlap applies a value to a map of functions, producing a map of results

func MonadLookup 

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

MonadMap transforms each value in a map using the provided function

func MonadMapRef 

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

MonadMapRef transforms each value in a map using the provided function with value references

func MonadMapRefWithIndex 

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

MonadMapRefWithIndex transforms each key-value pair in a map using the provided function with value references

func MonadMapWithIndex 

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

MonadMapWithIndex transforms each key-value pair in a map using the provided function

func Of added in v2.0.1 

func Of[K comparable, A any](k K, a A) map[K]A

Of creates a map with a single key-value pair

func Reduce 

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

Reduce reduces a map to a single value by applying a reducer function to each value

func ReduceOrd 

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 

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

ReduceRef reduces a map to a single value by applying a reducer function to each value reference

func ReduceRefWithIndex 

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

ReduceRefWithIndex reduces a map to a single value by applying a reducer function to each key-value pair with value references

func ReduceWithIndex 

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

ReduceWithIndex reduces a map to a single value by applying a reducer function to each key-value pair

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 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) Operator[K, V, V]

Union combines two maps using the provided Magma to resolve conflicts for duplicate keys

func UnionFirstMonoid 

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 

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

UnionFirstSemigroup creates a semigroup for maps where the first (left) value wins when the same key exists in both maps being concatenated.

This is useful when you want to preserve original values and ignore updates for keys that already exist.

When concatenating two maps:

  • Keys that exist in only one map are included in the result
  • Keys that exist in both maps keep the value from the first (left) map

Example: 

semigroup := UnionFirstSemigroup[string, int]()

map1 := map[string]int{"a": 1, "b": 2}
map2 := map[string]int{"b": 3, "c": 4}
result := semigroup.Concat(map1, map2)
// result: {"a": 1, "b": 2, "c": 4}  // b keeps value from map1 (first wins)

This is useful for:

  • Default values (defaults are set first, user values don't override)
  • Caching (first cached value is kept, subsequent updates ignored)
  • Immutable registries (first registration wins, duplicates are ignored)

func UnionLastMonoid 

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 

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

UnionLastSemigroup creates a semigroup for maps where the last (right) value wins when the same key exists in both maps being concatenated.

This is the most common conflict resolution strategy and is equivalent to using the standard map merge operation where right-side values take precedence.

When concatenating two maps:

  • Keys that exist in only one map are included in the result
  • Keys that exist in both maps take the value from the second (right) map

Example: 

semigroup := UnionLastSemigroup[string, int]()

map1 := map[string]int{"a": 1, "b": 2}
map2 := map[string]int{"b": 3, "c": 4}
result := semigroup.Concat(map1, map2)
// result: {"a": 1, "b": 3, "c": 4}  // b takes value from map2 (last wins)

This is useful for:

  • Configuration overrides (later configs override earlier ones)
  • Applying updates to a base map
  • Merging user preferences where newer values should win

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]

UnionSemigroup creates a semigroup for maps that combines two maps using the provided semigroup for resolving conflicts when the same key exists in both maps.

When concatenating two maps:

  • Keys that exist in only one map are included in the result
  • Keys that exist in both maps have their values combined using the provided semigroup

This is useful when you want custom conflict resolution logic beyond simple "first wins" or "last wins" semantics.

Example: 

// Create a semigroup that sums values for duplicate keys
sumSemigroup := number.SemigroupSum[int]()
mapSemigroup := UnionSemigroup[string, int](sumSemigroup)

map1 := map[string]int{"a": 1, "b": 2}
map2 := map[string]int{"b": 3, "c": 4}
result := mapSemigroup.Concat(map1, map2)
// result: {"a": 1, "b": 5, "c": 4}  // b values are summed: 2 + 3 = 5

Example with string concatenation: 

stringSemigroup := string.Semigroup
mapSemigroup := UnionSemigroup[string, string](stringSemigroup)

map1 := map[string]string{"a": "Hello", "b": "World"}
map2 := map[string]string{"b": "!", "c": "Goodbye"}
result := mapSemigroup.Concat(map1, map2)
// result: {"a": "Hello", "b": "World!", "c": "Goodbye"}

func Values 

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

Values returns the values in a map

func ValuesOrd 

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

type Collector added in v2.0.1 

type Collector[K comparable, V, R any] = func(K, V) R

Collector transforms key-value pairs into a result type and collects them into an array.

Example: 

toStrings := Collect(func(k string, v int) string {
    return fmt.Sprintf("%s=%d", k, v)
})

type Entries added in v2.0.1 

type Entries[K comparable, V any] = []Entry[K, V]

Entries is a slice of key-value pairs.

Example: 

entries := Entries[string, int]{
    T.MakeTuple2("a", 1),
    T.MakeTuple2("b", 2),
}
record := FromEntries(entries)

func ToArray 

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

ToArray converts a map to an array of key-value pairs

func ToEntries 

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

ToEntries converts a map to an array of key-value pairs (alias for ToArray)

type Entry added in v2.0.1 

type Entry[K comparable, V any] = pair.Pair[K, V]

Entry represents a single key-value pair from a record. This is an alias for Tuple2 to provide semantic clarity.

Example: 

entries := ToEntries(record)
for _, entry := range entries {
    key := entry.F1
    value := entry.F2
}

type Kleisli added in v2.0.1 

type Kleisli[K comparable, V1, V2 any] = func(V1) Record[K, V2]

Kleisli represents a monadic function that transforms a value into a record. Used in chain operations for composing record-producing functions.

Example: 

expand := func(x int) Record[string, int] {
    return Record[string, int]{
        "double": x * 2,
        "triple": x * 3,
    }
}

type KleisliWithIndex added in v2.0.1 

type KleisliWithIndex[K comparable, V1, V2 any] = func(K, V1) Record[K, V2]

KleisliWithIndex is a monadic function that uses both key and value to produce a record.

Example: 

expandWithKey := func(k string, v int) Record[string, int] {
    return Record[string, int]{
        k + "_double": v * 2,
        k + "_triple": v * 3,
    }
}

type Operator added in v2.0.1 

type Operator[K comparable, V1, V2 any] = func(Record[K, V1]) Record[K, V2]

Operator transforms a record from one value type to another while preserving keys. This is the fundamental transformation type for record operations.

Example: 

doubleValues := Map(func(x int) int { return x * 2 })
result := doubleValues(Record[string, int]{"a": 1, "b": 2})
// result: {"a": 2, "b": 4}

func DeleteAt 

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

DeleteAt returns a function that removes a key from a map

func Filter 

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

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

func FilterMap 

func FilterMap[K comparable, V1, V2 any](f func(V1) O.Option[V2]) Operator[K, V1, 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]) Operator[K, V1, 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) Operator[K, V, V]

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

func Map 

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

Map returns a function that transforms each value in a map using the provided function

func MapRef 

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

MapRef returns a function that transforms each value in a map using the provided function with value references

func MapRefWithIndex 

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

MapRefWithIndex returns a function that transforms each key-value pair in a map using the provided function with value references

func MapWithIndex 

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

MapWithIndex returns a function that transforms each key-value pair in a map using the provided function

func Merge 

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

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

func UpsertAt 

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

UpsertAt returns a function that inserts or updates a key-value pair in a map

type OperatorWithIndex added in v2.0.1 

type OperatorWithIndex[K comparable, V1, V2 any] = func(func(K, V1) V2) Operator[K, V1, V2]

OperatorWithIndex transforms a record using both key and value information. Useful when the transformation depends on the key.

Example: 

prefixWithKey := MapWithIndex(func(k string, v string) string {
    return k + ":" + v
})

type Predicate added in v2.0.1 

type Predicate[K any] = predicate.Predicate[K]

Predicate is a function that tests whether a key satisfies a condition. Used in filtering operations to determine which entries to keep.

Example: 

isVowel := func(k string) bool {
    return strings.ContainsAny(k, "aeiou")
}

type PredicateWithIndex added in v2.0.1 

type PredicateWithIndex[K comparable, V any] = func(K, V) bool

PredicateWithIndex is a function that tests whether a key-value pair satisfies a condition. Used in filtering operations that need access to both key and value.

Example: 

isAdult := func(name string, user User) bool {
    return user.Age >= 18
}

type Record added in v2.0.1 

type Record[K comparable, V any] = map[K]V

Record represents a map with comparable keys and values of any type. This is the primary data structure for the record package, providing functional operations over Go's native map type.

Example: 

type UserRecord = Record[string, User]
users := UserRecord{
    "alice": User{Name: "Alice", Age: 30},
    "bob":   User{Name: "Bob", Age: 25},
}

type Reducer added in v2.0.1 

type Reducer[K comparable, V, R any] = func(R, V) R

Reducer accumulates values from a record into a single result. The function receives the accumulator and current value, returning the new accumulator.

Example: 

sum := Reduce(func(acc int, v int) int {
    return acc + v
}, 0)

type ReducerWithIndex added in v2.0.1 

type ReducerWithIndex[K comparable, V, R any] = func(K, R, V) R

ReducerWithIndex accumulates values using both key and value information.

Example: 

weightedSum := ReduceWithIndex(func(k string, acc int, v int) int {
    weight := len(k)
    return acc + (v * weight)
}, 0)

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.