map_transform.go

package gofu

// ToSlice converts the map to a Slice using a mapper fn. [ Immutable ] [ time: O(n); space: O(n)]
//
// Example:
//
//		gofu.Map[string, int]{"a": 1, "b": 2}.
//	  ToSlice(func(k string, v int) string { return k + strconv.Itoa(v) })
//		// Slice[string]{"a1", "b2"} (order not guaranteed)
func (m Map[K, V]) ToSlice[S any](fn func(K, V) S) Slice[S] {
	result := make(Slice[S], 0, len(m))
	for k, v := range m {
		result = append(result, fn(k, v))
	}
	return result
}

// Map transforms keys and values of the map. [ Immutable ] [ time: O(n); space: O(n)]
// If multiple entries map to the same new key, the last one wins.
//
// Example:
//
//	gofu.Map[string, int]{"a": 1, "b": 2}.
//	    Map(func(k string, v int) (string, string) {
//	        return k, strconv.Itoa(v)
//	    })
//	// Map[string]string{"a": "1", "b": "2"}
func (m Map[K, V]) Map[K2 comparable, V2 any](fn func(K, V) (K2, V2)) Map[K2, V2] {
	result := make(Map[K2, V2], len(m))
	for k, v := range m {
		k2, v2 := fn(k, v)
		result[k2] = v2
	}
	return result
}

// Reduce combines key-value pairs using fn, starting from initial. [ Immutable ] [ time: O(n); space: O(1)]
//
// Example:
//
//	gofu.Map[string, int]{"a": 10, "b": 20, "c": 30}.
//	    Reduce(0, func(acc int, k string, v int) int { return acc + v }) // 60
func (m Map[K, V]) Reduce[R any](initial R, fn func(R, K, V) R) R {
	result := initial
	for k, v := range m {
		result = fn(result, k, v)
	}
	return result
}