record

func Ap ¶

func Ap[A any, K comparable, B any](m Monoid[Record[K, B]]) func(fa Record[K, A]) Operator[K, func(A) B, B]

Ap returns a function that applies a record of functions to a record of values.

This is the curried version of MonadAp, useful for composition. The applicative apply operation for records.

Example:

funcs := Record[string, func(int) int]{
    "double": func(x int) int { return x * 2 },
}
applyFuncs := Ap[int, string, int](MergeMonoid[string, int]())
values := Record[string, int]{"double": 5}
result := applyFuncs(values)(funcs) // {"double": 10}

func ApS ¶

func ApS[S1, T any, K comparable, S2 any](m Monoid[Record[K, S2]]) func(
	setter func(T) func(S1) S2,
	fa Record[K, T],
) Operator[K, S1, 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 Monoid[Record[K, S2]]) func(
	setter func(T) func(S1) S2,
	f Kleisli[K, S1, T],
) Operator[K, S1, 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 Chain ¶

func Chain[V1 any, K comparable, V2 any](m Monoid[Record[K, V2]]) func(Kleisli[K, V1, V2]) Operator[K, V1, V2]

Chain returns a function that chains record transformations.

This is the curried version of MonadChain, useful for composition. The monadic bind operation for records.

Example:

expand := Chain[int, string, string](MergeMonoid[string, string]())(
    func(v int) Record[string, string] {
        return Record[string, string]{"result": fmt.Sprint(v)}
    },
)
result := expand(Record[string, int]{"a": 1})

func ChainWithIndex ¶

func ChainWithIndex[V1 any, K comparable, V2 any](m Monoid[Record[K, V2]]) func(KleisliWithIndex[K, V1, V2]) Operator[K, V1, V2]

ChainWithIndex returns a function that chains record transformations with key-value access.

This is the curried version of MonadChainWithIndex, useful for composition.

Example:

expand := ChainWithIndex[int, string, string](MergeMonoid[string, string]())(
    func(k string, v int) Record[string, string] {
        return Record[string, string]{k + "_str": fmt.Sprint(v)}
    },
)
result := expand(Record[string, int]{"a": 1})

func Collect ¶

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

Collect transforms each key-value pair in a record using a collector function and returns the results as a slice.

The collector function receives both the key and value, allowing transformations that depend on both. The order of results is non-deterministic.

Example:

record := Record[string, int]{"a": 1, "b": 2}
toStrings := Collect(func(k string, v int) string {
    return fmt.Sprintf("%s=%d", k, v)
})
result := toStrings(record) // ["a=1", "b=2"] in any order

func CollectOrd ¶

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

CollectOrd transforms each key-value pair in a record using a collector function and returns the results as a slice in the order specified by the Ord instance.

Unlike Collect, this function guarantees the order of results based on key ordering.

Example:

record := Record[string, int]{"c": 3, "a": 1, "b": 2}
toStrings := CollectOrd(S.Ord)(func(k string, v int) string {
    return fmt.Sprintf("%s=%d", k, v)
})
result := toStrings(record) // ["a=1", "b=2", "c=3"] (ordered by key)

func Eq ¶

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

func FilterChain ¶

func FilterChain[V1 any, K comparable, V2 any](m Monoid[Record[K, V2]]) func(option.Kleisli[V1, Record[K, V2]]) Operator[K, V1, V2]

FilterChain filters and chains transformations that produce records.

Similar to FilterChainWithIndex but without key access in the transformation function.

Example:

record := Record[string, int]{"a": 1, "b": 2, "c": 3}
expandEven := FilterChain[int, string, int](MergeMonoid[string, int]())(
    func(v int) Option[Record[string, int]] {
        if v%2 == 0 {
            return O.Some(Record[string, int]{"doubled": v * 2})
        }
        return O.None[Record[string, int]]()
    },
)
result := expandEven(record)

func FilterChainWithIndex ¶

func FilterChainWithIndex[V1 any, K comparable, V2 any](m Monoid[Record[K, V2]]) func(func(K, V1) Option[Record[K, V2]]) Operator[K, V1, V2]

FilterChainWithIndex filters and chains transformations that produce records.

Combines filtering with chaining: the transformation returns Some(record) to include the result, or None to exclude it. Results are combined using the Monoid.

Example:

record := Record[string, int]{"a": 1, "b": 2, "c": 3}
expandEven := FilterChainWithIndex[int, string, int](MergeMonoid[string, int]())(
    func(k string, v int) Option[Record[string, int]] {
        if v%2 == 0 {
            return O.Some(Record[string, int]{k + "_doubled": v * 2})
        }
        return O.None[Record[string, int]]()
    },
)
result := expandEven(record) // {"b_doubled": 4}

func Flatten ¶

func Flatten[K comparable, V any](m Monoid[Record[K, V]]) func(Record[K, Record[K, V]]) Record[K, V]

Flatten converts a nested record (record of records) into a flat record.

When keys conflict between nested records, the Monoid determines how to combine values. This is the monadic join operation.

Example:

nested := Record[string, Record[string, int]]{
    "group1": {"a": 1, "b": 2},
    "group2": {"c": 3, "d": 4},
}
flat := Flatten(MergeMonoid[string, int]())(nested)
// flat: {"a": 1, "b": 2, "c": 3, "d": 4}

func Fold ¶

func Fold[K comparable, A any](m Monoid[A]) func(Record[K, A]) A

Fold combines all values in a record using a Monoid.

This is useful when the record values are already of the target type and you just need to combine them.

Example:

record := Record[string, int]{"a": 1, "b": 2, "c": 3}
sum := Fold(N.MonoidSum[int]())
result := sum(record) // 6

func FoldMap ¶

func FoldMap[K comparable, A, B any](m Monoid[B]) func(func(A) B) func(Record[K, A]) B

FoldMap maps each value in a record and folds the results using a Monoid.

This is a two-step operation: first map each value using the provided function, then combine all results using the Monoid's operation.

Example:

record := Record[string, int]{"a": 1, "b": 2, "c": 3}
sumDoubled := FoldMap(N.MonoidSum[int]())(func(v int) int {
    return v * 2
})
result := sumDoubled(record) // 12 (2 + 4 + 6)

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 Monoid[B]) func(func(A) B) func(Record[K, A]) B

FoldMapOrd maps and folds a record with keys processed in order.

Similar to FoldMap but guarantees the order in which entries are processed based on the provided Ord instance.

Example:

record := Record[string, int]{"c": 3, "a": 1, "b": 2}
concat := FoldMapOrd(S.Ord)(S.MonoidConcat)(func(v int) string {
    return fmt.Sprint(v)
})
result := concat(record) // "123" (alphabetical key order)

func FoldMapOrdWithIndex ¶

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

FoldMapOrdWithIndex maps and folds a record with key-value access and ordered processing.

Combines FoldMapWithIndex with ordered key processing based on the Ord instance.

Example:

record := Record[string, int]{"c": 3, "a": 1, "b": 2}
concat := FoldMapOrdWithIndex(S.Ord)(S.MonoidConcat)(func(k string, v int) string {
    return k + fmt.Sprint(v)
})
result := concat(record) // "a1b2c3" (alphabetical key order)

func FoldMapWithIndex ¶

func FoldMapWithIndex[K comparable, A, B any](m Monoid[B]) func(func(K, A) B) func(Record[K, A]) B

FoldMapWithIndex maps each key-value pair in a record and folds the results using a Monoid.

Similar to FoldMap but the mapping function receives both key and value.

Example:

record := Record[string, int]{"a": 1, "b": 2}
weightedSum := FoldMapWithIndex(N.MonoidSum[int]())(func(k string, v int) int {
    return len(k) * v
})
result := weightedSum(record) // 1*1 + 1*2 = 3

func FoldOrd ¶

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

FoldOrd combines all values in a record using a Monoid with keys processed in order.

Similar to Fold but guarantees the order based on the provided Ord instance.

Example:

record := Record[string, string]{"c": "3", "a": "1", "b": "2"}
concat := FoldOrd(S.Ord)(S.MonoidConcat)
result := concat(record) // "123" (alphabetical key order)

func FromArrayMap ¶

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

FromArrayMap converts an array to a record by mapping elements to entries.

Each element is transformed into a key-value entry. When duplicate keys occur, the Magma determines how to combine their values.

Example:

type Item struct { Name string; Count int }
items := []Item{{"apple", 5}, {"banana", 3}, {"apple", 2}}

sumMagma := Mg.MakeMagma(func(a, b int) int { return a + b })
toRecord := FromArrayMap[Item, string, int](sumMagma)(func(item Item) Entry[string, int] {
    return P.MakePair(item.Name, item.Count)
})
result := toRecord(items) // {"apple": 7, "banana": 3}

func FromFoldableMap ¶

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

FromFoldableMap converts a foldable structure to a record by mapping elements to entries.

The mapping function transforms each element into a key-value entry. When duplicate keys occur, the Magma determines how to combine their values. This is useful for building records from custom data structures.

Example:

type Person struct { ID string; Score int }
people := []Person{{"alice", 10}, {"bob", 20}, {"alice", 15}}

sumMagma := Mg.MakeMagma(func(a, b int) int { return a + b })
toRecord := FromArrayMap[Person, string, int](sumMagma)(func(p Person) Entry[string, int] {
    return P.MakePair(p.ID, p.Score)
})
result := toRecord(people) // {"alice": 25, "bob": 20}

func FromStrictEquals ¶

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

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

func Has ¶

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

Has tests if a key exists in a record.

Returns true if the key is present in the record, false otherwise.

Example:

record := Record[string, int]{"a": 1, "b": 2}
Has("a", record) // true
Has("c", record) // false

func IsEmpty ¶

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

IsEmpty tests if a record is empty (contains no entries).

Returns true if the record has no key-value pairs, false otherwise.

Example:

empty := Record[string, int]{}
IsEmpty(empty) // true

nonEmpty := Record[string, int]{"a": 1}
IsEmpty(nonEmpty) // false

func IsNil ¶

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

IsNil checks if the record is nil (not initialized).

Note: This checks for nil, not empty. An empty record {} is not nil.

Example:

var record Record[string, int]
IsNil(record) // true

record = Record[string, int]{}
IsNil(record) // false

func IsNonEmpty ¶

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

IsNonEmpty tests if a record is not empty (contains at least one entry).

Returns true if the record has at least one key-value pair, false otherwise. This is the logical negation of IsEmpty.

Example:

record := Record[string, int]{"a": 1}
IsNonEmpty(record) // true

func IsNonNil ¶

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

IsNonNil checks if the record is not nil (is initialized).

This is the logical negation of IsNil.

Example:

record := Record[string, int]{"a": 1}
IsNonNil(record) // true

func Keys ¶

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

Keys returns all keys from a record as a slice.

The order of keys is non-deterministic due to Go's map iteration behavior. Use KeysOrd if you need keys in a specific order.

Example:

record := Record[string, int]{"a": 1, "b": 2, "c": 3}
keys := Keys(record) // ["a", "b", "c"] in any order

func KeysOrd ¶

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

KeysOrd returns the keys from a record in the order specified by the Ord instance.

Unlike Keys, this guarantees a specific order for the returned keys.

Example:

record := Record[string, int]{"c": 3, "a": 1, "b": 2}
getKeys := KeysOrd(S.Ord)
keys := getKeys(record) // ["a", "b", "c"]

func Lookup ¶

func Lookup[V any, K comparable](k K) option.Kleisli[Record[K, V], V]

Lookup returns a function that retrieves the value for a key in a record if it exists.

Returns Some(value) if the key exists, None otherwise. This is the curried version that returns a Kleisli arrow, useful for composition.

Example:

record := Record[string, int]{"a": 1, "b": 2}
lookupA := Lookup[int]("a")
result := lookupA(record) // Some(1)

lookupC := Lookup[int]("c")
result2 := lookupC(record) // None

func Reduce ¶

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

Reduce reduces a record to a single value by applying a reducer function to each value.

The reducer function receives the accumulated result and the current value, returning the new accumulated result. The iteration order is non-deterministic.

Example:

record := Record[string, int]{"a": 1, "b": 2, "c": 3}
sum := Reduce(func(acc int, v int) int {
    return acc + v
}, 0)
result := sum(record) // 6

func ReduceOrd ¶

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

ReduceOrd reduces a record to a single value with keys processed in order.

Similar to ReduceOrdWithIndex but the reducer function doesn't receive keys.

Example:

record := Record[string, int]{"c": 3, "a": 1, "b": 2}
sum := ReduceOrd(S.Ord)(func(acc int, v int) int {
    return acc + v
}, 0)
result := sum(record) // 6 (order doesn't affect sum)

func ReduceOrdWithIndex ¶

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

ReduceOrdWithIndex reduces a record to a single value with keys processed in order.

Unlike ReduceWithIndex, this guarantees the order in which keys are processed based on the provided Ord instance.

Example:

record := Record[string, int]{"c": 3, "a": 1, "b": 2}
concat := ReduceOrdWithIndex(S.Ord)(func(k string, acc string, v int) string {
    return acc + k + fmt.Sprint(v)
}, "")
result := concat(record) // "a1b2c3" (alphabetical order)

func ReduceRef ¶

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

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

Similar to Reduce, but passes value pointers instead of values, which can be more efficient for large value types and allows mutation if needed.

Example:

record := Record[string, LargeStruct]{...}
result := ReduceRef(func(acc int, v *LargeStruct) int {
    return acc + v.Size
}, 0)(record)

func ReduceRefWithIndex ¶

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

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

Combines the benefits of ReduceWithIndex and ReduceRef, providing both key access and value references for efficient processing of large value types.

Example:

record := Record[string, LargeStruct]{...}
result := ReduceRefWithIndex(func(k string, acc int, v *LargeStruct) int {
    return acc + len(k) * v.Size
}, 0)(record)

func ReduceWithIndex ¶

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

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

The reducer function receives the key, accumulated result, and current value, allowing reductions that depend on the key. The iteration order is non-deterministic.

Example:

record := Record[string, int]{"a": 1, "b": 2, "c": 3}
weightedSum := ReduceWithIndex(func(k string, acc int, v int) int {
    weight := len(k)
    return acc + (v * weight)
}, 0)
result := weightedSum(record) // 1 + 2 + 3 = 6

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

Sequence transforms a map of effects into an effect of a map. This is the dual of Traverse where the transformation function is the identity.

This is useful when you have a map where each value is already in an effect context (like Option, Either, etc.) and you want to "flip" the nesting to get a single effect containing a map of plain values.

If any value in the map is a "failure" (e.g., None, Left), the entire result will be a failure. If all values are "successes", the result will be a success containing a map of all the unwrapped values.

Type parameters:

• K: The key type (must be comparable)
• A: The value type inside the effect
• HKTA: Higher-kinded type representing the effect containing A (e.g., Option[A])
• HKTAA: Higher-kinded type representing a function from A to map[K]A in the effect
• HKTRA: Higher-kinded type representing the effect containing map[K]A

Parameters:

• fof: Lifts a pure map[K]A into the effect (the "of" or "pure" function)
• fmap: Maps a function over the effect (the "map" or "fmap" function)
• fap: Applies an effectful function to an effectful value (the "ap" function)
• ma: The input map where each value is in an effect context

Example with Option:

input := map[string]O.Option[int]{"a": O.Some(1), "b": O.Some(2)}
result := Sequence(O.Of[map[string]int], O.Map[...], O.Ap[...], input)
// result: O.Some(map[string]int{"a": 1, "b": 2})

input2 := map[string]O.Option[int]{"a": O.Some(1), "b": O.None[int]()}
result2 := Sequence(O.Of[map[string]int], O.Map[...], O.Ap[...], input2)
// result2: O.None[map[string]int]()

func Size ¶

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

Size returns the number of key-value pairs in a record.

Example:

record := Record[string, int]{"a": 1, "b": 2, "c": 3}
Size(record) // 3

empty := Empty[string, int]()
Size(empty) // 0

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

Traverse transforms a map of values into a value of a map by applying an effectful function to each value. Unlike TraverseWithIndex, this function does not provide access to the keys.

This is useful when you need to perform an operation that may fail or have side effects on each element of a map, and you want to collect the results in the same applicative context.

Type parameters:

• K: The key type (must be comparable)
• A: The input value type
• B: The output value type
• HKTB: Higher-kinded type representing the effect containing B (e.g., Option[B], Either[E, B])
• HKTAB: Higher-kinded type representing a function from B to map[K]B in the effect
• HKTRB: Higher-kinded type representing the effect containing map[K]B

Parameters:

• fof: Lifts a pure map[K]B into the effect (the "of" or "pure" function)
• fmap: Maps a function over the effect (the "map" or "fmap" function)
• fap: Applies an effectful function to an effectful value (the "ap" function)
• f: The transformation function that takes a value and returns an effect

Example with Option:

f := func(s string) O.Option[string] {
    if s != "" {
        return O.Some(strings.ToUpper(s))
    }
    return O.None[string]()
}
traverse := Traverse(O.Of[map[string]string], O.Map[...], O.Ap[...], f)
result := traverse(map[string]string{"a": "hello"}) // O.Some(map[string]string{"a": "HELLO"})

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

TraverseWithIndex transforms a map of values into a value of a map by applying an effectful function to each key-value pair. The function has access to both the key and value.

This is useful when you need to perform an operation that may fail or have side effects on each element of a map, and you want to collect the results in the same applicative context.

Type parameters:

• K: The key type (must be comparable)
• A: The input value type
• B: The output value type
• HKTB: Higher-kinded type representing the effect containing B (e.g., Option[B], Either[E, B])
• HKTAB: Higher-kinded type representing a function from B to map[K]B in the effect
• HKTRB: Higher-kinded type representing the effect containing map[K]B

Parameters:

• fof: Lifts a pure map[K]B into the effect (the "of" or "pure" function)
• fmap: Maps a function over the effect (the "map" or "fmap" function)
• fap: Applies an effectful function to an effectful value (the "ap" function)
• f: The transformation function that takes a key and value and returns an effect

Example with Option:

f := func(k string, n int) O.Option[int] {
    if n > 0 {
        return O.Some(n * 2)
    }
    return O.None[int]()
}
traverse := TraverseWithIndex(O.Of[map[string]int], O.Map[...], O.Ap[...], f)
result := traverse(map[string]int{"a": 1, "b": 2}) // O.Some(map[string]int{"a": 2, "b": 4})

func Union ¶

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

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

The Magma defines how to combine values when the same key exists in both records. This is useful for custom merge strategies beyond simple replacement.

Example:

// Sum values for duplicate keys
sumMagma := Mg.MakeMagma(func(a, b int) int { return a + b })
unionSum := Union(sumMagma)

r1 := Record[string, int]{"a": 1, "b": 2}
r2 := Record[string, int]{"b": 3, "c": 4}
result := unionSum(r1)(r2) // {"a": 1, "b": 5, "c": 4}

func Values ¶

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

Values returns all values from a record as a slice.

The order of values is non-deterministic due to Go's map iteration behavior. Use ValuesOrd if you need values ordered by their keys.

Example:

record := Record[string, int]{"a": 1, "b": 2, "c": 3}
values := Values(record) // [1, 2, 3] in any order

func ValuesOrd ¶

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

ValuesOrd returns the values from a record ordered by their keys.

The values are returned in the order determined by sorting the keys using the Ord instance.

Example:

record := Record[string, int]{"c": 3, "a": 1, "b": 2}
getValues := ValuesOrd(S.Ord)
values := getValues(record) // [1, 2, 3] (ordered by key: a, b, c)

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

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

fmt.Println(getValues(src))

Output:

[c b a]