support go 1.18

Author: csimplestring

README.md

@@ -78,8 +78,13 @@ See all the details: [link](https://github.com/CppCon/CppCon2015/blob/master/Pre
 
 # How
 
+After go 1.18 
 ```bash
-go get github.com/csimplestring/go-left-right
+go get github.com/csimplestring/[email protected]
+```
+Before go 1.18
+```bash
+go get github.com/csimplestring/[email protected]
 ```
 
 Then you can use it to wrap any data structures. See the below example.
@@ -89,7 +94,7 @@ Then you can use it to wrap any data structures. See the below example.
 import github.com/csimplestring/go-left-right/primitive
 
 type LRMap struct {
-	*primitive.LeftRightPrimitive
+	*primitive.LeftRightPrimitive[map[int]int]
 
     // you have to provides 2 identical instances
 	left  map[int]int
@@ -103,26 +108,24 @@ func newIntMap() *LRMap {
 		right: make(map[int]int),
 	}
 
-	m.LeftRightPrimitive = primitive.New()
+	m.LeftRightPrimitive = primitive.New[map[int]int]()
 
 	return m
 }
 
 func (lr *LRMap) Get(k int) (val int, exist bool) {
 
     // Go does not have generics, so have to use interface{} for lambda's arguments
-	lr.ApplyReadFn(lr.left, lr.right, func(instance interface{}) {
-		m := instance.(map[int]int)
-		val, exist = m[k]
+	lr.ApplyReadFn(lr.left, lr.right, func(instance map[int]int) {
+		val, exist = instance[k]
 	})
 
 	return
 }
 
 func (lr *LRMap) Put(key, val int) {
-	lr.ApplyWriteFn(lr.left, lr.right, func(instance interface{}) {
-		m := instance.(map[int]int)
-		m[key] = val
+	lr.ApplyWriteFn(lr.left, lr.right, func(instance map[int]int) {
+		instance[key] = val
 	})
 }
 ```

go.mod

@@ -1,5 +1,7 @@
 module github.com/csimplestring/go-left-right
 
-go 1.15
+go 1.18
 
 require github.com/linxGnu/go-adder v0.2.0
+
+require github.com/valyala/fastrand v1.0.0 // indirect

map.go

@@ -4,7 +4,7 @@ import "github.com/csimplestring/go-left-right/primitive"
 
 // LRMap utilises the left-right pattern to handle concurrent read-write.
 type LRMap struct {
-	*primitive.LeftRightPrimitive
+	*primitive.LeftRightPrimitive[map[int]int]
 
 	left  map[int]int
 	right map[int]int
@@ -17,24 +17,23 @@ func newIntMap() *LRMap {
 		right: make(map[int]int),
 	}
 
-	m.LeftRightPrimitive = primitive.New()
+	m.LeftRightPrimitive = primitive.New[map[int]int]()
 
 	return m
 }
 
 func (lr *LRMap) Get(k int) (val int, exist bool) {
 
-	lr.ApplyReadFn(lr.left, lr.right, func(instance interface{}) {
-		m := instance.(map[int]int)
-		val, exist = m[k]
+	lr.ApplyReadFn(lr.left, lr.right, func(instance map[int]int) {
+		val, exist = instance[k]
 	})
 
 	return
 }
 
 func (lr *LRMap) Put(key, val int) {
-	lr.ApplyWriteFn(lr.left, lr.right, func(instance interface{}) {
-		m := instance.(map[int]int)
+	lr.ApplyWriteFn(lr.left, lr.right, func(instance map[int]int) {
+		m := instance
 		m[key] = val
 	})
 }

primitive/primitive.go

@@ -9,7 +9,7 @@ const ReadOnLeft int32 = -1
 const ReadOnRight int32 = 1
 
 // LeftRightPrimitive provides the basic core of the leftt-right pattern.
-type LeftRightPrimitive struct {
+type LeftRightPrimitive[T any] struct {
 	// readIndicators is an array of 2 read-indicators, counting the reader numbers on the left/right instance
 	readIndicators [2]ReadIndicator
 	// versionIndex is the index for readIndicators, 0 means reading on left, 1 means reading on right
@@ -19,9 +19,9 @@ type LeftRightPrimitive struct {
 }
 
 // New creates a LeftRightPrimitive
-func New() *LeftRightPrimitive {
+func New[T any]() *LeftRightPrimitive[T] {
 
-	m := &LeftRightPrimitive{
+	m := &LeftRightPrimitive[T]{
 		readIndicators: [2]ReadIndicator{
 			newDistributedAtomicReadIndicator(),
 			newDistributedAtomicReadIndicator(),
@@ -37,19 +37,19 @@ func New() *LeftRightPrimitive {
 }
 
 // readerArrive shall be called by the reader goroutine before start reading
-func (lr *LeftRightPrimitive) readerArrive() int {
+func (lr *LeftRightPrimitive[T]) readerArrive() int {
 	idx := atomic.LoadInt32(lr.versionIndex)
 	lr.readIndicators[idx].arrive()
 	return int(idx)
 }
 
 // readerDepart shall be called by the reader goroutine after finish reading
-func (lr *LeftRightPrimitive) readerDepart(localVI int) {
+func (lr *LeftRightPrimitive[T]) readerDepart(localVI int) {
 	lr.readIndicators[localVI].depart()
 }
 
 // writerToggleVersionAndWait shall be called by a single writer goroutine when applying the modification
-func (lr *LeftRightPrimitive) writerToggleVersionAndWait() {
+func (lr *LeftRightPrimitive[T]) writerToggleVersionAndWait() {
 
 	localVI := atomic.LoadInt32(lr.versionIndex)
 	prevVI := int(localVI % 2)
@@ -70,7 +70,7 @@ func (lr *LeftRightPrimitive) writerToggleVersionAndWait() {
 }
 
 // ApplyReadFn applies read operation on the chosen instance, oh, I really need generics, interface type is ugly
-func (lr *LeftRightPrimitive) ApplyReadFn(l interface{}, r interface{}, fn func(interface{})) {
+func (lr *LeftRightPrimitive[T]) ApplyReadFn(l T, r T, fn func(T)) {
 
 	lvi := lr.readerArrive()
 
@@ -87,7 +87,7 @@ func (lr *LeftRightPrimitive) ApplyReadFn(l interface{}, r interface{}, fn func(
 
 // ApplyWriteFn applies write operation on the chosen instance, write operation is done twice, on the left and right
 // instance respectively, this might make writing longer, but the readers are wait-free.
-func (lr *LeftRightPrimitive) ApplyWriteFn(l interface{}, r interface{}, fn func(interface{})) {
+func (lr *LeftRightPrimitive[T]) ApplyWriteFn(l T, r T, fn func(T)) {
 
 	side := atomic.LoadInt32(lr.sideToRead)
 	if side == ReadOnLeft {