Add some Generics (#11)

Author: Dean Karn

.github/workflows/go.yml

@@ -8,7 +8,7 @@ jobs:
   test:
     strategy:
       matrix:
-        go-version: [1.17.x,1.16.x]
+        go-version: [1.18.x,1.17.x]
         os: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     steps:

Makefile

@@ -4,6 +4,6 @@ test:
 	$(GOCMD) test -cover -race ./...
 
 bench:
-	$(GOCMD) test -bench=. -benchmem ./...
+	$(GOCMD) test -run=NONE -bench=. -benchmem  ./...
 
 .PHONY: linters-install lint test bench

README.md

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

go.mod

@@ -5,4 +5,4 @@ require (
 	github.com/go-playground/form/v4 v4.2.0
 )
 
-go 1.17
+go 1.18

go.sum

@@ -1,6 +1,4 @@
 github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A=
 github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
-github.com/go-playground/form/v4 v4.1.1 h1:1T9lGt3WRHuDwT5uwx7RYQZfxVwWZhF0DC1ovKyNnWY=
-github.com/go-playground/form/v4 v4.1.1/go.mod h1:q1a2BY+AQUUzhl6xA/6hBetay6dEIhMHjgvJiGo6K7U=
 github.com/go-playground/form/v4 v4.2.0 h1:N1wh+Goz61e6w66vo8vJkQt+uwZSoLz50kZPJWR8eic=
 github.com/go-playground/form/v4 v4.2.0/go.mod h1:q1a2BY+AQUUzhl6xA/6hBetay6dEIhMHjgvJiGo6K7U=

net/http/helpers.go

@@ -216,7 +216,7 @@ func DecodeMultipartForm(r *http.Request, qp QueryParamsOption, maxMemory int64,
 // The Content-Type e.g. "application/json" and http method are not checked.
 //
 // NOTE: when includeQueryParams=true query params will be parsed and included eg. route /user?test=true 'test'
-// is added to parsed JSON and replaces any value that may have been present
+// is added to parsed JSON and replaces any values that may have been present
 func DecodeJSON(r *http.Request, qp QueryParamsOption, maxMemory int64, v interface{}) (err error) {
 	var body io.Reader = r.Body
 	if encoding := r.Header.Get(ContentEncoding); encoding == Gzip {
@@ -243,7 +243,7 @@ func DecodeJSON(r *http.Request, qp QueryParamsOption, maxMemory int64, v interf
 // The Content-Type e.g. "application/xml" and http method are not checked.
 //
 // NOTE: when includeQueryParams=true query params will be parsed and included eg. route /user?test=true 'test'
-// is added to parsed XML and replaces any value that may have been present
+// is added to parsed XML and replaces any values that may have been present
 func DecodeXML(r *http.Request, qp QueryParamsOption, maxMemory int64, v interface{}) (err error) {
 	var body io.Reader = r.Body
 	if encoding := r.Header.Get(ContentEncoding); encoding == Gzip {
@@ -283,7 +283,7 @@ const (
 // This default to parsing query params if includeQueryParams=true and no other content type matches.
 //
 // NOTE: when includeQueryParams=true query params will be parsed and included eg. route /user?test=true 'test'
-// is added to parsed XML and replaces any value that may have been present
+// is added to parsed XML and replaces any values that may have been present
 func Decode(r *http.Request, qp QueryParamsOption, maxMemory int64, v interface{}) (err error) {
 	typ := r.Header.Get(ContentType)
 	if idx := strings.Index(typ, ";"); idx != -1 {

net/http/helpers_test.go

@@ -284,7 +284,7 @@ func TestDecode(t *testing.T) {
 
 	// test Form decode
 	form := url.Values{}
-	form.Add("Posted", "value")
+	form.Add("Posted", "values")
 
 	test = new(TestStruct)
 	r, _ = http.NewRequest(http.MethodPost, "/decode-query?id=13", strings.NewReader(form.Encode()))
@@ -293,7 +293,7 @@ func TestDecode(t *testing.T) {
 	mux.ServeHTTP(w, r)
 	Equal(t, w.Code, http.StatusOK)
 	Equal(t, test.ID, 13)
-	Equal(t, test.Posted, "value")
+	Equal(t, test.Posted, "values")
 	Equal(t, test.MultiPartPosted, "")
 
 	test = new(TestStruct)
@@ -303,14 +303,14 @@ func TestDecode(t *testing.T) {
 	mux.ServeHTTP(w, r)
 	Equal(t, w.Code, http.StatusOK)
 	Equal(t, test.ID, 0)
-	Equal(t, test.Posted, "value")
+	Equal(t, test.Posted, "values")
 	Equal(t, test.MultiPartPosted, "")
 
 	// test MultipartForm
 	body := &bytes.Buffer{}
 	writer := multipart.NewWriter(body)
 
-	err := writer.WriteField("MultiPartPosted", "value")
+	err := writer.WriteField("MultiPartPosted", "values")
 	Equal(t, err, nil)
 
 	// Don't forget to close the multipart writer.
@@ -326,12 +326,12 @@ func TestDecode(t *testing.T) {
 	Equal(t, w.Code, http.StatusOK)
 	Equal(t, test.ID, 12)
 	Equal(t, test.Posted, "")
-	Equal(t, test.MultiPartPosted, "value")
+	Equal(t, test.MultiPartPosted, "values")
 
 	body = &bytes.Buffer{}
 	writer = multipart.NewWriter(body)
 
-	err = writer.WriteField("MultiPartPosted", "value")
+	err = writer.WriteField("MultiPartPosted", "values")
 	Equal(t, err, nil)
 
 	// Don't forget to close the multipart writer.
@@ -347,19 +347,19 @@ func TestDecode(t *testing.T) {
 	Equal(t, w.Code, http.StatusOK)
 	Equal(t, test.ID, 0)
 	Equal(t, test.Posted, "")
-	Equal(t, test.MultiPartPosted, "value")
+	Equal(t, test.MultiPartPosted, "values")
 
 	// test JSON
-	jsonBody := `{"ID":13,"Posted":"value","MultiPartPosted":"value"}`
+	jsonBody := `{"ID":13,"Posted":"values","MultiPartPosted":"values"}`
 	test = new(TestStruct)
 	r, _ = http.NewRequest(http.MethodPost, "/decode-query?id=13", strings.NewReader(jsonBody))
 	r.Header.Set(ContentType, ApplicationJSON)
 	w = httptest.NewRecorder()
 	mux.ServeHTTP(w, r)
 	Equal(t, w.Code, http.StatusOK)
 	Equal(t, test.ID, 13)
-	Equal(t, test.Posted, "value")
-	Equal(t, test.MultiPartPosted, "value")
+	Equal(t, test.Posted, "values")
+	Equal(t, test.MultiPartPosted, "values")
 
 	var buff bytes.Buffer
 	gzw := gzip.NewWriter(&buff)
@@ -380,8 +380,8 @@ func TestDecode(t *testing.T) {
 	mux.ServeHTTP(w, r)
 	Equal(t, w.Code, http.StatusOK)
 	Equal(t, test.ID, 14)
-	Equal(t, test.Posted, "value")
-	Equal(t, test.MultiPartPosted, "value")
+	Equal(t, test.Posted, "values")
+	Equal(t, test.MultiPartPosted, "values")
 
 	test = new(TestStruct)
 	r, _ = http.NewRequest(http.MethodPost, "/decode-noquery?id=14", strings.NewReader(jsonBody))
@@ -390,20 +390,20 @@ func TestDecode(t *testing.T) {
 	mux.ServeHTTP(w, r)
 	Equal(t, w.Code, http.StatusOK)
 	Equal(t, test.ID, 13)
-	Equal(t, test.Posted, "value")
-	Equal(t, test.MultiPartPosted, "value")
+	Equal(t, test.Posted, "values")
+	Equal(t, test.MultiPartPosted, "values")
 
 	// test XML
-	xmlBody := `<TestStruct><ID>13</ID><Posted>value</Posted><MultiPartPosted>value</MultiPartPosted></TestStruct>`
+	xmlBody := `<TestStruct><ID>13</ID><Posted>values</Posted><MultiPartPosted>values</MultiPartPosted></TestStruct>`
 	test = new(TestStruct)
 	r, _ = http.NewRequest(http.MethodPost, "/decode-noquery?id=14", strings.NewReader(xmlBody))
 	r.Header.Set(ContentType, ApplicationXML)
 	w = httptest.NewRecorder()
 	mux.ServeHTTP(w, r)
 	Equal(t, w.Code, http.StatusOK)
 	Equal(t, test.ID, 13)
-	Equal(t, test.Posted, "value")
-	Equal(t, test.MultiPartPosted, "value")
+	Equal(t, test.Posted, "values")
+	Equal(t, test.MultiPartPosted, "values")
 
 	test = new(TestStruct)
 	r, _ = http.NewRequest(http.MethodPost, "/decode-query?id=14", strings.NewReader(xmlBody))
@@ -412,8 +412,8 @@ func TestDecode(t *testing.T) {
 	mux.ServeHTTP(w, r)
 	Equal(t, w.Code, http.StatusOK)
 	Equal(t, test.ID, 14)
-	Equal(t, test.Posted, "value")
-	Equal(t, test.MultiPartPosted, "value")
+	Equal(t, test.Posted, "values")
+	Equal(t, test.MultiPartPosted, "values")
 
 	buff.Reset()
 	gzw = gzip.NewWriter(&buff)
@@ -434,6 +434,6 @@ func TestDecode(t *testing.T) {
 	mux.ServeHTTP(w, r)
 	Equal(t, w.Code, http.StatusOK)
 	Equal(t, test.ID, 13)
-	Equal(t, test.Posted, "value")
-	Equal(t, test.MultiPartPosted, "value")
+	Equal(t, test.Posted, "values")
+	Equal(t, test.MultiPartPosted, "values")
 }

net/http/quality_value.go

@@ -7,14 +7,14 @@ const (
 	QualityValueFormat = "%s;q=%1.3g"
 )
 
-// QualityValue accepts a value to add/concatenate a quality value to and
-// the quality value itself.
+// QualityValue accepts a values to add/concatenate a quality values to and
+// the quality values itself.
 func QualityValue(v string, qv float32) string {
 	if qv > 1 {
-		qv = 1 // highest possible value
+		qv = 1 // highest possible values
 	}
 	if qv < 0.001 {
-		qv = 0.001 // lowest possible value
+		qv = 0.001 // lowest possible values
 	}
 	return fmt.Sprintf(QualityValueFormat, v, qv)
 }

sync/mutex.go

@@ -0,0 +1,130 @@
+//go:build go1.18
+
+package sync
+
+import (
+	"sync"
+
+	"github.com/go-playground/pkg/v5/values/result"
+)
+
+// NewMutex creates a new Mutex for use.
+func NewMutex[T any](value T) *Mutex[T] {
+	return &Mutex[T]{
+		value: value,
+	}
+}
+
+// Mutex creates a type safe mutex wrapper ensuring one cannot access the values of a locked values
+// without first gaining a lock.
+type Mutex[T any] struct {
+	m     sync.Mutex
+	value T
+}
+
+// PerformMut safely locks and unlocks the Mutex values and performs the provided function.
+//
+// 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() {
+	m.m.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 *Mutex[T]) TryLock() result.Result[T, struct{}] {
+	if m.m.TryLock() {
+		return result.Ok[T, struct{}](m.value)
+	} else {
+		return result.Err[T, struct{}](struct{}{})
+	}
+}
+
+// NewRWMutex creates a new RWMutex for use.
+func NewRWMutex[T any](value T) *RWMutex[T] {
+	return &RWMutex[T]{
+		value: value,
+	}
+}
+
+// RWMutex creates a type safe RWMutex wrapper ensuring one cannot access the values of a locked values
+// without first gaining a lock.
+type RWMutex[T any] struct {
+	rw    sync.RWMutex
+	value T
+}
+
+// PerformMut safely locks and unlocks the RWMutex mutable values and performs the provided function.
+//
+// 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.
+func (m *RWMutex[T]) Lock() T {
+	m.rw.Lock()
+	return m.value
+}
+
+// Unlock unlocks mutable lock for values.
+func (m *RWMutex[T]) Unlock() {
+	m.rw.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 *RWMutex[T]) TryLock() result.Result[T, struct{}] {
+	if m.rw.TryLock() {
+		return result.Ok[T, struct{}](m.value)
+	} else {
+		return result.Err[T, struct{}](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)
+}
+
+// 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 *RWMutex[T]) RLock() 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 *RWMutex[T]) RUnlock() {
+	m.rw.RUnlock()
+}
+
+// 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 *RWMutex[T]) TryRLock() result.Result[T, struct{}] {
+	if m.rw.TryRLock() {
+		return result.Ok[T, struct{}](m.value)
+	} else {
+		return result.Err[T, struct{}](struct{}{})
+	}
+}

sync/mutex_test.go

@@ -0,0 +1,45 @@
+//go:build go1.18
+
+package sync
+
+import (
+	"testing"
+
+	. "github.com/go-playground/assert/v2"
+)
+
+func TestMutex(t *testing.T) {
+	m := NewMutex(make(map[string]int))
+	m.Lock()["foo"] = 1
+	m.Unlock()
+
+	m.PerformMut(func(m map[string]int) {
+		m["boo"] = 1
+	})
+
+	myMap := m.Lock()
+	Equal(t, 2, len(myMap))
+	m.Unlock()
+}
+
+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.PerformMut(func(m map[string]int) {
+		m["boo"] = 2
+	})
+
+	myMap := m.RLock()
+	Equal(t, len(myMap), 2)
+	Equal(t, m.TryRLock().IsOk(), true)
+	m.RUnlock()
+
+	m.Perform(func(m map[string]int) {
+		Equal(t, 1, m["foo"])
+		Equal(t, 2, m["boo"])
+	})
+}