make it safer (#27)

Author: Dean Karn

CHANGELOG.md

@@ -6,6 +6,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [5.15.1] - 2023-03-06
+### Fixed
+- New Mutex2 functions and guards; checked in the wrong code accidentally last commit.
+
 ## [5.15.0] - 2023-03-05
 ### Added
 - New Mutex2 and RWMutex2 which corrects the original Mutex's design issues.
@@ -15,6 +19,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Added `timext.NanoTime` for fast low level monotonic time with nanosecond precision.
 
-[Unreleased]: https://github.com/go-playground/pkg/compare/v5.15.0...HEAD
+[Unreleased]: https://github.com/go-playground/pkg/compare/v5.15.1...HEAD
+[5.15.1]: https://github.com/go-playground/pkg/compare/v5.15.0...v5.15.1
 [5.15.0]: https://github.com/go-playground/pkg/compare/v5.14.0...v5.15.0
 [5.14.0]: https://github.com/go-playground/pkg/commit/v5.14.0

README.md

@@ -1,6 +1,6 @@
 # pkg
 
-![Project status](https://img.shields.io/badge/version-5.15.0-green.svg)
+![Project status](https://img.shields.io/badge/version-5.15.1-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/mutex2.go

@@ -9,131 +9,163 @@ import (
 	resultext "github.com/go-playground/pkg/v5/values/result"
 )
 
+// MutexGuard protects the inner contents of a Mutex2 for safety and unlocking.
+type MutexGuard[T any, M interface{ Unlock() }] struct {
+	m M
+	// T is the inner generic type of the Mutex
+	T T
+}
+
+// Unlock unlocks the Mutex2 value.
+func (g MutexGuard[T, M]) Unlock() {
+	g.m.Unlock()
+}
+
 // NewMutex2 creates a new Mutex for use.
-func NewMutex2[T any](value T) *Mutex2[T] {
-	return &Mutex2[T]{
+func NewMutex2[T any, M *sync.Mutex](value T) Mutex2[T, M] {
+	return Mutex2[T, M]{
+		m:     new(sync.Mutex),
 		value: value,
 	}
 }
 
 // Mutex2 creates a type safe mutex wrapper ensuring one cannot access the values of a locked values
 // without first gaining a lock.
-type Mutex2[T any] struct {
-	m     sync.Mutex
+type Mutex2[T any, M *sync.Mutex] struct {
+	m     *sync.Mutex
 	value T
 }
 
 // Lock locks the Mutex and returns value for use, safe for mutation if
 //
 // If the lock is already in use, the calling goroutine blocks until the mutex is available.
-func (m *Mutex2[T]) Lock() T {
+func (m Mutex2[T, M]) Lock() MutexGuard[T, *sync.Mutex] {
 	m.m.Lock()
-	return m.value
+	return MutexGuard[T, *sync.Mutex]{
+		m: m.m,
+		T: m.value,
+	}
 }
 
-// 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 *Mutex2[T]) Unlock() {
-	m.m.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 Mutex2[T]) Unlock() {
+//	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 *Mutex2[T]) PerformMut(f func(T)) {
-	f(m.Lock())
-	m.Unlock()
+func (m Mutex2[T, M]) PerformMut(f func(T)) {
+	guard := m.Lock()
+	f(guard.T)
+	guard.Unlock()
 }
 
 // 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 *Mutex2[T]) TryLock() resultext.Result[T, struct{}] {
+func (m Mutex2[T, M]) TryLock() resultext.Result[MutexGuard[T, *sync.Mutex], struct{}] {
 	if m.m.TryLock() {
-		return resultext.Ok[T, struct{}](m.value)
+		return resultext.Ok[MutexGuard[T, *sync.Mutex], struct{}](MutexGuard[T, *sync.Mutex]{
+			m: m.m,
+			T: m.value,
+		})
 	} else {
-		return resultext.Err[T, struct{}](struct{}{})
+		return resultext.Err[MutexGuard[T, *sync.Mutex], struct{}](struct{}{})
 	}
 }
 
+// RMutexGuard protects the inner contents of a RWMutex2 for safety and unlocking.
+type RMutexGuard[T any] struct {
+	rw *sync.RWMutex
+	// T is the inner generic type of the Mutex
+	T T
+}
+
+// RUnlock unlocks the RWMutex2 value.
+func (g RMutexGuard[T]) RUnlock() {
+	g.rw.RUnlock()
+}
+
 // NewRWMutex2 creates a new RWMutex for use.
-func NewRWMutex2[T any](value T) *RWMutex2[T] {
-	return &RWMutex2[T]{
+func NewRWMutex2[T any](value T) RWMutex2[T] {
+	return RWMutex2[T]{
+		rw:    new(sync.RWMutex),
 		value: value,
 	}
 }
 
 // RWMutex2 creates a type safe RWMutex wrapper ensuring one cannot access the values of a locked values
 // without first gaining a lock.
 type RWMutex2[T any] struct {
-	rw    sync.RWMutex
+	rw    *sync.RWMutex
 	value T
 }
 
 // Lock locks the Mutex and returns value for use, safe for mutation if
 //
 // If the lock is already in use, the calling goroutine blocks until the mutex is available.
-func (m *RWMutex2[T]) Lock() T {
+func (m RWMutex2[T]) Lock() MutexGuard[T, *sync.RWMutex] {
 	m.rw.Lock()
-	return m.value
-}
-
-// 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 *RWMutex2[T]) Unlock() {
-	m.rw.Unlock()
+	return MutexGuard[T, *sync.RWMutex]{
+		m: m.rw,
+		T: m.value,
+	}
 }
 
 // PerformMut safely locks and unlocks the RWMutex mutable values and performs the provided function.
-func (m *RWMutex2[T]) PerformMut(f func(T)) {
-	f(m.Lock())
-	m.Unlock()
+func (m RWMutex2[T]) PerformMut(f func(T)) {
+	guard := m.Lock()
+	f(guard.T)
+	guard.Unlock()
 }
 
 // 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 *RWMutex2[T]) TryLock() resultext.Result[T, struct{}] {
+func (m RWMutex2[T]) TryLock() resultext.Result[MutexGuard[T, *sync.RWMutex], struct{}] {
 	if m.rw.TryLock() {
-		return resultext.Ok[T, struct{}](m.value)
+		return resultext.Ok[MutexGuard[T, *sync.RWMutex], struct{}](
+			MutexGuard[T, *sync.RWMutex]{
+				m: m.rw,
+				T: m.value,
+			})
 	} else {
-		return resultext.Err[T, struct{}](struct{}{})
+		return resultext.Err[MutexGuard[T, *sync.RWMutex], struct{}](struct{}{})
 	}
 }
 
 // Perform safely locks and unlocks the RWMutex read-only values and performs the provided function.
-func (m *RWMutex2[T]) Perform(f func(T)) {
-	result := m.RLock()
-	f(result)
-	m.RUnlock()
+func (m RWMutex2[T]) Perform(f func(T)) {
+	guard := m.RLock()
+	f(guard.T)
+	guard.RUnlock()
 }
 
 // RLock locks the RWMutex for reading and returns the value for read-only use.
 // It should not be used for recursive read locking; a blocked Lock call excludes new readers from acquiring the lock
-func (m *RWMutex2[T]) RLock() T {
+func (m RWMutex2[T]) RLock() RMutexGuard[T] {
 	m.rw.RLock()
-	return m.value
-}
-
-// RUnlock undoes a single RLock call; it does not affect other simultaneous readers.
-// It is a run-time error if rw is not locked for reading on entry to RUnlock.
-func (m *RWMutex2[T]) RUnlock() {
-	m.rw.RUnlock()
+	return RMutexGuard[T]{
+		rw: m.rw,
+		T:  m.value,
+	}
 }
 
 // TryRLock tries to lock RWMutex for reading 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 *RWMutex2[T]) TryRLock() resultext.Result[T, struct{}] {
+func (m RWMutex2[T]) TryRLock() resultext.Result[RMutexGuard[T], struct{}] {
 	if m.rw.TryRLock() {
-		return resultext.Ok[T, struct{}](m.value)
+		return resultext.Ok[RMutexGuard[T], struct{}](
+			RMutexGuard[T]{
+				rw: m.rw,
+				T:  m.value,
+			},
+		)
 	} else {
-		return resultext.Err[T, struct{}](struct{}{})
+		return resultext.Err[RMutexGuard[T], struct{}](struct{}{})
 	}
 }

sync/mutex2_test.go

@@ -5,58 +5,65 @@ package syncext
 
 import (
 	resultext "github.com/go-playground/pkg/v5/values/result"
+	"sync"
 	"testing"
 
 	. "github.com/go-playground/assert/v2"
 )
 
 func TestMutex2(t *testing.T) {
 	m := NewMutex2(make(map[string]int))
-	m.Lock()["foo"] = 1
-	m.Unlock()
+	guard := m.Lock()
+	guard.T["foo"] = 1
+	guard.Unlock()
 
 	m.PerformMut(func(m map[string]int) {
 		m["boo"] = 1
 	})
-	myMap := m.Lock()
+	guard = m.Lock()
+	myMap := guard.T
 	Equal(t, 2, len(myMap))
 	Equal(t, myMap["foo"], 1)
 	Equal(t, myMap["boo"], 1)
-	Equal(t, m.TryLock(), resultext.Err[map[string]int](struct{}{}))
-	m.Unlock()
+	Equal(t, m.TryLock(), resultext.Err[MutexGuard[map[string]int, *sync.Mutex]](struct{}{}))
+	guard.Unlock()
 
 	result := m.TryLock()
 	Equal(t, result.IsOk(), true)
-	m.Unlock()
+	result.Unwrap().Unlock()
 }
 
 func TestRWMutex2(t *testing.T) {
 	m := NewRWMutex2(make(map[string]int))
-	m.Lock()["foo"] = 1
+	guard := m.Lock()
+	guard.T["foo"] = 1
 	Equal(t, m.TryLock().IsOk(), false)
 	Equal(t, m.TryRLock().IsOk(), false)
-	m.Unlock()
+	guard.Unlock()
 
 	m.PerformMut(func(m map[string]int) {
 		m["boo"] = 2
 	})
-	mp := m.Lock()
+	guard = m.Lock()
+	mp := guard.T
 	Equal(t, mp["foo"], 1)
 	Equal(t, mp["boo"], 2)
-	m.Unlock()
+	guard.Unlock()
 
-	myMap := m.RLock()
+	rguard := m.RLock()
+	myMap := rguard.T
 	Equal(t, len(myMap), 2)
 	Equal(t, m.TryRLock().IsOk(), true)
-	m.RUnlock()
+	rguard.RUnlock()
 
 	m.Perform(func(m map[string]int) {
 		Equal(t, 1, m["foo"])
 		Equal(t, 2, m["boo"])
 	})
-	myMap = m.RLock()
+	rguard = m.RLock()
+	myMap = rguard.T
 	Equal(t, len(myMap), 2)
 	Equal(t, myMap["foo"], 1)
 	Equal(t, myMap["boo"], 2)
-	m.RUnlock()
+	rguard.RUnlock()
 }