map_join.go

package gofu

import "maps"

// Merge returns a new map containing entries from m merged with all others. [ Immutable ] [ time: O(n+m); space: O(n+m)]
// For duplicate keys, values from later maps overwrite earlier ones.
//
// Example:
//
//	a := gofu.Map[string, int]{"a": 1, "b": 2}
//	b := gofu.Map[string, int]{"b": 3, "c": 4}
//	a.Merge(b) // Map[string, int]{"a": 1, "b": 3, "c": 4}
func (m Map[K, V]) Merge(others ...Map[K, V]) Map[K, V] {
	total := len(m)
	for _, other := range others {
		total += len(other)
	}
	result := make(Map[K, V], total)
	maps.Copy(result, m)
	for _, other := range others {
		maps.Copy(result, other)
	}
	return result
}

// Intersect returns a new map with keys present in both maps. [ Immutable ] [ time: O(n+m); space: O(min(n,m)) ]
//
// Values from m are kept.
//
// Example:
//
//	a := gofu.Map[string, int]{"a": 1, "b": 2, "c": 3}
//	b := gofu.Map[string, int]{"b": 20, "c": 30, "d": 40}
//	a.Intersect(b) // Map[string, int]{"b": 2, "c": 3}
func (m Map[K, V]) Intersect(other Map[K, V]) Map[K, V] {
	left, right := m, other
	if len(m) > len(other) {
		left, right = other, m
	}
	result := make(Map[K, V], len(left))
	for k := range left {
		if _, ok := right[k]; ok {
			result[k] = m[k]
		}
	}
	return result
}

// Difference returns a new map with keys from m that are not present in other. [ Immutable ] [ time: O(n+m); space: O(n)]
//
// Example:
//
//	a := gofu.Map[string, int]{"a": 1, "b": 2, "c": 3}
//	b := gofu.Map[string, int]{"b": 20, "d": 40}
//	a.Difference(b) // Map[string, int]{"a": 1, "c": 3}
func (m Map[K, V]) Difference(other Map[K, V]) Map[K, V] {
	result := maps.Clone(m)
	for k := range other {
		delete(result, k)
	}
	return result
}