Fix mutex (#14)

This is a breaking change to the Mutex interface, the previous was not usable in the manner intended.

Author: Dean Karn

.github/workflows/go.yml

@@ -8,28 +8,28 @@ jobs:
   test:
     strategy:
       matrix:
-        go-version: [1.18.x,1.17.x]
+        go-version: [1.19.x,1.18.x,1.17.x]
         os: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Install Go
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v3
         with:
           go-version: ${{ matrix.go-version }}
 
       - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Restore Cache
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: ~/go/pkg/mod
           key: ${{ runner.os }}-v1-go-${{ hashFiles('**/go.sum') }}
           restore-keys: |
             ${{ runner.os }}-v1-go-
 
       - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Test
         run: go test ./...
@@ -38,8 +38,8 @@ jobs:
     name: lint
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v2
+        uses: golangci/golangci-lint-action@v3
         with:
-          version: v1.45.2
+          version: v1.50.1

README.md

@@ -1,6 +1,6 @@
 # pkg
 
-![Project status](https://img.shields.io/badge/version-5.6.1-green.svg)
+![Project status](https://img.shields.io/badge/version-5.6.2-green.svg)
 [![Build Status](https://travis-ci.org/go-playground/pkg.svg?branch=master)](https://travis-ci.org/go-playground/pkg)
 [![Coverage Status](https://coveralls.io/repos/github/go-playground/pkg/badge.svg?branch=master)](https://coveralls.io/github/go-playground/pkg?branch=master)
 [![GoDoc](https://godoc.org/github.com/go-playground/pkg?status.svg)](https://pkg.go.dev/mod/github.com/go-playground/pkg/v5)

sync/mutex.go

@@ -3,6 +3,7 @@
 package syncext
 
 import (
+	optionext "github.com/go-playground/pkg/v5/values/option"
 	"sync"
 
 	resultext "github.com/go-playground/pkg/v5/values/result"
@@ -22,27 +23,41 @@ type Mutex[T any] struct {
 	value T
 }
 
-// PerformMut safely locks and unlocks the Mutex values and performs the provided function.
+// Lock locks the Mutex and returns value for use, safe for mutation if
 //
-// Too bad Go doesn't support PerformMut[R any](func(T) R) R syntax :(
-func (m *Mutex[T]) PerformMut(f func(T)) {
-	m.Lock()
-	defer m.Unlock()
-	f(m.value)
-}
-
-// Lock locks the Mutex and returns value for mutable use.
 // If the lock is already in use, the calling goroutine blocks until the mutex is available.
 func (m *Mutex[T]) Lock() T {
 	m.m.Lock()
 	return m.value
 }
 
-// Unlock unlocks the Mutex. It is a run-time error if the Mutex is not locked on entry to Unlock.
-func (m *Mutex[T]) Unlock() {
+// Unlock unlocks the Mutex accepting a value to set as the new or mutated value.
+// It is optional to pass a new value to be set but NOT required for there reasons:
+// 1. If the internal value is already mutable then no need to set as changes apply as they happen.
+// 2. If there's a failure working with the locked value you may NOT want to set it, but still unlock.
+// 3. Supports locked values that are not mutable.
+//
+// It is a run-time error if the Mutex is not locked on entry to Unlock.
+func (m *Mutex[T]) Unlock(value optionext.Option[T]) {
+	if value.IsSome() {
+		m.value = value.Unwrap()
+	}
 	m.m.Unlock()
 }
 
+// PerformMut safely locks and unlocks the Mutex values and performs the provided function returning its error if one
+// otherwise setting the returned value as the new mutex value.
+func (m *Mutex[T]) PerformMut(f func(T) (T, error)) error {
+	value := m.Lock()
+	result, err := f(value)
+	if err != nil {
+		m.Unlock(optionext.None[T]())
+		return err
+	}
+	m.Unlock(optionext.Some(result))
+	return nil
+}
+
 // TryLock tries to lock Mutex and reports whether it succeeded.
 // If it does the value is returned for use in the Ok result otherwise Err with empty value.
 func (m *Mutex[T]) TryLock() resultext.Result[T, struct{}] {
@@ -67,26 +82,40 @@ type RWMutex[T any] struct {
 	value T
 }
 
-// PerformMut safely locks and unlocks the RWMutex mutable values and performs the provided function.
+// Lock locks the Mutex and returns value for use, safe for mutation if
 //
-// Too bad Go doesn't support PerformMut[R any](func(T) R) R syntax :(
-func (m *RWMutex[T]) PerformMut(f func(T)) {
-	m.Lock()
-	defer m.Unlock()
-	f(m.value)
-}
-
-// Lock locks mutex and returns values for mutable use.
+// If the lock is already in use, the calling goroutine blocks until the mutex is available.
 func (m *RWMutex[T]) Lock() T {
 	m.rw.Lock()
 	return m.value
 }
 
-// Unlock unlocks mutable lock for values.
-func (m *RWMutex[T]) Unlock() {
+// Unlock unlocks the Mutex accepting a value to set as the new or mutated value.
+// It is optional to pass a new value to be set but NOT required for there reasons:
+// 1. If the internal value is already mutable then no need to set as changes apply as they happen.
+// 2. If there's a failure working with the locked value you may NOT want to set it, but still unlock.
+// 3. Supports locked values that are not mutable.
+//
+// It is a run-time error if the Mutex is not locked on entry to Unlock.
+func (m *RWMutex[T]) Unlock(value optionext.Option[T]) {
+	if value.IsSome() {
+		m.value = value.Unwrap()
+	}
 	m.rw.Unlock()
 }
 
+// PerformMut safely locks and unlocks the RWMutex mutable values and performs the provided function.
+func (m *RWMutex[T]) PerformMut(f func(T) (T, error)) error {
+	value := m.Lock()
+	result, err := f(value)
+	if err != nil {
+		m.Unlock(optionext.None[T]())
+		return err
+	}
+	m.Unlock(optionext.Some(result))
+	return nil
+}
+
 // TryLock tries to lock RWMutex and returns the value in the Ok result if successful.
 // If it does the value is returned for use in the Ok result otherwise Err with empty value.
 func (m *RWMutex[T]) TryLock() resultext.Result[T, struct{}] {
@@ -98,12 +127,15 @@ func (m *RWMutex[T]) TryLock() resultext.Result[T, struct{}] {
 }
 
 // Perform safely locks and unlocks the RWMutex read-only values and performs the provided function.
-//
-// Too bad Go doesn't support Perform[R any](func(T) R) R syntax :(
-func (m *RWMutex[T]) Perform(f func(T)) {
-	m.RLock()
-	defer m.RUnlock()
-	f(m.value)
+func (m *RWMutex[T]) Perform(f func(T) error) error {
+	result := m.RLock()
+	err := f(result)
+	if err != nil {
+		m.RUnlock()
+		return err
+	}
+	m.RUnlock()
+	return nil
 }
 
 // RLock locks the RWMutex for reading and returns the value for read-only use.

sync/mutex_test.go

@@ -3,6 +3,7 @@
 package syncext
 
 import (
+	optionext "github.com/go-playground/pkg/v5/values/option"
 	"testing"
 
 	. "github.com/go-playground/assert/v2"
@@ -11,35 +12,41 @@ import (
 func TestMutex(t *testing.T) {
 	m := NewMutex(make(map[string]int))
 	m.Lock()["foo"] = 1
-	m.Unlock()
+	m.Unlock(optionext.None[map[string]int]())
 
-	m.PerformMut(func(m map[string]int) {
+	err := m.PerformMut(func(m map[string]int) (map[string]int, error) {
 		m["boo"] = 1
+		return m, nil
 	})
+	Equal(t, err, nil)
 
 	myMap := m.Lock()
 	Equal(t, 2, len(myMap))
-	m.Unlock()
+	m.Unlock(optionext.None[map[string]int]())
 }
 
 func TestRWMutex(t *testing.T) {
 	m := NewRWMutex(make(map[string]int))
 	m.Lock()["foo"] = 1
 	Equal(t, m.TryLock().IsOk(), false)
 	Equal(t, m.TryRLock().IsOk(), false)
-	m.Unlock()
+	m.Unlock(optionext.None[map[string]int]())
 
-	m.PerformMut(func(m map[string]int) {
+	err := m.PerformMut(func(m map[string]int) (map[string]int, error) {
 		m["boo"] = 2
+		return m, nil
 	})
+	Equal(t, err, nil)
 
 	myMap := m.RLock()
 	Equal(t, len(myMap), 2)
 	Equal(t, m.TryRLock().IsOk(), true)
 	m.RUnlock()
 
-	m.Perform(func(m map[string]int) {
+	err = m.Perform(func(m map[string]int) error {
 		Equal(t, 1, m["foo"])
 		Equal(t, 2, m["boo"])
+		return nil
 	})
+	Equal(t, err, nil)
 }