record

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

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) func(map[K]V1) map[K]V2

func ChainWithIndex ¶

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

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

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

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 ¶

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

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

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.

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 []T.Tuple2[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) T.Tuple2[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 []T.Tuple2[K, V]) map[K]V

func FromFoldable ¶

func FromFoldable[
	HKTA any,
	FOLDABLE ~func(func(map[K]V, T.Tuple2[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) T.Tuple2[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 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 ¶

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 ¶

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

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

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

func MonadFlap ¶

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

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

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 ¶

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

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 ¶

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]

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]

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 ¶

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

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

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

fmt.Println(getValues(src))

Output:

[c b a]