From a7cb9b50dc3ed9916bc1424df42dbf23caf2fb33 Mon Sep 17 00:00:00 2001
From: Sasha Koshka <sashakoshka@tebibyte.media>
Date: Sun, 22 Dec 2024 19:11:50 -0500
Subject: [PATCH] sync: Rename Locker to Monitor Locker is an interface type in
 the stdlib sync package.

---
 sync/locker.go | 44 ++++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/sync/locker.go b/sync/locker.go
index 57c8d5c..d7712d0 100644
--- a/sync/locker.go
+++ b/sync/locker.go
@@ -2,76 +2,76 @@ package usync
 
 import "sync"
 
-// Locker guards access to a value. It must not be copied after first use.
-type Locker[T any] struct {
+// Monitor guards access to a value. It must not be copied after first use.
+type Monitor[T any] struct {
 	value T
 	mutex sync.Mutex
 }
 
-// NewLocker creates a new locker with the specified value.
-func NewLocker[T any] (value T) Locker[T] {
-	return Locker[T] {
+// NewMonitor creates a new Monitor with the specified value.
+func NewMonitor[T any] (value T) Monitor[T] {
+	return Monitor[T] {
 		value: value,
 	}
 }
 
-// Set sets the value of the locker.
-func (this *Locker[T]) Set (value T) {
+// Set sets the value of the Monitor.
+func (this *Monitor[T]) Set (value T) {
 	this.mutex.Lock()
 	defer this.mutex.Unlock()
 	this.value = value
 }
 
-// Borrow borrows the value from the locker, and returns a function that must
+// Borrow borrows the value from the Monitor, and returns a function that must
 // immediately be deferred, like this:
 //
-//   value, done := locker.Borrow()
+//   value, done := Monitor.Borrow()
 //   defer done()
 //
 // From the time Borrow is called to the time the done function is called, it is
 // safe to access the locked object from within the current goroutine.
-func (this *Locker[T]) Borrow () (T, func ()) {
+func (this *Monitor[T]) Borrow () (T, func ()) {
 	this.mutex.Lock()
 	return this.value, this.mutex.Unlock
 }
 
-// RWLocker guards separate read/write access to a value.
-type RWLocker[T any] struct {
+// RWMonitor guards separate read/write access to a value.
+type RWMonitor[T any] struct {
 	value T
 	mutex sync.RWMutex
 }
 
-// NewRWLocker creates a new locker with the specified value. It must not be
+// NewRWMonitor creates a new Monitor with the specified value. It must not be
 // copied after first use.
-func NewRWLocker[T any] (value T) RWLocker[T] {
-	return RWLocker[T] {
+func NewRWMonitor[T any] (value T) RWMonitor[T] {
+	return RWMonitor[T] {
 		value: value,
 	}
 }
 
-// Set sets the value of the locker.
-func (this *RWLocker[T]) Set (value T) {
+// Set sets the value of the Monitor.
+func (this *RWMonitor[T]) Set (value T) {
 	this.mutex.Lock()
 	defer this.mutex.Unlock()
 	this.value = value
 }
 
-// Borrow borrows the value from the locker for write access, and returns a
+// Borrow borrows the value from the Monitor for write access, and returns a
 // function that must immediately be deferred, like this:
 //
-//   value, done := locker.Borrow()
+//   value, done := Monitor.Borrow()
 //   defer done()
 //
 // From the time Borrow is called to the time the done function is called, it is
 // safe to access the locked object from within the current goroutine.
-func (this *RWLocker[T]) Borrow () (T, func ()) {
+func (this *RWMonitor[T]) Borrow () (T, func ()) {
 	this.mutex.Lock()
 	return this.value, this.mutex.Unlock
 }
 
 // RBorrow is like Borrow, but returns the item for read access only. Do not
-// under any circumstances write to an item returned from this method.
-func (this *RWLocker[T]) RBorrow () (T, func ()) {
+// under any circumstances modify anything returned by this method.
+func (this *RWMonitor[T]) RBorrow () (T, func ()) {
 	this.mutex.Lock()
 	return this.value, this.mutex.Unlock
 }