Concurrency safe (#7)

* feat: Concurrency improvements

These changes make the package safe for concurrent go routines.
I tried to minimize lock contention using atomic and RWMutex.
Also fixed a bug with maps/slices of Items (exported type), which now are handled correctly.

* chore: update copy

Author: srfrog

.gitignore

@@ -0,0 +1 @@
+.gocache

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019 srfrog - https://srfrog.me
+Copyright (c) 2025 srfrog - https://srfrog.dev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -29,10 +29,10 @@ View [example_test.go][2] for an extended example of basic usage and features.
 - [x] Go types int, uint, float, string and fmt.Stringer are hashable for dict keys.
 - [x] Go map keys are used for dict keys if they are hashable.
 - [x] Dict items are sorted in their insertion order, unlike Go maps.
-- [ ] Go routine safe with minimal mutex locking (WIP)
+- [x] Go routine safe with minimal mutex locking (WIP)
 - [x] Builtin JSON support for marshalling and unmarshalling
 - [ ] sql.Scanner support via optional sub-package (WIP)
-- [ ] Plenty of tests and examples to get you started quickly (WIP)
+- [x] Plenty of tests and examples to get you started quickly
 
 ## Documentation
 

benchmark_test.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2019 srfrog - https://srfrog.me
+// Copyright (c) 2025 srfrog - https://srfrog.dev
 // Use of this source code is governed by the license in the LICENSE file.
 
 package dict

conv.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2019 srfrog - https://srfrog.me
+// Copyright (c) 2025 srfrog - https://srfrog.dev
 // Use of this source code is governed by the license in the LICENSE file.
 
 package dict
@@ -82,6 +82,14 @@ type Item struct {
 func toIterable(i interface{}) <-chan Item {
 	ci := make(chan Item)
 
+	// If the value is an Item, just return it.
+	transform := func(ii interface{}) Item {
+		if v, ok := ii.(Item); ok {
+			return v
+		}
+		return Item{Value: ii}
+	}
+
 	go func() {
 		defer close(ci)
 
@@ -112,16 +120,16 @@ func toIterable(i interface{}) <-chan Item {
 				if !ok {
 					break L
 				}
-				ci <- Item{Value: x.Interface()}
+				ci <- transform(x.Interface())
 			}
 
 		case reflect.Array, reflect.Slice:
 			for j := 0; j < v.Len(); j++ {
-				ci <- Item{Key: j, Value: v.Index(j).Interface()}
+				ci <- transform(v.Index(j).Interface())
 			}
 
 		default:
-			ci <- Item{Value: v.Interface()}
+			ci <- transform(v.Interface())
 		}
 	}()
 

dict.go

@@ -1,27 +1,35 @@
-// Copyright (c) 2019 srfrog - https://srfrog.me
+// Copyright (c) 2025 srfrog - https://srfrog.dev
 // Use of this source code is governed by the license in the LICENSE file.
 
 package dict
 
 import (
 	"fmt"
+	"reflect"
 	"strings"
+	"sync"
+	"sync/atomic"
 )
 
 // Dict is a type that uses a hash mapping index, also known as a dictionary.
 type Dict struct {
-	size, version int
+	size, version int64
 	keys          []*Key
 	values        map[uint64]interface{}
+	mu            sync.RWMutex
 }
 
 // Version returns the version of the dictionary. The version is increased after every
 // change to dict items.
 // Returns version, which is zero (0) initially.
-func (d *Dict) Version() int { return d.version }
+func (d *Dict) Version() int {
+	return int(atomic.LoadInt64(&d.version))
+}
 
 // Len returns the size of a Dict.
-func (d *Dict) Len() int { return d.size }
+func (d *Dict) Len() int {
+	return int(atomic.LoadInt64(&d.size))
+}
 
 // New returns a new Dict object.
 // vargs can be any Go basic type, slices, and maps. The keys in a map are
@@ -45,14 +53,23 @@ func (d *Dict) Set(key, value interface{}) *Dict {
 		return d
 	}
 
-	if _, ok := d.values[k.ID]; ok {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	if curr, ok := d.values[k.ID]; ok {
 		d.values[k.ID] = value
+
+		// Value changed, update version.
+		if !reflect.DeepEqual(value, curr) {
+			atomic.AddInt64(&d.version, 1)
+		}
+
 		return d
 	}
 	d.keys = append(d.keys, k)
 	d.values[k.ID] = value
-	d.size++
-	d.version++
+	atomic.AddInt64(&d.size, 1)
+	atomic.AddInt64(&d.version, 1)
 
 	return d
 }
@@ -64,8 +81,11 @@ func (d *Dict) Get(key interface{}, alt ...interface{}) interface{} {
 	if d.IsEmpty() {
 		return nil
 	}
+
 	h, ok := d.GetKeyID(key)
 	if ok {
+		d.mu.RLock()
+		defer d.mu.RUnlock()
 		return d.values[h]
 	}
 	if alt != nil {
@@ -80,16 +100,21 @@ func (d *Dict) GetKeyID(key interface{}) (uint64, bool) {
 	if d.IsEmpty() {
 		return 0, false
 	}
+
 	k := MakeKey(key)
 	if k == nil {
 		return 0, false
 	}
+
+	d.mu.RLock()
 	_, ok := d.values[k.ID]
+	d.mu.RUnlock()
+
 	return k.ID, ok
 }
 
 func (d *Dict) deleteItem(idx int) {
-	if d.IsEmpty() || idx >= d.size {
+	if d.IsEmpty() || idx >= d.Len() {
 		return
 	}
 
@@ -98,8 +123,8 @@ func (d *Dict) deleteItem(idx int) {
 	l := len(d.keys)
 	d.keys[l-1] = nil
 	d.keys = d.keys[:l-1]
-	d.size = l
-	d.version++
+	atomic.StoreInt64(&d.size, int64(l-1))
+	atomic.AddInt64(&d.version, 1)
 }
 
 // Del removes an item from dict by key name.
@@ -110,14 +135,18 @@ func (d *Dict) Del(key interface{}) bool {
 		return false
 	}
 
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
 	var idx int
 	for i := range d.keys {
 		if d.keys[i].ID == id {
 			idx = i
 			break
 		}
 	}
-	if idx > d.size || d.keys[idx].ID != id {
+
+	if idx >= len(d.keys) || d.keys[idx].ID != id {
 		return false
 	}
 
@@ -143,9 +172,17 @@ func (d *Dict) PopItem() *Item {
 		return nil
 	}
 
-	key := d.keys[d.size-1]
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	size := len(d.keys)
+	if size == 0 {
+		return nil
+	}
+
+	key := d.keys[size-1]
 	value := d.values[key.ID]
-	d.deleteItem(d.size - 1)
+	d.deleteItem(size - 1)
 
 	return &Item{
 		Key:   key.Name,
@@ -161,7 +198,7 @@ func (d *Dict) Key(key interface{}) bool {
 
 // IsEmpty returns true if the dict is empty, false otherwise.
 func (d *Dict) IsEmpty() bool {
-	return d == nil || d.size == 0
+	return d == nil || d.Len() == 0
 }
 
 // Clear empties a Dict d.
@@ -170,8 +207,13 @@ func (d *Dict) Clear() bool {
 	if d.IsEmpty() {
 		return false
 	}
-	d.size = 0
-	d.version++ // not a new dict
+
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	atomic.StoreInt64(&d.size, 0)
+	atomic.AddInt64(&d.version, 1)
+
 	d.keys = []*Key{}
 	d.values = make(map[uint64]interface{})
 	return true
@@ -182,7 +224,11 @@ func (d *Dict) Keys() []string {
 	if d.IsEmpty() {
 		return nil
 	}
-	keys := make([]string, d.size)
+
+	d.mu.RLock()
+	defer d.mu.RUnlock()
+
+	keys := make([]string, d.Len())
 	for i := range d.keys {
 		keys[i] = d.keys[i].Name
 	}
@@ -194,7 +240,11 @@ func (d *Dict) Values() []interface{} {
 	if d.IsEmpty() {
 		return nil
 	}
-	values := make([]interface{}, d.size)
+
+	d.mu.RLock()
+	defer d.mu.RUnlock()
+
+	values := make([]interface{}, d.Len())
 	for i, key := range d.keys {
 		values[i] = d.values[key.ID]
 	}
@@ -204,17 +254,29 @@ func (d *Dict) Values() []interface{} {
 // Items returns a channel of key-value items, or nil if the dict is empty.
 func (d *Dict) Items() <-chan Item {
 	ci := make(chan Item)
+	if d.IsEmpty() {
+		close(ci)
+		return ci
+	}
+
+	// Avoid lock contention
+	d.mu.RLock()
+	items := make([]Item, len(d.keys))
+	for i := range d.keys {
+		items[i] = Item{
+			Key:   d.keys[i].Name,
+			Value: d.values[d.keys[i].ID],
+		}
+	}
+	d.mu.RUnlock()
 
 	go func() {
 		defer close(ci)
-		if d.IsEmpty() {
+		if len(items) == 0 {
 			return
 		}
-		for i := range d.keys {
-			ci <- Item{
-				Key:   d.keys[i].Name,
-				Value: d.values[d.keys[i].ID],
-			}
+		for _, item := range items {
+			ci <- item
 		}
 	}()
 
@@ -241,14 +303,16 @@ func (d *Dict) Update(vargs ...interface{}) bool {
 		// iterables and scalars
 		for item := range toIterable(vargs[i]) {
 			if item.Key == nil {
-				item.Key = d.size
+				item.Key = d.Len()
 			}
 			d.Set(item.Key, item.Value)
 		}
 	}
 	return ver != d.Version()
 }
 
+// String implements the fmt.Stringer interface to print d similar to a Python dict.
+// Returns a formatted string with the keys and values of the dict.
 func (d *Dict) String() string {
 	items := make([]string, 0, d.Len())
 	for item := range d.Items() {