What are the limitations of using sync.Map compared to a regular Map protected by Mutex?

sync.Map in Go is designed for concurrent access without explicit use of mutexes, but has limitations compared to a regular map + sync.Mutex:

• Lack of type safety: sync.Map stores values as interface{}, which requires type assertions and reduces safety.
• Limited API: no way to get the size of the map, no methods for conditional deletion, no iteration with modification capabilities.
• Performance: sync.Map is optimized for scenarios with many reads and infrequent writes. In cases of frequent writes and deletions, it may perform worse than a map with a mutex.
• Iteration: iterating over sync.Map does not guarantee data consistency, as the map may change during traversal.

Example of using sync.Map:

var m sync.Map
m.Store("key", "value")
if val, ok := m.Load("key"); ok {
    fmt.Println(val)
}
m.Delete("key")

If strict typing and full control are needed, it is better to use a regular map with sync.Mutex."},{